@flamingo-stack/openframe-frontend-core 0.0.244 → 0.0.246

package/dist/components/chat/utils/history-merge.d.ts

@@ -1,92 +0,0 @@
-import type { MessageContent } from '../types';
-/**
- * Reconciliation between persisted dialog history (processed GraphQL pages)
- * and the realtime messages a chat client accumulated from streaming chunks.
- *
- * This is the missing middle piece of the chat pipeline this lib already
- * owns: `processHistoricalMessages*` produces one stream, the realtime chunk
- * processor / segment accumulator produces the other, and every host (Mingo,
- * tickets, openframe-chat) needs to merge them whenever history is (re)fetched.
- * Hand-rolled versions of this merge have produced both duplicated turns
- * (synthetic kept alongside its persisted twin) and lost turns (synthetic
- * trimmed against a stale snapshot that didn't contain its persisted twin
- * yet) — the freshness rule below is the invariant that prevents both.
- *
- * Pure on purpose: the host owns WHEN to merge (react-query wiring, store
- * writes), this module owns HOW.
- */
-/** Minimal structural shape the merge needs — hosts pass their own message
- *  type and get it back. */
-export interface MergeableChatMessage {
-    id: string;
-    role: string;
-    content: MessageContent;
-    timestamp?: Date;
-}
-/** Ids minted client-side by realtime chunk processors
- *  (`assistant-<ts>-…` placeholder bubbles, `user-<ts>-…` peer messages,
- *  `error-<ts>` stream errors). They never match the Mongo ObjectIds history
- *  returns for the same turns. This is the cross-host contract every minting
- *  site (lib `use-chat`, Mingo / tickets chunk processors, openframe-chat)
- *  must keep matching — exported so it lives in exactly one place.
- *  `welcome-` and `optimistic-` ids are intentionally NOT listed: welcome
- *  bubbles are never persisted server-side, and optimistic user messages are
- *  deduped by content below. */
-export declare const SYNTHETIC_REALTIME_ID_PREFIXES: readonly ["assistant-", "user-", "error-"];
-/** Flattens DESC-sorted message pages (newest page first, newest message
- *  first within a page) into one chronological list. */
-export declare function flattenMessagePagesChronological<T>(pages: readonly {
-    messages: readonly T[];
-}[] | undefined): T[];
-/** Max `lastChunkStreamSeq` across history pages — the history half of the
- *  merge's seq-coverage signal (`HistoryMergeInput.historyMaxStreamSeq`),
- *  also used by hosts as the JetStream replay start offset. 0 = unstamped. */
-export declare function maxPersistedStreamSeq(pages: readonly {
-    messages: readonly {
-        lastChunkStreamSeq?: number | null;
-    }[];
-}[] | undefined): number;
-export interface HistoryMergeInput<M extends MergeableChatMessage> {
-    /** Processed history in chronological order (all fetched pages). */
-    processedHistory: M[];
-    /** Raw history message ids across all fetched pages, when they can differ
-     *  from processed ids (processing may merge/rename). Optional — pass when
-     *  available so raw-id duplicates are filtered too. */
-    rawHistoryIds?: ReadonlySet<string>;
-    /** Messages currently in the host store for this dialog (realtime + prior merges). */
-    existingMessages: M[];
-    /** Id of the in-flight streaming synthetic, if any. Never dropped.
-     *  IMPORTANT: hosts must not pass a STALE id here (e.g. a streaming entry
-     *  left behind by unmounting mid-stream) — gate it on the server-side
-     *  stream state when available, or the synthetic will be exempted forever. */
-    streamingMessageId: string | null;
-    /** Epoch ms when the history pages were fetched (react-query `dataUpdatedAt`).
-     *  Wall-clock freshness fallback used when seq coverage (below) is unknown:
-     *  a synthetic created AFTER this instant cannot be represented in the
-     *  snapshot, so it must be kept. NOTE this heuristic is blind to chunk
-     *  REPLAY, which re-mints synthetics for old turns with fresh timestamps —
-     *  pass the seq fields whenever the host tracks them. */
-    historyFetchedAt: number;
-    /** Max `lastChunkStreamSeq` across the raw history pages, when the backend
-     *  stamps it (see `maxPersistedStreamSeq`). Together with
-     *  `realtimeSeenStreamSeq` this gives an exact coverage signal that
-     *  replaces the wall-clock heuristic. */
-    historyMaxStreamSeq?: number;
-    /** Highest stream seq this client has consumed for the dialog (live or
-     *  replayed chunks). */
-    realtimeSeenStreamSeq?: number;
-}
-export declare function mergeHistoryWithRealtime<M extends MergeableChatMessage>(input: HistoryMergeInput<M>): M[];
-export interface HistoryPrependResult<M extends MergeableChatMessage> {
-    newMessages: M[];
-    boundaryMessageId?: string;
-    boundaryUpdates?: {
-        content: MessageContent;
-    };
-}
-/** Pagination path (an older page arrived via fetchNextPage): everything on
- *  screen stays; collect only the messages above the first already-known id,
- *  plus a content refresh for that boundary message if it changed. Returns
- *  null when there is nothing to apply. */
-export declare function computeHistoryPrepend<M extends MergeableChatMessage>(processedHistory: M[], existingMessages: M[]): HistoryPrependResult<M> | null;
-//# sourceMappingURL=history-merge.d.ts.map

