Fix cloud lists, hidden flex children, ink frames and cleared text fields

- A snapshot listener that throws no longer stalls the action chain waiting
  on the first snapshot; dates in documents read through timeAgo and date.
- A flexing child hidden at runtime gives up its space with flex 0 and a
  zero size, so a visible sibling fills it and a hidden scrollable never
  sees unbounded constraints (a hidden grid computed NaN offsets).
- A sized frame with an ink well fills its size with the ink and children
  instead of shrinking to its unpositioned children, which hid the photo in
  a grid tile when its likes badge was hidden.
- Image fills whose URL path resolves to nothing load no image.
- A text field bound to a text variable clears when the variable is set to
  empty.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VJ3E2NmBuiBkBnmDDmQBcz

Author: claude

lib/src/data/cloud_database.dart

@@ -599,13 +599,22 @@ class FirestoreCloudDatabase extends CloudDatabase {
           'Updating variable ${variable.value.name} with success state.',
           name: name,
         );
-        // Set the variable with success state.
-        variable.set(
-          variable.value.copyWith(
-            value: CloudDatabaseVariableUtils.success(docs),
-          ),
-        );
-        if (!firstSnapshot.isCompleted) firstSnapshot.complete();
+        // Set the variable with success state. The chain waiting on the
+        // first snapshot continues even if a listener of the variable throws.
+        try {
+          variable.set(
+            variable.value.copyWith(
+              value: CloudDatabaseVariableUtils.success(docs),
+            ),
+          );
+        } catch (error, stackTrace) {
+          DebugLogger.instance.printInfo(
+            'Listener of ${variable.value.name} failed: $error\n$stackTrace',
+            name: name,
+          );
+        } finally {
+          if (!firstSnapshot.isCompleted) firstSnapshot.complete();
+        }
       },
       onError: (error) {
         DebugLogger.instance.printInfo(

lib/src/transformers/node_transformers/passive_rectangle_transformer.dart

@@ -144,6 +144,8 @@ class PassiveRectangleWidget extends StatelessWidget {
             stackAlignment: stackAlignment,
             applyPadding: applyPadding,
           ),
+          alignment:
+              stackAlignment.flutterAlignment ?? AlignmentDirectional.topStart,
         ),
       ],
     );
@@ -177,8 +179,9 @@ class PassiveRectangleWidget extends StatelessWidget {
 List<Widget> wrapWithInkWell(
   BuildContext context,
   BaseNode node,
-  List<Widget> children,
-) {
+  List<Widget> children, {
+  AlignmentGeometry alignment = AlignmentDirectional.topStart,
+}) {
   if (node is! ReactionMixin) return children;
 
   final InkWellModel? inkWell = node is BlendMixin ? node.inkWell : null;
@@ -220,10 +223,18 @@ List<Widget> wrapWithInkWell(
       highlightColor: inkWell.highlightColor?.toFlutterColor(),
       hoverColor: inkWell.hoverColor?.toFlutterColor(),
       focusColor: inkWell.focusColor?.toFlutterColor(),
-      child: Stack(children: children),
+      child: Stack(alignment: alignment, children: children),
     ),
   );
 
+  // A node with a set size fills it with its ink and children. Otherwise the
+  // inner stack sizes to its unpositioned children, and when those are
+  // hidden (a likes badge on a photo tile) everything else in it gets no
+  // space.
+  if (node.horizontalFit != SizeFit.shrinkWrap &&
+      node.verticalFit != SizeFit.shrinkWrap) {
+    return [Positioned.fill(child: widget)];
+  }
   return [widget];
 }
 
@@ -720,6 +731,11 @@ Widget buildFill(
         nullSubstitutionMode: settings.nullSubstitutionMode,
         scopedValues: scopedValues,
       );
