fix(ui): stop StreamMessageListView from tripping RenderViewport layout-cycle limit

ScrollablePositionedList's reanchor used to reset pixels to 0, which forced the
trailing SliverList to walk back through its children one layout cycle at a
time on every mid-list anchored layout — exhausting RenderViewport's 10-cycle
budget. The reanchor now folds the existing pixels into the new viewport anchor
(LazyListState-style) so the slivers don't need to walk back. UnboundedRenderViewport
also gains a precisionErrorTolerance guard on sliver corrections and a higher
cycle ceiling as belt-and-suspenders.

Also pulls the v10 padding fix forward: ScrollablePositionedList.padding now
accepts EdgeInsetsGeometry (resolved against Directionality), and scrollTo
adjusts for leading padding so the target lands at the content-area edge.

See google/flutter.widgets#525, flutter/flutter#30809, flutter/flutter#23527.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: xsahil03x

packages/stream_chat_flutter/CHANGELOG.md

@@ -4,8 +4,15 @@
 
 - Fixed `StreamMessageListView` not auto-scrolling to the bottom on the user's own outgoing message
   until the server confirmed it.
-- Fixed a `FlutterError` ("A RenderViewport exceeded its maximum number of layout cycles") that
-  could occur when fast-scrolling through the message list.
+- Fixed `StreamMessageListView` tripping `A RenderViewport exceeded its maximum number of layout
+  cycles` under mid-list anchored layout. `ScrollablePositionedList` now preserves the scroll offset
+  across reanchors instead of resetting it to 0.
+
+🚀 Improved
+
+- `ScrollablePositionedList.padding` now accepts `EdgeInsetsGeometry` (resolved against
+  `Directionality`), and `scrollTo` lands the target at the content-area edge by adjusting for
+  leading padding.
 
 ## 9.24.0
 

packages/stream_chat_flutter/lib/scrollable_positioned_list/src/positioned_list.dart

@@ -125,7 +125,7 @@ class PositionedList extends StatefulWidget {
   final bool addSemanticIndexes;
 
   /// The amount of space by which to inset the children.
-  final EdgeInsets? padding;
+  final EdgeInsetsGeometry? padding;
 
   /// Whether to wrap each child in a [RepaintBoundary].
   ///
@@ -452,57 +452,82 @@ class _PositionedListState extends State<PositionedList> {
     );
   }
 
-  EdgeInsets get _leadingSliverPadding =>
-      (widget.scrollDirection == Axis.vertical
-          ? widget.reverse
-              ? widget.padding?.copyWith(top: 0)
-              : widget.padding?.copyWith(bottom: 0)
-          : widget.reverse
-              ? widget.padding?.copyWith(left: 0)
-              : widget.padding?.copyWith(right: 0)) ??
+  EdgeInsets get _resolvedPadding =>
+      widget.padding
+          ?.resolve(Directionality.maybeOf(context) ?? TextDirection.ltr) ??
       EdgeInsets.zero;
 