package/dist/components/chat/utils/history-merge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"history-merge.d.ts","sourceRoot":"","sources":["../../../../src/components/chat/utils/history-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAwB,cAAc,EAAE,MAAM,UAAU,CAAA;AAEpE;;;;;;;;;;;;;;;GAeG;AAEH;4BAC4B;AAC5B,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,cAAc,CAAA;IACvB,SAAS,CAAC,EAAE,IAAI,CAAA;CACjB;AAED;;;;;;;;gCAQgC;AAChC,eAAO,MAAM,8BAA8B,4CAA6C,CAAA;AAMxF;wDACwD;AACxD,wBAAgB,gCAAgC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS;IAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAA;CAAE,EAAE,GAAG,SAAS,GAAG,CAAC,EAAE,CAGjH;AAED;;8EAE8E;AAC9E,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS;IAAE,QAAQ,EAAE,SAAS;QAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,EAAE,CAAA;CAAE,EAAE,GAAG,SAAS,GAC5F,MAAM,CAUR;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,oBAAoB;IAC/D,oEAAoE;IACpE,gBAAgB,EAAE,CAAC,EAAE,CAAA;IACrB;;2DAEuD;IACvD,aAAa,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACnC,sFAAsF;IACtF,gBAAgB,EAAE,CAAC,EAAE,CAAA;IACrB;;;kFAG8E;IAC9E,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC;;;;;6DAKyD;IACzD,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;6CAGyC;IACzC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;4BACwB;IACxB,qBAAqB,CAAC,EAAE,MAAM,CAAA;CAC/B;AAED,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,oBAAoB,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CA4GzG;AAED,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,oBAAoB;IAClE,WAAW,EAAE,CAAC,EAAE,CAAA;IAChB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,eAAe,CAAC,EAAE;QAAE,OAAO,EAAE,cAAc,CAAA;KAAE,CAAA;CAC9C;AAED;;;2CAG2C;AAC3C,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,oBAAoB,EAClE,gBAAgB,EAAE,CAAC,EAAE,EACrB,gBAAgB,EAAE,CAAC,EAAE,GACpB,oBAAoB,CAAC,CAAC,CAAC,GAAG,IAAI,CAiChC"}

package/src/components/chat/__tests__/chat-message-list.test.tsx

