Merge branch 'master' into v10.0.0

Resolves SPL conflicts in scrollable_positioned_list and positioned_list:
- Take master's preserve-pixels `_updateFirstVisibleItemIfNeeded` (PR #2703)
- Take master's empty-list `_centerSliverPadding` guard
- Take master's RTL `_axisDirection`-based `_updatePositions` branching
- Take master's `_resolveLeadingEndPaddingAdjust` `index != 0` check
- Drop orphaned `message_card_test.dart` (widget deleted in v10 design refresh);
  master's MessageCard fix from #2702 ported to StreamMessageContent.

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

Author: xsahil03x

.fvmrc

@@ -0,0 +1,3 @@
+{
+  "flutter": "3.27.4"
+}

packages/stream_chat_flutter/CHANGELOG.md

@@ -148,8 +148,18 @@
 
 - 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.
+- Fixed `RenderBox was not laid out` thrown by `MessageCard._updateWidthLimit` when the attachments
+  subtree was detached between scheduling the post-frame callback and it firing (e.g. the list was
+  rebuilt or the message removed). Added a `hasSize` guard before reading `RenderBox.size`.
+
+🚀 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

@@ -489,6 +489,9 @@ class _PositionedListState extends State<PositionedList> {
   // edge padding only when it owns the first/last item.
   EdgeInsets get _centerSliverPadding {
     final resolved = _resolvedPadding;
+    // Empty list: center is the only sliver in the tree. Drop neither
+    // edge or the gap would be asymmetric.
+    if (widget.itemCount == 0) return resolved;
     final isFirst = widget.positionedIndex == 0;
     final isLast = widget.positionedIndex == widget.itemCount - 1;
     switch (_axisDirection) {
@@ -571,21 +574,16 @@ class _PositionedListState extends State<PositionedList> {
             } else {
               final itemOffset = box.localToGlobal(Offset.zero, ancestor: viewport).dx;
               if (!itemOffset.isFinite) continue;
+              final viewportDimension = scrollController.position.viewportDimension;
+              // Branch on the resolved axis direction so RTL is handled.
+              final isRight = _axisDirection == AxisDirection.right;
+              final leadingPx = isRight ? itemOffset : viewportDimension - (itemOffset + box.size.width);
+              final trailingPx = isRight ? itemOffset + box.size.width : viewportDimension - itemOffset;
               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,
+                  itemLeadingEdge: leadingPx.round() / viewportDimension,
+                  itemTrailingEdge: trailingPx.round() / viewportDimension,
                 ),
               );
             }

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

@@ -522,13 +522,10 @@ class _ScrollablePositionedListState extends State<ScrollablePositionedList> wit
   ///    reanchor would silently revert the user's in-progress scroll
   ///    and the list would feel locked in place.
   ///
-  /// 2. The scroll offset is brought to zero via
-  ///    [ScrollPosition.correctBy], not [ScrollController.jumpTo].
-  ///    `correctBy` mutates `pixels` directly without firing `goIdle()`
-  ///    or dispatching scroll notifications, so an in-flight
-  ///    `DragScrollActivity` or `BallisticScrollActivity` keeps
-  ///    integrating its delta against the new baseline instead of
-  ///    being cancelled.
+  /// 2. The new anchor folds the current pixel offset in so we can
+  ///    leave [primary.scrollController.position.pixels] untouched.
+  ///    Resetting pixels could exhaust [UnboundedRenderViewport]'s
+  ///    layout-cycle budget on deep mid-list anchors.
   void _updateFirstVisibleItemIfNeeded() {
     final keyBuilder = widget.itemKeyBuilder;
     if (keyBuilder == null || _lastKnownFirstItemKey == null) return;
@@ -543,21 +540,16 @@ class _ScrollablePositionedListState extends State<ScrollablePositionedList> wit
     final currentAlignment = viewport > 0
         ? _firstVisibleItemAlignment - pixelDelta / viewport
         : _firstVisibleItemAlignment;
+    // `newAnchor * viewport - pixels == currentAlignment * viewport`
+    // so the anchored item lands at the same visual position without
+    // touching pixels.
+    final newAnchor = viewport > 0 ? currentAlignment + pixels / viewport : currentAlignment;
 
-    if (newIndex == primary.target && primary.alignment == currentAlignment && pixels == 0) {
-      return;
-    }
+    if (newIndex == primary.target && primary.alignment == newAnchor) return;
     primary
       ..target = newIndex
-      ..alignment = currentAlignment;
-    if (hasClients && pixels != 0) {
-      position!.correctBy(-pixels);
-    }
-    // The reanchor itself moves the pixel baseline to 0; record that
-    // alongside the (now-applied) anchor so subsequent reanchors that
-    // fire before the next layout compute deltas against the right
-    // starting point.
-    _firstVisibleItemAlignmentAtPixels = 0;
+      ..alignment = newAnchor;
+    _firstVisibleItemAlignmentAtPixels = pixels;
     _lastKnownFirstItemIndex = newIndex;
     _firstVisibleItemAlignment = currentAlignment;
   }
@@ -663,13 +655,17 @@ class _ScrollablePositionedListState extends State<ScrollablePositionedList> wit
   }
 
   /// Adjustment for `_startScroll`'s target so the leading-end item
