Open long chats bottom-anchored so only the rows that show are laid out

This commit is contained in:
2026-11-02 00:23:46 +00:00
parent b80c52b3e1
commit a5f0eb3811
8 changed files with 532 additions and 39 deletions
@@ -74,27 +74,35 @@ String chatJumpToLatestLabel(int newMessages) {
/// Where a conversation's transcript is placed when it first shows.
///
/// No saved position means the operator has none of their own: open at the
/// newest content. A saved offset is kept, clamped to the current end, so a
/// newest content. A saved offset is kept, clamped to the current extent, so a
/// conversation whose content grew or shrank while it was closed still lands on
/// a real position.
/// a real position. A bottom-anchored transcript measures older rows above its
/// centre, so its offsets (and [minScrollExtent]) can be negative.
double chatRestoreOffset({
required double? savedOffset,
required double maxScrollExtent,
double minScrollExtent = 0,
}) {
if (savedOffset == null) return maxScrollExtent;
return savedOffset.clamp(0.0, maxScrollExtent).toDouble();
return savedOffset.clamp(minScrollExtent, maxScrollExtent).toDouble();
}
/// A saved transcript position: the scroll offset and the message id of the
/// row the transcript was split at (see `chatTranscriptAnchor`), or null for a
/// top-anchored transcript whose offset counts from its first row. An offset
/// only means something measured from the same anchor.
typedef ChatScrollPosition = ({double offset, String? anchor});
/// Per-conversation transcript positions, kept while the chat list stays
/// mounted. A conversation opened again returns to the position the operator
/// left; one they never moved in opens at its newest message.
abstract interface class ChatScrollStore {
/// The offset the operator left this conversation at, or null when they never
/// scrolled away from its end.
double? read(String sessionId);
/// The position the operator left this conversation at, or null when they
/// never scrolled away from its end.
ChatScrollPosition? read(String sessionId);
/// Records a deliberate position away from the end.
void write(String sessionId, double offset);
void write(String sessionId, ChatScrollPosition position);
/// Forgets the position once the operator is following the end again.
void clear(String sessionId);
@@ -107,19 +115,22 @@ abstract interface class ChatScrollStore {
/// client keeps no transcript position on disk and does not import the web's
/// storage keys.
class MemoryChatScrollStore implements ChatScrollStore {
final Map<String, double> _offsets = {};
final Map<String, ChatScrollPosition> _offsets = {};
/// A snapshot of the stored offsets, so a test can tell a cleared
/// A snapshot of the stored positions, so a test can tell a cleared
/// conversation from one that was never moved.
Map<String, double> get entries => Map.unmodifiable(_offsets);
Map<String, ChatScrollPosition> get entries => Map.unmodifiable(_offsets);
@override
double? read(String sessionId) => _offsets[sessionId];
ChatScrollPosition? read(String sessionId) => _offsets[sessionId];
@override
void write(String sessionId, double offset) {
if (!offset.isFinite || offset < 0) return;
_offsets[sessionId] = offset;
void write(String sessionId, ChatScrollPosition position) {
// A top-anchored offset counts from the first row and is never negative;
// a bottom-anchored one is negative above its centre.
if (!position.offset.isFinite) return;
if (position.anchor == null && position.offset < 0) return;
_offsets[sessionId] = position;
}
@override
@@ -35,7 +35,9 @@ import '../../../ui/adaptive/segmented_bar_overlay.dart';
import '../../../ui/layout/app_sheet_header.dart';
import 'chat_reading_width.dart';
import 'chat_thread_header.dart';
import 'chat_transcript_anchor.dart';
import 'chat_transcript_cache.dart';
import 'chat_transcript_scroll_view.dart';
import 'chat_permission_card_model.dart';
import 'chat_permission_group.dart';
import 'chat_transcript_card.dart';
@@ -185,7 +187,12 @@ class _ChatThreadViewState extends State<ChatThreadView> {
/// The conversation's saved position, read when this view is attached and
/// consumed by the first placement after the history arrives.
double? _savedOffset;
ChatScrollPosition? _savedPosition;
/// The message id the transcript is split at (see [chatTranscriptAnchor]),
/// chosen once when the history first arrives; null keeps it top-anchored.
String? _anchor;
bool _anchorChosen = false;
bool _placed = false;
bool _pinScheduled = false;
@@ -384,7 +391,7 @@ class _ChatThreadViewState extends State<ChatThreadView> {
@override
void initState() {
super.initState();
_savedOffset = widget.scrollPositions?.read(widget.sessionId);
_savedPosition = widget.scrollPositions?.read(widget.sessionId);
_adoptCachedTranscript();
_seedCommandNotice();
}
@@ -416,7 +423,9 @@ class _ChatThreadViewState extends State<ChatThreadView> {
_syncGeneration++;
_commandNotices.clear();
_seedCommandNotice();
_savedOffset = widget.scrollPositions?.read(widget.sessionId);
_savedPosition = widget.scrollPositions?.read(widget.sessionId);
_anchor = null;
_anchorChosen = false;
_placed = false;
_following = true;
_distanceFromBottom = null;
@@ -489,11 +498,8 @@ class _ChatThreadViewState extends State<ChatThreadView> {
store.clear(id);
return;
}
if (_scroll.hasClients) {
store.write(id, _scroll.position.pixels);
} else {
store.write(id, _lastOffset);
}
final offset = _scroll.hasClients ? _scroll.position.pixels : _lastOffset;
store.write(id, (offset: offset, anchor: _anchor));
}
/// Measured distance from the end for the current content.
@@ -535,11 +541,21 @@ class _ChatThreadViewState extends State<ChatThreadView> {
/// the operator left one, otherwise the newest message.
void _placeFromStore() {
if (!_scroll.hasClients) return;
final saved = _savedPosition;
if (_anchor != null &&
saved == null &&
_scroll.position.minScrollExtent >= 0) {
// The rows above the centre do not fill the viewport, so a bottom-anchored
// list would leave a gap above them. A transcript this short is cheap to
// lay out whole: show it top-anchored, from its first row, as before.
setState(() => _anchor = null);
_scheduleFollow();
return;
}
_placed = true;
final saved = _savedOffset;
_savedOffset = null;
_savedPosition = null;
if (saved != null) {
_restoreOffset = saved;
_restoreOffset = saved.offset;
_restoring = true;
_following = false;
_newestAtRelease = null;
@@ -564,6 +580,7 @@ class _ChatThreadViewState extends State<ChatThreadView> {
final target = chatRestoreOffset(
savedOffset: _restoreOffset,
maxScrollExtent: end,
minScrollExtent: _scroll.position.minScrollExtent,
);
if (_scroll.position.pixels != target) _scroll.jumpTo(target);
_lastOffset = target;
@@ -680,6 +697,35 @@ class _ChatThreadViewState extends State<ChatThreadView> {
_restoreOffset = null;
}
/// The index of the row the transcript is split at, or -1 to keep it
/// top-anchored. The anchor is chosen once, when the history first arrives:
/// a saved position keeps the anchor it was measured from.
int _splitFor(List<JsonMap> rows) {
if (!_controller.loaded) return -1;
if (!_anchorChosen) {
_anchorChosen = true;
final saved = _savedPosition;
if (saved != null &&
saved.anchor != null &&
chatTranscriptAnchorIndex(rows, saved.anchor) < 0) {
// The row the position was measured from is gone: the offset no longer
// names a place in this transcript, so it opens at the newest message.
_savedPosition = null;
}
_anchor = _savedPosition == null
? chatTranscriptAnchor(rows)
: _savedPosition!.anchor;
}
var index = chatTranscriptAnchorIndex(rows, _anchor);
if (index < 0 && _anchor != null) {
// A repair replaced the transcript without the anchor row: split the new
// one afresh (a following view is pinned to its end again after layout).
_anchor = chatTranscriptAnchor(rows);
index = chatTranscriptAnchorIndex(rows, _anchor);
}
return index;
}
@override
Widget build(BuildContext context) => AnimatedBuilder(
animation: Listenable.merge([
@@ -743,6 +789,7 @@ class _ChatThreadViewState extends State<ChatThreadView> {
// its previous messages, keeping the element (and its open disclosures)
// across paging and streaming.
final keys = _rowKeys.forRows(rows);
final split = _splitFor(rows);
final initialLoad = !_controller.loaded && _controller.loading;
final historyNotice = _noticeOf(
notices,
@@ -825,11 +872,16 @@ class _ChatThreadViewState extends State<ChatThreadView> {
children: [
// At rest the first item starts below the floating bar
// and the last one ends above the floating composer.
ListView(
// Bottom-anchored at the split row, the newest rows are
// laid out first and older ones only when scrolled to.
ChatTranscriptScrollView(
key: ValueKey<String>(
'chat-thread-${widget.sessionId}',
),
controller: _scroll,
splitAfter: split < 0
? null
: ValueKey<String>(keys[split]),
padding: EdgeInsets.fromLTRB(
side,
media.top + 8,
@@ -0,0 +1,69 @@
import '../../../core/api_gateway.dart';
/// Where an opened transcript is split into its older and newer halves.
///
/// Opening a long conversation at its newest message used to lay out every row
/// above it: a top-anchored list can only reach its end by measuring the rows
/// in between. The transcript is instead a two-sided scroll view whose centre
/// sits between an anchor row and the rows after it. The anchor row and every
/// older row grow upwards from the centre; the rows after it (and the queued,
/// unsent and command lines) grow downwards. Opening lays out only what shows.
///
/// The split is fixed for as long as the conversation is open, so growth on
/// either side never moves the other: an older page loaded above, or a reply
/// streaming below, leaves the operator's reading position where it is. The
/// newest message row (and a reply that is still streaming) is never the
/// anchor or above it, because a row above the centre that grew would push the
/// rows above it up while the operator reads them.
///
/// Returns null when the transcript has fewer than two message rows: there is
/// nothing older to keep unmeasured, and the view stays top-anchored.
String? chatTranscriptAnchor(List<JsonMap> rows) {
var cut = -1;
for (var index = rows.length - 1; index >= 0; index--) {
if (_messageIds(rows[index]).isNotEmpty) {
cut = index;
break;
}
}
for (var index = 0; index < rows.length; index++) {
if (rows[index]['streaming'] == true && index < cut) {
cut = index;
break;
}
}
for (var index = cut - 1; index >= 0; index--) {
final ids = _messageIds(rows[index]);
if (ids.isNotEmpty) return ids.last;
}
return null;
}
/// The index of the row that holds [anchor], or -1 when no row does (a repair
/// replaced the transcript) or there is no anchor.
int chatTranscriptAnchorIndex(List<JsonMap> rows, String? anchor) {
if (anchor == null) return -1;
for (var index = rows.length - 1; index >= 0; index--) {
if (_messageIds(rows[index]).contains(anchor)) return index;
}
return -1;
}
/// The stored message ids of one user or assistant row. Cards, activity lines
/// and the pending-response shell carry none and can never be an anchor.
List<String> _messageIds(JsonMap row) {
final kind = row['kind'];
if (kind == 'assistant') {
final listed = row['messageIds'];
if (listed is! List) return const [];
return [
for (final id in listed)
if ('$id'.trim().isNotEmpty) '$id'.trim(),
];
}
if (kind == 'user') {
final id = '${row['key'] ?? ''}'.trim();
return id.isEmpty ? const [] : [id];
}
return const [];
}
@@ -0,0 +1,64 @@
import 'package:flutter/widgets.dart';
/// The transcript's scrollable: older rows above a centre, newer rows below.
///
/// With [splitAfter], the children up to and including the one with that key
/// sit above the centre and the rest below it. The centre is at the viewport's
/// bottom edge at offset zero: the older children grow upwards from it and the
/// newer ones downwards, so the newest rows are laid out first and an older row
/// only when it is scrolled to. Offsets above the centre are negative.
///
/// Without one (or when no child has that key) this is a plain top-anchored
/// list starting at its first child. A transcript that fits its viewport stays
/// top-anchored, so a short conversation still reads from the top.
///
/// [padding] keeps the first child below the floating bar and the last child
/// above the floating composer, as a list's padding would.
class ChatTranscriptScrollView extends StatelessWidget {
const ChatTranscriptScrollView({
super.key,
required this.controller,
required this.padding,
required this.children,
this.splitAfter,
});
static const _centre = ValueKey<String>('chat-thread-newer');
final ScrollController controller;
final EdgeInsets padding;
final List<Widget> children;
final Key? splitAfter;
@override
Widget build(BuildContext context) {
final split = splitAfter == null
? -1
: children.indexWhere((child) => child.key == splitAfter);
final anchored = split >= 0;
return CustomScrollView(
controller: controller,
center: _centre,
anchor: anchored ? 1 : 0,
slivers: [
// Before the centre, a sliver grows upwards: its first child sits at
// the centre, so the older children go in newest-first.
SliverPadding(
padding: anchored ? padding.copyWith(bottom: 0) : EdgeInsets.zero,
sliver: SliverList(
delegate: SliverChildListDelegate([
for (var index = split; index >= 0; index--) children[index],
]),
),
),
SliverPadding(
key: _centre,
padding: anchored ? padding.copyWith(top: 0) : padding,
sliver: SliverList(
delegate: SliverChildListDelegate(children.sublist(split + 1)),
),
),
],
);
}
}
@@ -103,27 +103,39 @@ void main() {
expect(chatRestoreOffset(savedOffset: 0, maxScrollExtent: 640), 0);
expect(chatRestoreOffset(savedOffset: 900, maxScrollExtent: 640), 640);
});
test('a bottom-anchored position above the centre stays negative', () {
double restore(double saved) => chatRestoreOffset(
savedOffset: saved,
minScrollExtent: -2000,
maxScrollExtent: 300,
);
expect(restore(-750), -750);
expect(restore(-5000), -2000);
expect(restore(900), 300);
});
});
group('store', () {
test('remembers one conversation without touching another', () {
final store = MemoryChatScrollStore();
store.write('a', 120);
store.write('b', 30);
expect(store.read('a'), 120);
expect(store.read('b'), 30);
store.write('a', (offset: 120, anchor: null));
store.write('b', (offset: -30, anchor: 'm4'));
expect(store.read('a'), (offset: 120.0, anchor: null));
expect(store.read('b'), (offset: -30.0, anchor: 'm4'));
expect(store.read('c'), isNull);
store.clear('a');
expect(store.read('a'), isNull);
expect(store.entries, {'b': 30.0});
expect(store.entries, {'b': (offset: -30.0, anchor: 'm4')});
});
test('ignores an unusable offset instead of inventing a position', () {
final store = MemoryChatScrollStore();
store.write('a', double.nan);
store.write('a', double.infinity);
store.write('a', -5);
store.write('a', (offset: double.nan, anchor: 'm1'));
store.write('a', (offset: double.infinity, anchor: null));
// Only a bottom-anchored offset counts from a centre and can be negative.
store.write('a', (offset: -5, anchor: null));
expect(store.read('a'), isNull);
});
});
@@ -0,0 +1,211 @@
import 'package:flutter/material.dart';
import 'package:flutter/widgets.dart' as widgets;
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/chat/conversation/chat_scroll.dart';
import 'package:pipelines_app/features/chat/conversation/chat_thread_view.dart';
import 'package:pipelines_app/features/chat/ui/transcript/chat_message_view.dart';
import 'chat_thread_fixtures.dart';
import 'chat_thread_scroll_test.dart' show host, transcriptScroll;
// The transcript opens bottom-anchored: only the rows that show are built, and
// growth on either side of the split never moves the operator's place. In the
// 800x600 test viewport the first row starts below the floating header.
const _firstRowTop = 80.0;
List<JsonMap> messages(int count, {int from = 0, int sentences = 6}) => [
for (var index = from; index < from + count; index++)
chatMessage(
'm$index',
index.isEven ? 'user' : 'assistant',
parts: [
{
'type': 'text',
'text':
'Message $index. '
'${List.filled(sentences, 'A sentence that wraps across the transcript width.').join(' ')}',
},
],
),
];
Finder row(String id) => find.byWidgetPredicate(
(widget) =>
widget is ChatMessageView &&
(widget.row['key'] == id ||
(widget.row['messageIds'] as List?)?.contains(id) == true),
skipOffstage: false,
);
Finder get thread => find.byKey(const Key('chat-thread-s'));
Future<void> dragUntil(WidgetTester tester, Finder target) async {
for (var drag = 0; drag < 80 && !tester.any(target); drag++) {
await tester.drag(thread, const Offset(0, 500));
await tester.pump();
}
await tester.pumpAndSettle();
}
Future<void> openThread(WidgetTester tester, FakeChatGateway gateway) async {
await tester.pumpWidget(
host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})),
);
await tester.pumpAndSettle();
}
void main() {
testWidgets('a long transcript opens at its newest message, building only '
'what shows', (tester) async {
final gateway = FakeChatGateway();
addTearDown(gateway.close);
gateway.history = (_) async => chatPage(messages(200));
final built = <String>{};
widgets.debugOnRebuildDirtyWidget = (element, _) {
final widget = element.widget;
if (widget is ChatMessageView) built.add('${widget.row['key']}');
};
addTearDown(() => widgets.debugOnRebuildDirtyWidget = null);
await openThread(tester, gateway);
widgets.debugOnRebuildDirtyWidget = null;
final scroll = transcriptScroll(tester);
expect(
scroll.position.pixels,
closeTo(scroll.position.maxScrollExtent, 0.5),
);
expect(scroll.position.minScrollExtent, lessThan(0));
final newest = tester.getRect(row('m199'));
expect(newest.bottom, lessThanOrEqualTo(600));
expect(newest.bottom, greaterThan(400));
expect(built, isNot(contains('m0')));
expect(built.length, lessThan(20));
expect(find.byKey(const Key('chat-jump-to-latest')), findsNothing);
// A reply streaming below the split is followed while at the end.
gateway.emitEvent(chatTextFrame('Streaming answer. ', messageId: 'live'));
await tester.pump();
await tester.pump();
expect(
scroll.position.pixels,
closeTo(scroll.position.maxScrollExtent, 0.5),
);
});
testWidgets('scrolling up reaches the first row with no gap above it', (
tester,
) async {
final gateway = FakeChatGateway();
addTearDown(gateway.close);
gateway.history = (_) async => chatPage(messages(40));
await openThread(tester, gateway);
await dragUntil(tester, row('m0'));
await tester.fling(thread, const Offset(0, 3000), 3000);
await tester.pumpAndSettle();
final scroll = transcriptScroll(tester);
expect(
scroll.position.pixels,
closeTo(scroll.position.minScrollExtent, 0.5),
);
expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1));
expect(find.byKey(const Key('chat-jump-to-latest')), findsOneWidget);
});
for (final tall in [false, true]) {
testWidgets('a short transcript still reads from the top '
'(tall newest row: $tall)', (tester) async {
final gateway = FakeChatGateway();
addTearDown(gateway.close);
// The rows above the newest one fit the viewport.
gateway.history = (_) async => chatPage([
...messages(2, sentences: 1),
...messages(1, from: 2, sentences: tall ? 60 : 1),
]);
await openThread(tester, gateway);
final scroll = transcriptScroll(tester);
expect(scroll.position.minScrollExtent, 0);
expect(
scroll.position.pixels,
closeTo(scroll.position.maxScrollExtent, 0.5),
);
if (!tall) {
expect(scroll.position.maxScrollExtent, 0);
expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1));
return;
}
// At its end the tall newest row shows its end; scrolling back reaches
// the first row at the top padding.
expect(tester.getRect(row('m2')).bottom, lessThanOrEqualTo(600));
await tester.fling(thread, const Offset(0, 3000), 3000);
await tester.pumpAndSettle();
expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1));
});
}
testWidgets('loading an older page keeps the rows the operator reads in '
'place', (tester) async {
final gateway = FakeChatGateway();
addTearDown(gateway.close);
gateway.history = (_) async =>
chatPage(messages(30, from: 30), cursor: 'older', hasMore: true);
await openThread(tester, gateway);
await dragUntil(tester, find.text('Load older'));
await tester.fling(thread, const Offset(0, 3000), 3000);
await tester.pumpAndSettle();
final held = tester.getRect(row('m30'));
gateway.history = (_) async => chatPage(messages(30));
await tester.tap(find.text('Load older'));
await tester.pumpAndSettle();
expect(find.text('Load older'), findsNothing);
expect(tester.getRect(row('m30')).top, closeTo(held.top, 0.5));
// The older page sits above, reachable by scrolling up.
await dragUntil(tester, row('m0'));
await tester.fling(thread, const Offset(0, 3000), 3000);
await tester.pumpAndSettle();
expect(tester.getRect(row('m0')).top, closeTo(_firstRowTop, 1));
});
testWidgets('a reopened conversation keeps its place after messages arrived '
'while it was closed', (tester) async {
final gateway = FakeChatGateway();
addTearDown(gateway.close);
gateway.history = (_) async => chatPage(messages(60));
final positions = MemoryChatScrollStore();
Widget view() => host(
ChatThreadView(
gateway: gateway,
sessionId: 's',
scrollPositions: positions,
onBack: () {},
),
);
await tester.pumpWidget(view());
await tester.pumpAndSettle();
for (var drag = 0; drag < 4; drag++) {
await tester.drag(thread, const Offset(0, 400));
await tester.pump();
}
await tester.pumpAndSettle();
final shown = find.byWidgetPredicate((widget) => widget is ChatMessageView);
final top = shown.evaluate().first.widget as ChatMessageView;
final id = '${top.row['key']}';
final held = tester.getRect(row(id));
expect(positions.read('s')!.anchor, isNotNull);
await tester.pumpWidget(host(const SizedBox()));
gateway.history = (_) async => chatPage(messages(64));
await tester.pumpWidget(view());
await tester.pumpAndSettle();
expect(tester.getRect(row(id)).top, closeTo(held.top, 1));
expect(find.text('Jump to latest · 4 new messages'), findsNothing);
expect(find.byKey(const Key('chat-jump-to-latest')), findsOneWidget);
});
}
@@ -35,8 +35,14 @@ JsonMap tallPage() => chatPage([
),
]);
ScrollController transcriptScroll(WidgetTester tester) =>
tester.widget<ListView>(find.byKey(const Key('chat-thread-s'))).controller!;
ScrollController transcriptScroll(WidgetTester tester) => tester
.widget<CustomScrollView>(
find.descendant(
of: find.byKey(const Key('chat-thread-s')),
matching: find.byType(CustomScrollView),
),
)
.controller!;
void main() {
testWidgets('a streaming transcript stays pinned to its newest end', (
@@ -181,14 +187,14 @@ void main() {
);
await tester.pumpAndSettle();
final saved = scroll.position.pixels;
expect(saved, greaterThan(0));
expect(positions.read('s'), closeTo(saved, 0.5));
expect(saved, lessThan(scroll.position.maxScrollExtent - 300));
expect(positions.read('s')!.offset, closeTo(saved, 0.5));
// Leaving the conversation disposes its view but not the destination's
// store.
await tester.pumpWidget(host(const SizedBox()));
await tester.pumpAndSettle();
expect(positions.read('s'), closeTo(saved, 0.5));
expect(positions.read('s')!.offset, closeTo(saved, 0.5));
await tester.pumpWidget(
host(
@@ -0,0 +1,68 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/chat/conversation/chat_transcript_anchor.dart';
JsonMap user(String id) => {'kind': 'user', 'key': id};
JsonMap assistant(List<String> ids, {bool streaming = false}) => {
'kind': 'assistant',
'key': ids.isEmpty ? 'chat-pending-response' : ids.first,
'messageIds': ids,
if (streaming) 'streaming': true,
};
void main() {
test('splits before the newest message row', () {
final rows = [
user('u1'),
assistant(['a2', 'a3']),
user('u4'),
];
expect(chatTranscriptAnchor(rows), 'a3');
expect(chatTranscriptAnchorIndex(rows, 'a3'), 1);
// Any message the folded turn holds finds it, as paging prepends into it.
expect(chatTranscriptAnchorIndex(rows, 'a2'), 1);
});
test('a streaming reply and the rows after it stay below the centre', () {
// A queued follow-up can be recorded after the reply still arriving.
final rows = [
user('u1'),
assistant(['a2']),
user('u3'),
assistant(['a4'], streaming: true),
user('u5'),
];
expect(chatTranscriptAnchor(rows), 'u3');
});
test('cards, activity lines and the pending shell are never the anchor', () {
final rows = [
user('u1'),
{'kind': 'activity', 'key': 'chat-activity-a2'},
assistant(['a2']),
assistant(const [], streaming: true),
{'kind': 'permission', 'key': 'chat-permission-p1'},
];
// The newest message row is a2, so the anchor is the row before it.
expect(chatTranscriptAnchor(rows), 'u1');
});
test('fewer than two message rows stay top-anchored', () {
expect(chatTranscriptAnchor(const []), isNull);
expect(chatTranscriptAnchor([user('u1')]), isNull);
expect(
chatTranscriptAnchor([
user('u1'),
{'kind': 'question', 'key': 'chat-question-q1'},
]),
isNull,
);
});
test('a missing anchor reports no split', () {
final rows = [user('u1'), user('u2')];
expect(chatTranscriptAnchorIndex(rows, null), -1);
expect(chatTranscriptAnchorIndex(rows, 'gone'), -1);
});
}