@@ -1,92 +0,0 @@
-import { render } from '@testing-library/react'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { Message } from '../types/message.types'
-
-const scrollToBottom = vi.fn()
-const stopScroll = vi.fn()
-
-function makeRef() {
-  const fn = ((el: HTMLElement | null) => {
-    ;(fn as { current: HTMLElement | null }).current = el
-  }) as ((el: HTMLElement | null) => void) & { current: HTMLElement | null }
-  fn.current = null
-  return fn
-}
-const scrollRefMock = makeRef()
-const contentRefMock = makeRef()
-
-vi.mock('use-stick-to-bottom', () => ({
-  useStickToBottom: () => ({
-    scrollRef: scrollRefMock,
-    contentRef: contentRefMock,
-    scrollToBottom,
-    stopScroll,
-  }),
-}))
-
-// Keep the row renderer trivial — these tests exercise ChatMessageList's
-// scroll orchestration, not markdown rendering.
-vi.mock('../chat-message-enhanced', () => ({
-  ChatMessageEnhanced: ({ content }: { content: string }) => <div>{content}</div>,
-}))
-
-import { ChatMessageList } from '../chat-message-list'
-
-// jsdom ships neither observer; the component instantiates both
-// (load-more sentinel + top-anchor settle watcher).
-class ObserverStub {
-  observe() {}
-  unobserve() {}
-  disconnect() {}
-}
-vi.stubGlobal('IntersectionObserver', ObserverStub)
-vi.stubGlobal('ResizeObserver', ObserverStub)
-
-const msg = (id: string, role: Message['role']): Message => ({
-  id,
-  role,
-  content: `body of ${id}`,
-  timestamp: new Date(),
-})
-
-describe('ChatMessageList force-scroll decisions', () => {
-  beforeEach(() => {
-    scrollToBottom.mockClear()
-  })
-
-  it('snaps to bottom when the dialog changes', () => {
-    const { rerender } = render(<ChatMessageList dialogId="d1" messages={[msg('m1', 'user')]} />)
-    scrollToBottom.mockClear()
-    rerender(<ChatMessageList dialogId="d2" messages={[msg('x1', 'user')]} />)
-    expect(scrollToBottom).toHaveBeenCalled()
-  })
-
-  it('snaps to bottom when a new user message is appended', () => {
-    const initial = [msg('m1', 'user'), msg('m2', 'assistant')]
-    const { rerender } = render(<ChatMessageList dialogId="d1" messages={initial} />)
-    scrollToBottom.mockClear()
-    rerender(<ChatMessageList dialogId="d1" messages={[...initial, msg('m3', 'user')]} />)
-    expect(scrollToBottom).toHaveBeenCalled()
-  })
-
-  it('does NOT scroll when an older page is prepended (load-more)', () => {
-    const initial = [msg('m3', 'user'), msg('m4', 'assistant')]
-    const { rerender } = render(
-      <ChatMessageList dialogId="d1" messages={initial} hasNextPage onLoadMore={() => {}} />,
-    )
-    scrollToBottom.mockClear()
-    const olderPage = [msg('m1', 'user'), msg('m2', 'assistant')]
-    rerender(
-      <ChatMessageList dialogId="d1" messages={[...olderPage, ...initial]} hasNextPage onLoadMore={() => {}} />,
-    )
-    expect(scrollToBottom).not.toHaveBeenCalled()
-  })
-
-  it('does NOT scroll on assistant-only appends (library owns streaming follow)', () => {
-    const initial = [msg('m1', 'user'), msg('m2', 'assistant')]
-    const { rerender } = render(<ChatMessageList dialogId="d1" messages={initial} />)
-    scrollToBottom.mockClear()
-    rerender(<ChatMessageList dialogId="d1" messages={[...initial, msg('m3', 'assistant')]} />)
-    expect(scrollToBottom).not.toHaveBeenCalled()
-  })
-})

package/src/components/chat/utils/__tests__/history-merge.test.ts