-  /// lands at the content-area edge (Compose semantic). Only applies
-  /// when the center sliver carries the leading padding — for other
-  /// indices SPL's pre-existing math is preserved.
-  double _resolveLeadingEndPaddingAdjust({required int index, required double alignment}) {
+  /// lands at the content-area edge. Only applies when the center
+  /// sliver carries the leading padding — for other indices SPL's
+  /// pre-existing math is preserved.
+  double _resolveLeadingEndPaddingAdjust({
+    required int index,
+    required double alignment,
+  }) {
     if (alignment != 0) return 0;
-    final isAtLeadingEnd = widget.reverse ? index == 0 : index == widget.itemCount - 1;
-    if (!isAtLeadingEnd) return 0;
+    // Center carries the leading-edge padding only when
+    // `positionedIndex == 0`, in both axis directions.
+    if (index != 0) return 0;
     return _resolveLeadingPadding();
   }
 
@@ -757,7 +753,7 @@ class _ScrollablePositionedListState extends State<ScrollablePositionedList> wit
       final localScrollAmount = itemPosition.itemLeadingEdge * viewport;
       // `itemLeadingEdge` comes from `getOffsetToReveal`, which is
       // geometric and padding-blind. Subtract `leadingPadding` so the
-      // target lands at the content-area edge (Compose semantic).
+      // target lands at the content-area edge.
       final paddingAdjust = _resolveLeadingEndPaddingAdjust(index: index, alignment: alignment);
       await primary.scrollController.animateTo(
         primary.scrollController.offset + localScrollAmount - alignment * viewport - paddingAdjust,

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

@@ -4,6 +4,7 @@
 
 import 'dart:math' as math;
 
+import 'package:flutter/foundation.dart';
 import 'package:flutter/rendering.dart';
 import 'package:flutter/widgets.dart';
 
@@ -67,7 +68,10 @@ class UnboundedRenderViewport extends RenderViewport {
   }) : _requestedAnchor = anchor,
        _effectiveAnchor = anchor;
 
-  static const int _maxLayoutCycles = 10;
+  // Raised from 10 to absorb walk-back cycles from the underlying
+  // slivers after an anchor-preserving re-layout. Still bounded so
+  // pathological infinite loops assert.
+  static const int _maxLayoutCycles = 100;
 
   /// The anchor the widget asked for. Used as the starting point each
   /// layout pass; may be overridden by the "fit anchor" fallback when
@@ -195,7 +199,9 @@ class UnboundedRenderViewport extends RenderViewport {
         offset.pixels + centerOffsetAdjustment,
         effectiveAnchor,
       );
-      if (correction != 0.0) {
+      // Sub-`precisionErrorTolerance` corrections can't move `pixels`
+      // and would loop forever; treat as converged.
+      if (correction.abs() > precisionErrorTolerance) {
         offset.correctBy(correction);
       } else {
         // *** Difference from [RenderViewport].

packages/stream_chat_flutter/lib/src/message_widget/components/stream_message_content.dart

@@ -113,12 +113,18 @@ class _StreamMessageContentState extends State<StreamMessageContent> {
 
   // Measures the attachment width after layout and constrains the bubble.
   void _updateWidthLimit() {
+    if (!mounted) return;
+
     final attachmentContext = attachmentsKey.currentContext;
     final renderBox = attachmentContext?.findRenderObject() as RenderBox?;
-    final attachmentsWidth = renderBox?.size.width;
-
-    if (attachmentsWidth == null || attachmentsWidth == 0) return;
-    if (mounted) setState(() => widthLimit = attachmentsWidth);
+    // The attachments subtree may have been detached between scheduling this
+    // post-frame callback and it firing. Reading [RenderBox.size] without
+    // checking [RenderBox.hasSize] throws `RenderBox was not laid out`.
+    if (renderBox == null || !renderBox.hasSize) return;
+    final attachmentsWidth = renderBox.size.width;
+
+    if (attachmentsWidth == 0) return;
+    setState(() => widthLimit = attachmentsWidth);
   }
 
   @override

packages/stream_chat_flutter/test/scrollable_positioned_list/scrollable_positioned_list_test.dart

@@ -1258,6 +1258,135 @@ void main() {
     );
   });
 
+  testWidgets('padding - empty list keeps both main-axis edges', (WidgetTester tester) async {
+    tester.view.devicePixelRatio = 1.0;
+    tester.view.physicalSize = const Size(screenWidth, screenHeight);
+
+    // With itemCount: 0 the center sliver is the only sliver in the
+    // tree. Before the fix, isLast was false (positionedIndex 0 !=
+    // itemCount-1 = -1) so one main-axis padding edge was dropped.
+    // Smoke-test: rendering an empty list with padding must not throw
+    // and must keep symmetric padding.
+    await tester.pumpWidget(
+      MaterialApp(
+        home: ScrollablePositionedList.builder(
+          itemCount: 0,
+          itemBuilder: (_, __) => const SizedBox.shrink(),
+          padding: const EdgeInsets.symmetric(vertical: 20),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+    expect(tester.takeException(), isNull);
+  });
+
+  testWidgets(
+    'padding - scrollTo(0, alignment: 0) lands at content-area edge in '
+    'non-reversed list',
+    (WidgetTester tester) async {
+      final itemScrollController = ItemScrollController();
+      await setUpWidgetTest(
+        tester,
+        itemScrollController: itemScrollController,
+        padding: const EdgeInsets.only(top: 40),
+      );
+
+      // Scroll away from item 0 first so the next scrollTo isn't a no-op.
+      unawaited(
+        itemScrollController.scrollTo(
+          index: 50,
+          duration: const Duration(milliseconds: 1),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      // Now scroll back to item 0 at alignment 0. Without the
+      // padding-adjust fix (the v10 `widget.reverse` ternary), the
+      // adjustment didn't fire for non-reversed lists and item 0 would
+      // not land at the content-area edge.
+      unawaited(
+        itemScrollController.scrollTo(
+          index: 0,
+          duration: const Duration(milliseconds: 1),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      // Item 0's top edge sits at y = padding.top (the content-area
+      // edge), not the viewport edge.
+      expect(tester.getTopLeft(find.text('Item 0')), const Offset(0, 40));
+    },
+  );
+
+  testWidgets(
+    'horizontal RTL: itemLeadingEdge is measured from the right edge',
+    (WidgetTester tester) async {
+      final positionsListener = ItemPositionsListener.create();
+      tester.view.devicePixelRatio = 1.0;
+      tester.view.physicalSize = const Size(screenWidth, screenHeight);
+
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Directionality(
+            textDirection: TextDirection.rtl,
+            child: ScrollablePositionedList.builder(
+              itemCount: 100,
+              scrollDirection: Axis.horizontal,
+              itemPositionsListener: positionsListener,
+              itemBuilder: (context, index) => SizedBox(
+                width: 50,
+                child: Text('Item $index'),
+              ),
+            ),
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      // RTL + scrollDirection horizontal + reverse=false resolves to
+      // AxisDirection.left, so item 0 sits flush against the viewport's
+      // right edge and `itemLeadingEdge` (measured from the leading
+      // side, i.e. the right) should be near 0.
+      final pos0 = positionsListener.itemPositions.value.firstWhere((p) => p.index == 0);
+      expect(pos0.itemLeadingEdge, lessThan(0.01));
+      expect(tester.getTopRight(find.text('Item 0')), const Offset(screenWidth, 0));
+    },
+  );
+
+  testWidgets(
+    'horizontal RTL: EdgeInsetsDirectional padding resolves correctly',
+    (WidgetTester tester) async {
+      tester.view.devicePixelRatio = 1.0;
+      tester.view.physicalSize = const Size(screenWidth, screenHeight);
+
+      await tester.pumpWidget(
+        MaterialApp(
+          home: Directionality(
+            textDirection: TextDirection.rtl,
+            child: ScrollablePositionedList.builder(
+              itemCount: 100,
+              scrollDirection: Axis.horizontal,
+              padding: const EdgeInsetsDirectional.only(start: 20),
+              itemBuilder: (context, index) => SizedBox(
+                width: 50,
+                child: Text('Item $index'),
+              ),
+            ),
+          ),
+        ),
+      );
+      await tester.pumpAndSettle();
+
+      // In RTL, `EdgeInsetsDirectional.start` resolves to right. Item
+      // 0 (the leading-end item) should be inset by 20 from the right
+      // viewport edge.
+      expect(
+        tester.getTopRight(find.text('Item 0')),
+        const Offset(screenWidth - 20, 0),
+      );
+    },
+  );
+
   testWidgets('no repaint boundaries', (WidgetTester tester) async {
     final itemScrollController = ItemScrollController();
     await setUpWidgetTest(

packages/stream_chat_persistence/CHANGELOG.md

@@ -14,6 +14,10 @@
 
 - Reduce the number of DB reads in the `ChatPersistenceClient.getChannelStates` method.
 
+🔄 Changed
+
+- Changed how dates are stored in the local cache, from integer seconds to ISO-8601 strings, in order to preserve millisecond precision.
+
 ## 9.24.0
 
 - Updated `stream_chat` dependency to [`9.24.0`](https://pub.dev/packages/stream_chat/changelog).

packages/stream_chat_persistence/test/src/dao/connection_event_dao_test.dart

@@ -112,6 +112,23 @@ void main() {
     expect(updatedLastSyncAt, isSameDateAs(now));
   });
 
+  test('updateLastSyncAt preserves millisecond precision', () async {
+    // A connection event must exist before lastSyncAt can be stored.
+    await eventDao.updateConnectionEvent(
+      Event(
+        createdAt: DateTime.now(),
+        me: OwnUser(id: 'testUserId'),
+      ),
+    );
+
+    final preciseDate = DateTime.utc(2026, 5, 28, 12, 34, 56, 123);
+    await eventDao.updateLastSyncAt(preciseDate);
+
+    final readBack = await eventDao.lastSyncAt;
+    expect(readBack, equals(preciseDate));
+    expect(readBack!.millisecond, equals(123));
+  });
+
   tearDown(() async {
     await database.disconnect();
   });

packages/stream_chat_persistence/test/src/utils/date_matcher.dart

@@ -14,7 +14,8 @@ class _IsSameDateAs extends Matcher {
         date.day == targetDate?.day &&
         date.hour == targetDate?.hour &&
         date.minute == targetDate?.minute &&
-        date.second == targetDate?.second;
+        date.second == targetDate?.second &&
+        date.millisecond == targetDate?.millisecond;
   }
 
   @override