+      // A URL path that resolves to nothing, like a cover that isn't set
+      // yet, has no image to load.
+      if (bytes == null && imageURL.trim().isEmpty) {
+        return const SizedBox.shrink();
+      }
       Widget child;
 
       if (imageFillBuilder != null) {

lib/src/transformers/node_transformers/passive_row_column_transformer.dart

@@ -285,6 +285,45 @@ class PassiveRowColumnWidget extends StatelessWidget {
   final NodeTransformerManager manager;
   final WidgetBuildSettings settings;
 
+  /// A flexing child hidden at runtime gives up its share of the free space,
+  /// so a visible sibling (an empty state next to a hidden spinner) can take
+  /// all of it. The flex drops to zero rather than removing the [Flexible] so
+  /// the child keeps its state when it shows again.
+  Widget _collapseWhenHidden(
+    BuildContext context,
+    BaseNode child,
+    Widget sizedWidget,
+  ) {
+    final NodeTransformerManager manager = this.manager;
+    if (sizedWidget is! Flexible || manager is! PassiveNodeTransformerManager) {
+      return sizedWidget;
+    }
+
+    Widget buildFlexible(BuildContext context) {
+      final bool hidden = manager.runtimeVisibility(context, child) == false;
+      // Without flex the hidden child would be laid out with unbounded
+      // main-axis constraints, which a scrollable inside it can't take
+      // (a hidden grid computed NaN offsets), so it gets no space at all.
+      return Flexible(
+        flex: hidden ? 0 : sizedWidget.flex,
+        fit: sizedWidget.fit,
+        child: SizedBox(
+          width: hidden ? 0 : null,
+          height: hidden ? 0 : null,
+          child: sizedWidget.child,
+        ),
+      );
+    }
+
+    final List<Listenable> listenables = manager.listenablesFor(context, child);
+    if (listenables.isEmpty) return buildFlexible(context);
+    return ManagedListenableBuilder(
+      key: ValueKey('${child.id}-flex'),
+      listenables: listenables,
+      builder: buildFlexible,
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     final List<Widget> widgetChildren = children.map((child) {
@@ -294,12 +333,14 @@ class PassiveRowColumnWidget extends StatelessWidget {
         settings: settings,
       );
 
-      return PassiveRowColumnTransformer.wrapChildWithSizeFits(
-        child,
-        node,
-        builtWidget,
-        child.flex,
-      );
+      final Widget sizedWidget =
+          PassiveRowColumnTransformer.wrapChildWithSizeFits(
+            child,
+            node,
+            builtWidget,
+            child.flex,
+          );
+      return _collapseWhenHidden(context, child, sizedWidget);
     }).toList();
 
     final Widget child = (node is DefaultShapeNode)

lib/src/transformers/node_transformers/passive_text_field_transformer.dart

@@ -175,12 +175,16 @@ class _PassiveTextFieldWidgetState extends State<PassiveTextFieldWidget> {
     // different from the current controller text.
     // widget.node.variables['inputValue'] only works when a sync variable is specified. If it is not then
     // we rely on initial text to be able to see if controller text needs to be updated.
-    String? currentPropertyValue = widget.node.variables['inputValue'] != null
+    final String? boundPath = widget.node.variables['inputValue'];
+    String? currentPropertyValue = boundPath != null
         ? PropertyValueDelegate.getPropertyValue<String>(
-            widget.node,
-            'inputValue',
-            scopedValues: scopedValues,
-          )
+                widget.node,
+                'inputValue',
+                scopedValues: scopedValues,
+              ) ??
+              // An empty text variable reads as null; a field bound to one
+              // still clears, e.g. after a comment is sent.
+              (_isExistingVariable(boundPath, scopedValues) ? '' : null)
         : findIndexedValueIfApplied(scopedValues) ??
               PropertyValueDelegate.getPropertyValueFromNodeValues<String>(
                 widget.node,
@@ -201,6 +205,16 @@ class _PassiveTextFieldWidgetState extends State<PassiveTextFieldWidget> {
     }
   }
 
+  bool _isExistingVariable(String path, ScopedValues scopedValues) {
+    final VariableMatch? match = VariableMatch.parse(
+      path.wrapWithVariableSyntax(),
+    );
+    if (match == null || match.hasPath || match.isPredefinedVariable) {
+      return false;
+    }
+    return scopedValues.variables.values.findByNameOrNull(match.name) != null;
+  }
+
   /// The purpose of this function is to find the indexed value of the variable
   /// 'item' if it is applied to the initial text. This is used to determine if
   /// the controller text needs to be updated when the variable 'inputValue' is

lib/src/transformers/passive_transformer_manager.dart

@@ -137,6 +137,34 @@ class PassiveNodeTransformerManager extends WidgetNodeTransformerManager {
 
     if (!enabled) return const SizedBox.shrink();
 
+    final CodelesslyContext codelesslyContext = context
+        .read<CodelesslyContext>();
+    final List<Listenable> listenables = listenablesFor(context, node);
+
+    return NodeStateProviderWidget(
+      key: ValueKey(node.id),
+      node: node,
+      codelesslyContext: codelesslyContext,
+      child: Builder(
+        builder: (context) {
+          if (listenables.isNotEmpty) {
+            return ManagedListenableBuilder(
+              key: ValueKey(node.id),
+              listenables: listenables,
+              builder: (context) => builder(context),
+            );
+          } else {
+            return builder(context);
+          }
+        },
+      ),
+    );
+  }
+
+  /// Returns what the widget of [node] rebuilds on: the node's local values,
+  /// the variables its properties use and the variables of the conditions
+  /// that affect it.
+  List<Listenable> listenablesFor(BuildContext context, BaseNode node) {
     final CodelesslyContext codelesslyContext = context
         .read<CodelesslyContext>();
 
@@ -251,24 +279,7 @@ class PassiveNodeTransformerManager extends WidgetNodeTransformerManager {
       }
     }
 
-    return NodeStateProviderWidget(
-      key: ValueKey(node.id),
-      node: node,
-      codelesslyContext: codelesslyContext,
-      child: Builder(
-        builder: (context) {
-          if (listenables.isNotEmpty) {
-            return ManagedListenableBuilder(
-              key: ValueKey(node.id),
-              listenables: listenables,
-              builder: (context) => builder(context),
-            );
-          } else {
-            return builder(context);
-          }
-        },
-      ),
-    );
+    return listenables;
   }
 
   Listenable? getStorageListenerFor(VariableMatch match, BuildContext context) {

lib/src/transformers/utils/property_value_delegate.dart

@@ -605,6 +605,11 @@ class PropertyValueDelegate {
         'ceil': value.ceil(),
       },
       bool() => {'toggled': !value},
+      // Cloud documents carry createdAt and updatedAt as dates.
+      DateTime() => {
+        'timeAgo': formatTimeAgo(value),
+        'date': formatDate(value),
+      },
       Map() => {
         'length': value.length,
         'isEmpty': value.isEmpty,

lib/src/transformers/widget_node_transformer_manager.dart

@@ -46,18 +46,23 @@ abstract class WidgetNodeTransformerManager
     return Opacity(opacity: opacity, child: widget);
   }
 
+  /// Returns the visibility a condition or variable gives [node] at runtime,
+  /// or null when nothing overrides the node's own visibility.
+  bool? runtimeVisibility(BuildContext context, BaseNode node) =>
+      PropertyValueDelegate.getPropertyValue<bool>(
+        node,
+        'visible',
+        scopedValues: ScopedValues.of(context),
+      );
+
   /// Convenience method to handle widget visibility.
   Widget applyWidgetVisibility(
     BuildContext context,
     BaseNode node,
     Widget widget, {
     required bool maintainState,
   }) {
-    final bool? runtimeVisible = PropertyValueDelegate.getPropertyValue<bool>(
-      node,
-      'visible',
-      scopedValues: ScopedValues.of(context),
-    );
+    final bool? runtimeVisible = runtimeVisibility(context, node);
     final bool visible = runtimeVisible ?? node.visible;
 
     if (visible) return widget;