@@ -1,339 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { MessageSegment } from '../../types'
-import {
-  computeHistoryPrepend,
-  flattenMessagePagesChronological,
-  maxPersistedStreamSeq,
-  type MergeableChatMessage,
-  mergeHistoryWithRealtime,
-} from '../history-merge'
-
-interface TestMessage extends MergeableChatMessage {
-  role: 'user' | 'assistant'
-}
-
-const txt = (s: string): MessageSegment[] => [{ type: 'text', text: s }]
-const t = (ms: number) => new Date(ms)
-const ids = (msgs: TestMessage[]) => msgs.map((m) => m.id)
-const batchSeg = {
-  type: 'approval_batch',
-  data: { approvalRequestId: 'req-9', toolCalls: [] },
-} as unknown as MessageSegment
-
-// Persisted history (Mongo ids), first fetched at t=1000
-const U0: TestMessage = { id: 'aaaa0001', role: 'user', content: 'first question', timestamp: t(500) }
-const A0: TestMessage = { id: 'aaaa0002', role: 'assistant', content: txt('first answer'), timestamp: t(600) }
-
-// A later turn that happened via realtime (optimistic user + streamed reply)
-const OPT1: TestMessage = { id: 'optimistic-2000-x', role: 'user', content: 'second question', timestamp: t(2000) }
-const SYN1: TestMessage = { id: 'assistant-2100-x', role: 'assistant', content: txt('second answer'), timestamp: t(2100) }
-
-// Persisted counterparts of that turn (what a FRESH fetch returns)
-const U1: TestMessage = { id: 'aaaa0003', role: 'user', content: 'second question', timestamp: t(2000) }
-const A1: TestMessage = { id: 'aaaa0004', role: 'assistant', content: txt('second answer'), timestamp: t(2100) }
-
-describe('mergeHistoryWithRealtime', () => {
-  it('keeps realtime messages newer than a STALE history snapshot (no data loss)', () => {
-    // Reopen a dialog: first merge runs against the cached snapshot fetched
-    // BEFORE the second turn existed. The completed reply must survive — the
-    // realtime transport will not redeliver chunks this client already consumed.
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0],
-      existingMessages: [U0, A0, OPT1, SYN1],
-      streamingMessageId: null,
-      historyFetchedAt: 1000,
-    })
-    expect(ids(merged)).toEqual([U0.id, A0.id, OPT1.id, SYN1.id])
-  })
-
-  it('replaces optimistic + synthetic messages with their persisted twins on a FRESH snapshot', () => {
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, A1],
-      existingMessages: [U0, A0, OPT1, SYN1],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id])
-  })
-
-  it('never drops the in-flight streaming synthetic', () => {
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1], // assistant turn not persisted yet
-      existingMessages: [U0, A0, OPT1, SYN1],
-      streamingMessageId: SYN1.id,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toContain(SYN1.id)
-  })
-
-  it('dedupes mid-list synthetics against fresh history (no duplicated turns)', () => {
-    const OPT2: TestMessage = { id: 'optimistic-3000-x', role: 'user', content: 'third question', timestamp: t(3000) }
-    const SYN2: TestMessage = { id: 'assistant-3100-x', role: 'assistant', content: txt('third answer'), timestamp: t(3100) }
-    const U2: TestMessage = { id: 'aaaa0006', role: 'user', content: 'third question', timestamp: t(3000) }
-    const A2: TestMessage = { id: 'aaaa0007', role: 'assistant', content: txt('third answer'), timestamp: t(3100) }
-
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, A1, U2, A2],
-      existingMessages: [U0, A0, OPT1, SYN1, OPT2, SYN2],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id, U2.id, A2.id])
-  })
-
-  it('pins the more-complete synthetic over a partial history assistant (approval persistence race)', () => {
-    const partialHistA: TestMessage = { id: 'aaaa0005', role: 'assistant', content: [batchSeg], timestamp: t(2100) }
-    const fullSyn: TestMessage = {
-      id: 'assistant-2100-y',
-      role: 'assistant',
-      content: [...txt('second answer'), batchSeg],
-      timestamp: t(2100), // OLDER than the snapshot — pin must beat the freshness rule
-    }
-
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, partialHistA],
-      existingMessages: [U0, A0, OPT1, fullSyn],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toContain(fullSyn.id)
-    expect(ids(merged)).not.toContain(partialHistA.id)
-  })
-
-  it('drops the synthetic when history is at least as complete for the same approval batch', () => {
-    const fullHistA: TestMessage = {
-      id: 'aaaa0005',
-      role: 'assistant',
-      content: [...txt('second answer'), batchSeg],
-      timestamp: t(2100),
-    }
-    const lesserSyn: TestMessage = {
-      id: 'assistant-2100-y',
-      role: 'assistant',
-      content: [batchSeg],
-      timestamp: t(9000), // even NEWER than the snapshot — explicit drop wins
-    }
-
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, fullHistA],
-      existingMessages: [U0, A0, OPT1, lesserSyn],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toContain(fullHistA.id)
-    expect(ids(merged)).not.toContain(lesserSyn.id)
-  })
-
-  it('drops a replay-minted synthetic with a FRESH timestamp when seq coverage proves history contains it', () => {
-    // Chunk replay re-materializes an old turn into a synthetic stamped with
-    // the CURRENT time — newer than the snapshot, so the wall-clock rule
-    // would wrongly keep it next to its persisted twin (the "duplicated
-    // assistant message after navigating back" bug). Seq coverage is exact:
-    // history persisted through seq 80 >= client consumed through seq 80.
-    const replayedSyn: TestMessage = {
-      id: 'assistant-9999-r',
-      role: 'assistant',
-      content: txt('second answer'),
-      timestamp: t(9999), // newer than historyFetchedAt
-    }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, A1],
-      existingMessages: [U0, A0, replayedSyn],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-      historyMaxStreamSeq: 80,
-      realtimeSeenStreamSeq: 80,
-    })
-    expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id])
-  })
-
-  it('keeps an old-looking synthetic when seq coverage proves history is BEHIND (persistence lag)', () => {
-    // Client consumed through seq 90 but history only persisted through 80 —
-    // dropping the synthetic would lose content, no matter how old its
-    // wall-clock timestamp looks.
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0],
-      existingMessages: [U0, A0, OPT1, SYN1], // SYN1 timestamp 2100 <= fetchedAt
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-      historyMaxStreamSeq: 80,
-      realtimeSeenStreamSeq: 90,
-    })
-    expect(ids(merged)).toContain(SYN1.id)
-  })
-
-  it('falls back to the wall-clock rule when seq signals are unavailable', () => {
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, A1],
-      existingMessages: [U0, A0, OPT1, SYN1],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-      historyMaxStreamSeq: 0,
-      realtimeSeenStreamSeq: 0,
-    })
-    expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, A1.id])
-  })
-
-  it('keeps a just-sent optimistic message whose text repeats an older turn (stale snapshot)', () => {
-    // The user re-sends "first question" and the merge runs against a STALE
-    // snapshot (e.g. triggered by stream start). Content-dedup must not match
-    // it against the OLD persisted turn with the same text.
-    const repeat: TestMessage = { id: 'optimistic-9000-x', role: 'user', content: 'first question', timestamp: t(9000) }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0],
-      existingMessages: [U0, A0, repeat],
-      streamingMessageId: null,
-      historyFetchedAt: 1000,
-    })
-    expect(ids(merged)).toContain(repeat.id)
-  })
-
-  it('drops an optimistic repeat once the snapshot is fresh enough to contain its twin', () => {
-    const repeatPersisted: TestMessage = { id: 'bbbb0001', role: 'user', content: 'first question', timestamp: t(9000) }
-    const repeat: TestMessage = { id: 'optimistic-9000-x', role: 'user', content: 'first question', timestamp: t(9000) }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, repeatPersisted],
-      existingMessages: [U0, A0, repeat],
-      streamingMessageId: null,
-      historyFetchedAt: 10_000,
-    })
-    expect(ids(merged)).toEqual([U0.id, A0.id, repeatPersisted.id])
-  })
-
-  it('returns existing messages untouched when the history snapshot is empty', () => {
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [],
-      existingMessages: [OPT1, SYN1],
-      streamingMessageId: null,
-      historyFetchedAt: 10_000,
-    })
-    expect(merged).toEqual([OPT1, SYN1])
-  })
-
-  it('keeps a just-sent optimistic repeat even when seq coverage reports covered', () => {
-    // Optimistic messages are minted on send, not by chunks — seq coverage
-    // says nothing about them. Sent AFTER the snapshot → must survive even
-    // though its text matches an old persisted turn.
-    const repeat: TestMessage = { id: 'optimistic-9000-x', role: 'user', content: 'first question', timestamp: t(9000) }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0],
-      existingMessages: [U0, A0, repeat],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-      historyMaxStreamSeq: 80,
-      realtimeSeenStreamSeq: 80,
-    })
-    expect(ids(merged)).toContain(repeat.id)
-  })
-
-  it('pins the streaming twin even when it carries a persisted history id (adoption path)', () => {
-    // Chunk processors ADOPT an in-progress trailing assistant after a prior
-    // merge, so the streaming twin can have the SAME Mongo id as history's
-    // trailing message. The pin must beat the processed/raw id dedup or the
-    // turn vanishes from both lists.
-    const adopted: TestMessage = { id: 'aaaa0005', role: 'assistant', content: [batchSeg], timestamp: t(2100) }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, adopted],
-      rawHistoryIds: new Set([U0.id, A0.id, U1.id, adopted.id]),
-      existingMessages: [U0, A0, adopted],
-      streamingMessageId: adopted.id,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toEqual([U0.id, A0.id, U1.id, adopted.id])
-  })
-
-  it('never drops the streaming twin in the approval-batch resolution (pins it instead)', () => {
-    // History's trailing assistant fully persisted the approval turn, but the
-    // same batch id belongs to the LIVE streaming bubble (continuation after
-    // approve). Dropping it would orphan the host's streaming pointer and
-    // make continuation chunks invisible.
-    const fullHistA: TestMessage = {
-      id: 'aaaa0005',
-      role: 'assistant',
-      content: [...txt('second answer'), batchSeg],
-      timestamp: t(2100),
-    }
-    const liveTwin: TestMessage = { id: 'assistant-2100-y', role: 'assistant', content: [batchSeg], timestamp: t(2100) }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, fullHistA],
-      existingMessages: [U0, A0, OPT1, liveTwin],
-      streamingMessageId: liveTwin.id,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toContain(liveTwin.id)
-    expect(ids(merged)).not.toContain(fullHistA.id)
-  })
-
-  it('resolves the approval batch against the most recent twin when several share the batch id', () => {
-    const partialHistA: TestMessage = { id: 'aaaa0005', role: 'assistant', content: [batchSeg], timestamp: t(2100) }
-    const staleTwin: TestMessage = { id: 'assistant-1000-old', role: 'assistant', content: [batchSeg], timestamp: t(1000) }
-    const fullTwin: TestMessage = {
-      id: 'assistant-2100-y',
-      role: 'assistant',
-      content: [...txt('second answer'), batchSeg],
-      timestamp: t(2100),
-    }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0, U1, partialHistA],
-      existingMessages: [U0, A0, staleTwin, fullTwin],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toContain(fullTwin.id)
-    expect(ids(merged)).not.toContain(partialHistA.id)
-    expect(ids(merged)).not.toContain(staleTwin.id)
-  })
-
-  it('keeps welcome bubbles (never persisted server-side)', () => {
-    const welcome: TestMessage = { id: 'welcome-d1', role: 'assistant', content: 'Hi!', timestamp: t(100) }
-    const merged = mergeHistoryWithRealtime({
-      processedHistory: [U0, A0],
-      existingMessages: [welcome],
-      streamingMessageId: null,
-      historyFetchedAt: 5000,
-    })
-    expect(ids(merged)).toContain(welcome.id)
-  })
-})
-
-describe('computeHistoryPrepend', () => {
-  it('collects only messages above the first known id', () => {
-    const older: TestMessage = { id: 'aaaa0000', role: 'user', content: 'zeroth', timestamp: t(100) }
-    const result = computeHistoryPrepend([older, U0, A0], [U0, A0, SYN1])
-    expect(result).not.toBeNull()
-    expect(ids(result!.newMessages)).toEqual([older.id])
-    expect(result!.boundaryUpdates).toBeUndefined()
-  })
-
-  it('reports a boundary content refresh when the known boundary message changed', () => {
-    const updatedU0: TestMessage = { ...U0, content: 'first question (edited)' }
-    const result = computeHistoryPrepend([updatedU0, A0], [U0, A0])
-    expect(result).not.toBeNull()
-    expect(result!.newMessages).toEqual([])
-    expect(result!.boundaryMessageId).toBe(U0.id)
-    expect(result!.boundaryUpdates).toEqual({ content: 'first question (edited)' })
-  })
-
-  it('returns null when there is nothing to apply', () => {
-    expect(computeHistoryPrepend([U0, A0], [U0, A0])).toBeNull()
-  })
-})
-
-describe('page helpers', () => {
-  // Pages arrive DESC (newest page first, newest message first within a page).
-  const pages: { messages: { id: string; lastChunkStreamSeq?: number | null }[] }[] = [
-    { messages: [{ id: 'd', lastChunkStreamSeq: 40 }, { id: 'c', lastChunkStreamSeq: null }] },
-    { messages: [{ id: 'b', lastChunkStreamSeq: 20 }, { id: 'a' }] },
-  ]
-
-  it('flattenMessagePagesChronological reverses pages and messages into chronological order', () => {
-    expect(flattenMessagePagesChronological(pages).map((m) => m.id)).toEqual(['a', 'b', 'c', 'd'])
-    expect(flattenMessagePagesChronological(undefined)).toEqual([])
-  })
-
-  it('maxPersistedStreamSeq returns the highest stamped seq, 0 when absent', () => {
-    expect(maxPersistedStreamSeq(pages)).toBe(40)
-    expect(maxPersistedStreamSeq([{ messages: [{}] }])).toBe(0)
-    expect(maxPersistedStreamSeq(undefined)).toBe(0)
-  })
-})