-  EdgeInsets get _centerSliverPadding => widget.scrollDirection == Axis.vertical
-      ? widget.reverse
-          ? widget.padding?.copyWith(
-                top: widget.positionedIndex == widget.itemCount - 1
-                    ? widget.padding!.top
-                    : 0,
-                bottom:
-                    widget.positionedIndex == 0 ? widget.padding!.bottom : 0,
-              ) ??
-              EdgeInsets.zero
-          : widget.padding?.copyWith(
-                top: widget.positionedIndex == 0 ? widget.padding!.top : 0,
-                bottom: widget.positionedIndex == widget.itemCount - 1
-                    ? widget.padding!.bottom
-                    : 0,
-              ) ??
-              EdgeInsets.zero
-      : widget.reverse
-          ? widget.padding?.copyWith(
-                left: widget.positionedIndex == widget.itemCount - 1
-                    ? widget.padding!.left
-                    : 0,
-                right: widget.positionedIndex == 0 ? widget.padding!.right : 0,
-              ) ??
-              EdgeInsets.zero
-          : widget.padding?.copyWith(
-                left: widget.positionedIndex == 0 ? widget.padding!.left : 0,
-                right: widget.positionedIndex == widget.itemCount - 1
-                    ? widget.padding!.right
-                    : 0,
-              ) ??
-              EdgeInsets.zero;
-
-  EdgeInsets get _trailingSliverPadding =>
-      widget.scrollDirection == Axis.vertical
-          ? widget.reverse
-              ? widget.padding?.copyWith(bottom: 0) ?? EdgeInsets.zero
-              : widget.padding?.copyWith(top: 0) ?? EdgeInsets.zero
-          : widget.reverse
-              ? widget.padding?.copyWith(right: 0) ?? EdgeInsets.zero
-              : widget.padding?.copyWith(left: 0) ?? EdgeInsets.zero;
+  AxisDirection get _axisDirection {
+    if (widget.scrollDirection == Axis.vertical) {
+      return widget.reverse ? AxisDirection.up : AxisDirection.down;
+    }
+    final ltr = (Directionality.maybeOf(context) ?? TextDirection.ltr) ==
+        TextDirection.ltr;
+    if (widget.reverse) {
+      return ltr ? AxisDirection.left : AxisDirection.right;
+    }
+    return ltr ? AxisDirection.right : AxisDirection.left;
+  }
+
+  EdgeInsets _stripAxisTrailing(EdgeInsets base) {
+    switch (_axisDirection) {
+      case AxisDirection.up:
+        return base.copyWith(top: 0);
+      case AxisDirection.down:
+        return base.copyWith(bottom: 0);
+      case AxisDirection.left:
+        return base.copyWith(left: 0);
+      case AxisDirection.right:
+        return base.copyWith(right: 0);
+    }
+  }
+
+  EdgeInsets _stripAxisLeading(EdgeInsets base) {
+    switch (_axisDirection) {
+      case AxisDirection.up:
+        return base.copyWith(bottom: 0);
+      case AxisDirection.down:
+        return base.copyWith(top: 0);
+      case AxisDirection.left:
+        return base.copyWith(right: 0);
+      case AxisDirection.right:
+        return base.copyWith(left: 0);
+    }
+  }
+
+  EdgeInsets get _leadingSliverPadding => _stripAxisTrailing(_resolvedPadding);
+
+  EdgeInsets get _trailingSliverPadding => _stripAxisLeading(_resolvedPadding);
+
+  // Center keeps cross-axis padding always; carries the leading/trailing
+  // edge padding only when it owns the first/last item.
+  EdgeInsets get _centerSliverPadding {
+    final resolved = _resolvedPadding;
+    final isFirst = widget.positionedIndex == 0;
+    final isLast = widget.positionedIndex == widget.itemCount - 1;
+    switch (_axisDirection) {
+      case AxisDirection.up:
+        return resolved.copyWith(
+          top: isLast ? resolved.top : 0,
+          bottom: isFirst ? resolved.bottom : 0,
+        );
+      case AxisDirection.down:
+        return resolved.copyWith(
+          top: isFirst ? resolved.top : 0,
+          bottom: isLast ? resolved.bottom : 0,
+        );
+      case AxisDirection.left:
+        return resolved.copyWith(
+          left: isLast ? resolved.left : 0,
+          right: isFirst ? resolved.right : 0,
+        );
+      case AxisDirection.right:
+        return resolved.copyWith(
+          left: isFirst ? resolved.left : 0,
+          right: isLast ? resolved.right : 0,
+        );
+    }
+  }
 
   void _schedulePositionNotificationUpdate() {
     if (!updateScheduled) {
@@ -551,32 +576,36 @@ class _PositionedListState extends State<PositionedList> {
               final itemOffset = reveal -
                   viewport.offset.pixels +
                   anchor * viewport.size.height;
-              positions.add(ItemPosition(
-                index: key.index,
-                itemLeadingEdge: itemOffset.round() /
-                    scrollController.position.viewportDimension,
-                itemTrailingEdge: (itemOffset + box.size.height).round() /
-                    scrollController.position.viewportDimension,
-              ));
+              positions.add(
+                ItemPosition(
+                  index: key.index,
+                  itemLeadingEdge: itemOffset.round() /
+                      scrollController.position.viewportDimension,
+                  itemTrailingEdge: (itemOffset + box.size.height).round() /
+                      scrollController.position.viewportDimension,
+                ),
+              );
             } else {
               final itemOffset =
                   box.localToGlobal(Offset.zero, ancestor: viewport).dx;
               if (!itemOffset.isFinite) continue;
-              positions.add(ItemPosition(
-                index: key.index,
-                itemLeadingEdge: (widget.reverse
-                            ? scrollController.position.viewportDimension -
-                                (itemOffset + box.size.width)
-                            : itemOffset)
-                        .round() /
-                    scrollController.position.viewportDimension,
-                itemTrailingEdge: (widget.reverse
-                            ? scrollController.position.viewportDimension -
-                                itemOffset
-                            : (itemOffset + box.size.width))
-                        .round() /
-                    scrollController.position.viewportDimension,
-              ));
+              positions.add(
+                ItemPosition(
+                  index: key.index,
+                  itemLeadingEdge: (widget.reverse
+                              ? scrollController.position.viewportDimension -
+                                  (itemOffset + box.size.width)
+                              : itemOffset)
+                          .round() /
+                      scrollController.position.viewportDimension,
+                  itemTrailingEdge: (widget.reverse
+                              ? scrollController.position.viewportDimension -
+                                  itemOffset
+                              : (itemOffset + box.size.width))
+                          .round() /
+                      scrollController.position.viewportDimension,
+                ),
+              );
             }
           } on TypeError catch (_) {
             // Specifically the null-check failure inside