zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/transcript/collapse.ts

@@ -1,789 +0,0 @@
-/**
- * Stream events to rows: pairs tool calls with their results, merges
- * streamed text, reconciles edits and spawns. Rows are cached per source
- * event so an appended event keeps every earlier row identical (memoised
- * rendering depends on it).
- */
-import type { EditOutcome, StreamEvent } from 'zidane/chat';
-import { displayNameFor, formatToolCall, isUserBashEvent } from 'zidane/chat/pure';
-import type { ChatEvent } from '../host';
-import { promptOriginOf } from '../prompt-origin';
-import { pairToolEvents } from './pairing';
-import { type Owned, type Row, parseBashExitMeta } from './rows';
-
-/**
- * When the paired result is an `error`, flip every `applied` outcome
- * to `failed` so the renderer doesn't paint approval-intent as if the
- * tool body succeeded. `denied` stays denied — that was the user's
- * choice, not the tool's failure.
- */
-function reconcileEditOnError(edit: NonNullable<StreamEvent['edit']>): NonNullable<StreamEvent['edit']> {
-  if (!edit.outcomes || edit.outcomes.length === 0) {
-    return edit;
-  }
-
-  let mutated = false;
-
-  const next: EditOutcome[] = edit.outcomes.map((o) => {
-    if (o.kind === 'applied') {
-      mutated = true;
-      return { kind: 'failed', reason: o.reason ?? 'Tool body did not apply this hunk' };
-    }
-
-    return o;
-  });
-
-  if (!mutated) {
-    return edit;
-  }
-
-  return { ...edit, outcomes: next };
-}
-
-/**
- * Per-event row cache. `collapseEvents` runs on EVERY stream drain tick
- * over the FULL events array. Without caching, each tick would build O(n)
- * fresh row objects (and a `formatToolCall` for every historical tool
- * event), O(n²) aggregate over a stream, with all-new identities that
- * defeat every memo'd row component downstream.
- *
- * Keyed by the event OBJECT: the live store is append-only
- * with immutable event objects (a streaming markdown delta replaces the
- * tail event with a new object), so a finalized event's ref is stable
- * for the life of the session. The `key` string covers every OTHER
- * input that shapes the row — index (ids embed it; a lazy-scrollback
- * prepend shifts indices and correctly invalidates), pairing state,
- * display flags — so a cache hit is exactly "this row would be
- * byte-identical". WeakMap: dropped sessions release their rows.
- */
-const rowCache = new WeakMap<object, { key: string; row: Row }>();
-
-/**
- * Stable per-event identity for row ids and cache keys. Rows do not
- * embed the ABSOLUTE event index: a lazy-scrollback prepend shifts
- * every index, which would change every React key at once (the whole list
- * remounts, expanded tool rows and fetched full results collapse).
- * A WeakMap-assigned monotonic id survives prepends (event objects are
- * immutable and reused), so existing rows keep their keys and only the
- * genuinely new page mounts.
- */
-const eventRowIds = new WeakMap<object, number>();
-let nextEventRowId = 1;
-
-function rowIdFor(event: object): number {
-  let id = eventRowIds.get(event);
-
-  if (id === undefined) {
-    id = nextEventRowId++;
-    eventRowIds.set(event, id);
-  }
-
-  return id;
-}
-
-/**
- * Hands the row identity of the prompts `next` dropped to their copies in
- * it. A store swaps a prompt on show for an updated copy when it learns its
- * turn (the host's binding, or the persisted copy a page read brings): the
- * copy's rows keep their keys, so they update in place instead of
- * remounting and playing their entrance again. A copy is the same prompt by
- * its words, as `reconcileEvents` matches prompts; the newest pair first, so
- * an older prompt with the same words keeps its own rows.
- *
- * @param prev - The events on show before the update.
- * @param next - The events after it.
- */
-export function inheritRowIdentity(prev: readonly ChatEvent[], next: readonly ChatEvent[]): void {
-  const kept = new Set(next);
-  const dropped = prev.filter((e) => e.kind === 'user-prompt' && !kept.has(e) && eventRowIds.has(e));
-  for (let i = next.length - 1; i >= 0 && dropped.length > 0; i--) {
-    const copy = next[i]!;
-    if (copy.kind !== 'user-prompt' || eventRowIds.has(copy)) continue;
-    let at = dropped.length - 1;
-    while (at >= 0 && !(dropped[at]!.text === copy.text && Boolean(dropped[at]!.synthetic) === Boolean(copy.synthetic)))
-      at--;
-    if (at === -1) continue;
-    eventRowIds.set(copy, eventRowIds.get(dropped[at]!)!);
-    dropped.splice(at, 1);
-  }
-}
-
-/**
- * Turn-boundary separators synthesized in front of a user prompt, keyed by
- * the PROMPT event (it already owns the `rowCache` slot), so the row keeps
- * its identity across stream ticks.
- */
-const autoSeparators = new WeakMap<object, Row>();
-
-function autoSeparatorFor(event: object, sid: number): Row {
-  let row = autoSeparators.get(event);
-
-  if (!row) {
-    row = { kind: 'separator', id: `s-u-${sid}` };
-    autoSeparators.set(event, row);
-  }
-
-  return row;
-}
-
-function cachedRow(event: object, key: string, build: () => Row): Row {
-  const hit = rowCache.get(event);
-
-  if (hit && hit.key === key) {
-    return hit.row;
-  }
-
-  const row = build();
-  rowCache.set(event, { key, row });
-  return row;
-}
-
-function own(e: ChatEvent): Owned {
-  const tag: Owned = {};
-
-  if (e.childId) {
-    tag.childId = e.childId;
-  }
-
-  if (e.depth != null) {
-    tag.depth = e.depth;
-  }
-
-  if (e.turnId) {
-    tag.turnId = e.turnId;
-  }
-
-  return tag;
-}
-
-function markdownRow(event: ChatEvent, mid: string): Row {
-  return cachedRow(event, `${mid}-${event.streaming ?? false}`, () => ({
-    ...own(event),
-    kind: 'markdown',
-    id: mid,
-    text: event.text,
-    streaming: event.streaming ?? false,
-  }));
-}
-
-/**
- * The one row of the thinking run `events[start..end)`, whose first event has text.
- *
- * @param kid - The run's row id, its per-(turn, owner) ordinal.
- */
-function thinkingRow(events: readonly ChatEvent[], start: number, end: number, kid: string): Row {
-  const event = events[start];
-  const parts = [event.text];
-
-  for (let k = start + 1; k < end; k++) {
-    if (events[k].text.trim()) {
-      parts.push(events[k].text);
-    }
-  }
-
-  const text = parts.join('\n');
-
-  /*
-   * Segment timing (live streams only): the live reducer
-   * (`applyLiveEvent`) stamps `thinkingStartedAt` on the segment's first event when it
-   * opens and REPLACES that event with one carrying `thinkingMs`
-   * when it closes — the new object identity misses the row cache
-   * and rebuilds exactly this one row. Replayed events carry
-   * neither field: `live` false, no duration.
-   */
-  const thinkingMs = event.thinkingMs;
-  const live = event.thinkingStartedAt != null && thinkingMs == null;
-
-  return cachedRow(event, `${kid}-${end - start}-${text.length}-${thinkingMs ?? (live ? 'live' : '')}`, () => ({
-    ...own(event),
-    kind: 'thinking',
-    id: kid,
-    text,
-    ...(thinkingMs != null ? { thinkingMs } : {}),
-    ...(live ? { live } : {}),
-  }));
-}
-
-/** A collapse pass, kept so the next tick can redo only what it replaced. */
-interface LastPass {
-  events: readonly ChatEvent[];
-  rows: readonly Row[];
-  showEditDiffs: boolean;
-  isStreaming: boolean;
-  /** Row index each markdown or thinking event feeds, -1 for every other event. */
-  rowOf: Int32Array;
-  /** Index of the event that heads the row each markdown or thinking event feeds. */
-  headOf: Int32Array;
-}
-
-/*
- * Keyed by the FIRST event: every tick hands a new events array, but the
- * store keeps each event object it does not replace, so the head event
- * names the transcript across ticks. A prepend or a swapped head misses
- * and takes the full pass.
- */
-const lastPasses = new WeakMap<object, LastPass>();
-
-/**
- * The per-tick fast path: when `events` differs from the last pass only by
- * markdown or thinking events replaced in place with ones of the same kind
- * and owner (a streaming delta), the last rows are copied and only the rows
- * those events feed are rebuilt. Such a swap leaves everything else the full
- * pass reads as it was: pairing and the spawn queue read other kinds, the
- * ordinals and prompt scopes count kinds and owners, and a thinking run
- * keeps its extent as long as its first event keeps having text.
- *
- * @returns The rows, or `null` when the full pass is needed.
- */
-function collapseTail(events: readonly ChatEvent[], showEditDiffs: boolean, isStreaming: boolean): Row[] | null {
-  const last = events.length > 0 ? lastPasses.get(events[0]) : undefined;
-
-  if (
-    !last ||
-    last.events.length !== events.length ||
-    last.showEditDiffs !== showEditDiffs ||
-    last.isStreaming !== isStreaming
-  ) {
-    return null;
-  }
-
-  const prev = last.events;
-  const { rowOf, headOf } = last;
-  const changed: number[] = [];
-
-  for (let i = 0; i < events.length; i++) {
-    const before = prev[i];
-    const after = events[i];
-
-    if (before === after) {
-      continue;
-    }
-
-    if (
-      (after.kind !== 'markdown' && after.kind !== 'thinking') ||
-      after.kind !== before.kind ||
-      after.turnId !== before.turnId ||
-      after.childId !== before.childId ||
-      after.depth !== before.depth
-    ) {
-      return null;
-    }
-
-    // A thinking event the full pass visits opens a row iff it has text: that must not flip.
-    if (after.kind === 'thinking' && (rowOf[i] === -1 || headOf[i] === i)) {
-      const opensRow = rowOf[i] !== -1;
-
-      if (Boolean(after.text.trim()) !== opensRow) {
-        return null;
-      }
-    }
-
-    changed.push(i);
-  }
-
-  const rows = last.rows.slice();
-
-  for (const i of changed) {
-    const r = rowOf[i];
-
-    // The full pass hands an id to every event it visits; the rest of a thinking run it skips.
-    if (r === -1 || headOf[i] === i) {
-      rowIdFor(events[i]);
-    }
-
-    if (r === -1) {
-      continue;
-    }
-
-    if (events[i].kind === 'markdown') {
-      rows[r] = markdownRow(events[i], rows[r].id);
-      continue;
-    }
-
-    const start = headOf[i];
-    let end = start + 1;
-
-    while (end < events.length && rowOf[end] === r) {
-      end++;
-    }
-
-    // Several events of one run may change in a tick: the row is rebuilt from all of them each time, the cache absorbing repeats.
-    rows[r] = thinkingRow(events, start, end, rows[r].id);
-  }
-
-  lastPasses.set(events[0], { ...last, events, rows });
-  return rows;
-}
-
-/**
- * `spawn` calls past the cap: `waiting` while no worker has started for them
- * (announced by `spawn-queued`), and when the worker of one that waited
- * started (its marker's `spawn.startedAt`, the host's clock), which is when
- * its time starts counting.
- */
-function spawnQueue(events: readonly ChatEvent[]): {
-  waiting: Map<string, { active: number; max: number }>;
-  startedAt: Map<string, number>;
-} {
-  const waiting = new Map<string, { active: number; max: number }>();
-  const startedAt = new Map<string, number>();
-  const queued = new Set<string>();
-  for (const event of events) {
-    if (event.kind === 'spawn-queued' && event.callId && event.waitingFor) {
-      waiting.set(event.callId, event.waitingFor);
-      queued.add(event.callId);
-    } else if (event.kind === 'spawn-start' && event.spawn?.callId) {
-      waiting.delete(event.spawn.callId);
-      if (queued.has(event.spawn.callId)) startedAt.set(event.spawn.callId, event.spawn.startedAt);
-    }
-  }
-  return { waiting, startedAt };
-}
-
-/**
- * A finished call's duration: the host's measure, less a spawn's wait for its
- * slot when both starts are known; else the gap between this window's arrival
- * stamps (an older host).
- */
-function doneDurationMs(
-  result: ChatEvent,
-  since: number | undefined,
-  workerStart: number | undefined,
-  callStart: number | undefined,
-): number | undefined {
-  if (result.durationMs !== undefined) {
-    return workerStart !== undefined && callStart !== undefined
-      ? Math.max(0, result.durationMs - (workerStart - callStart))
-      : result.durationMs;
-  }
-  return since !== undefined && result.receivedAt !== undefined ? Math.max(0, result.receivedAt - since) : undefined;
-}
-
-/**
- * A tool call that failed: its result says so, or it is a spawn the cap
- * refused in plain text (older recordings do not mark that as failed).
- *
- * @param tool - The tool row: its `name`, `ok`, and `result`.
- */
-export function toolFailed(tool: Pick<Extract<Row, { kind: 'tool' }>, 'name' | 'ok' | 'result'>): boolean {
-  return tool.ok === false || refusedSpawn(tool);
-}
-
-/**
- * A spawn the cap refused, as older recordings carry it: plain result text, not a failed call.
- *
- * @param tool - The tool row: its `name` and `result`.
- */
-export function refusedSpawn(tool: Pick<Extract<Row, { kind: 'tool' }>, 'name' | 'result'>): boolean {
-  return tool.name === 'spawn' && typeof tool.result === 'string' && /^(?:Tool error: )?Cannot spawn/.test(tool.result);
-}
-
-/**
- * Turns transcript events into rows: pairs tool calls with their results, merges streamed text, reconciles edits and spawns. Rows are cached per source event, so appending an event keeps every earlier row identical.
- *
- * @param events - The transcript events, oldest first.
- * @param showEditDiffs - Keeps the edit diff on edit tool rows. When false, the rows carry none.
- * @param isStreaming - A run is in flight, so the last reply may still be streaming.
- */
-export function collapseEvents(events: readonly ChatEvent[], showEditDiffs: boolean, isStreaming: boolean): Row[] {
-  return collapseTail(events, showEditDiffs, isStreaming) ?? collapseAll(events, showEditDiffs, isStreaming);
-}
-
-/**
- * The full pass of {@link collapseEvents}, over every event. Exported for tests that hold the fast path to it.
- *
- * @param events - The transcript events, oldest first.
- * @param showEditDiffs - Keeps the edit diff on edit tool rows.
- * @param isStreaming - A run is in flight.
- */
-export function collapseAll(events: readonly ChatEvent[], showEditDiffs: boolean, isStreaming: boolean): Row[] {
-  const rows: Row[] = [];
-  const rowOf = new Int32Array(events.length).fill(-1);
-  const headOf = new Int32Array(events.length);
-  const { pairings, consumedResultIndices } = pairToolEvents(events);
-  const { waiting, startedAt: workerStartedAt } = spawnQueue(events);
-
-  /*
-   * Markdown rows can't ride the WeakMap id: the store's delta coalescer
-   * REPLACES the streaming tail event object on every tick, so an
-   * object-keyed id would remount that row per delta. A per-(turn, owner)
-   * ordinal is stable across ticks, passes, AND prepends (older pages
-   * add other turns; ordinals are turn-scoped). Events without a turn id
-   * (a host that streams plain events) scope by the prompt they follow:
-   * the prompt event is never replaced, so its id holds.
-   */
-  const mdOrdinals = new Map<string, number>();
-  const thinkOrdinals = new Map<string, number>();
-  let promptScope = '@start';
-  const ordinalId = (ordinals: Map<string, number>, prefix: string, event: ChatEvent) => {
-    const scope = event.turnId ?? promptScope;
-    const key = `${scope}\u0000${event.childId ?? ''}`;
-    const ordinal = (ordinals.get(key) ?? 0) + 1;
-    ordinals.set(key, ordinal);
-    return `${prefix}-${scope}-${ordinal}`;
-  };
-
-  for (let i = 0; i < events.length; i++) {
-    const event = events[i];
-    const sid = rowIdFor(event);
-
-    if (consumedResultIndices.has(i)) {
-      continue;
-    }
-
-    switch (event.kind) {
-      case 'user-prompt': {
-        /*
-         * Exactly one turn boundary before every top-level prompt that
-         * follows content. Replay (`eventsFromTurns`) emits a separator
-         * here but a live prompt append does not, so the row list adds one
-         * itself. Otherwise the gap under the previous turn would depend on
-         * whether the session had been reloaded.
-         */
-        if (!event.childId && rows.length > 0 && rows[rows.length - 1].kind !== 'separator') {
-          rows.push(autoSeparatorFor(event, sid));
-        }
-        if (!event.childId) {
-          promptScope = `@u${sid}`;
-        }
-
-        rows.push(
-          cachedRow(event, `u-${sid}`, () => {
-            const eventAttachments = event.attachments;
-            const origin = promptOriginOf(event);
-            return {
-              ...own(event),
-              kind: 'user-prompt',
-              id: `u-${sid}`,
-              text: event.text,
-              ...(event.refs && event.refs.length > 0 ? { refs: event.refs } : {}),
-              ...(eventAttachments && eventAttachments.length > 0 ? { attachments: eventAttachments } : {}),
-              ...(event.synthetic ? { synthetic: true as const } : {}),
-              ...(origin ? { origin } : {}),
-            };
-          }),
-        );
-        break;
-      }
-      case 'markdown': {
-        rowOf[i] = rows.length;
-        headOf[i] = i;
-        rows.push(markdownRow(event, ordinalId(mdOrdinals, 'm', event)));
-        break;
-      }
-      case 'thinking': {
-        /*
-         * Defensive: an empty reasoning line paints a bare icon row with
-         * no text (the "double icon" artifact). Canonical replay does not
-         * emit them, but mid-stream edge cases might.
-         */
-        if (!event.text.trim()) {
-          break;
-        }
-
-        /*
-         * Fold the whole run of same-owner thinking lines into ONE row —
-         * a single icon per reasoning segment. Canonical replay emits one
-         * event per LINE (TUI gutter contract); live streaming coalesces
-         * per segment. Both normalize to the same single row here, so
-         * live and reloaded transcripts match and a 12-line reasoning
-         * paragraph costs one dot instead of twelve.
-         *
-         * The cache key spans the group (start, end, joined length), so
-         * the merged row's identity is stable across collapse passes once
-         * the group stops growing — only the live tail rebuilds.
-         */
-        let j = i + 1;
-
-        while (j < events.length) {
-          const next = events[j];
-
-          if (
-            next.kind !== 'thinking' ||
-            next.turnId !== event.turnId ||
-            next.childId !== event.childId ||
-            next.depth !== event.depth
-          ) {
-            break;
-          }
-
-          j++;
-        }
-
-        /*
-         * Like markdown rows, a single-event live segment gets its tail
-         * object replaced per coalesced delta — an object-keyed id would
-         * remount the row (and drop its manual expand state) every tick.
-         * The per-(turn, owner) ordinal is stable across ticks and across
-         * the open→closed identity swap, so the collapse transition
-         * animates in place instead of remounting.
-         */
-        const kid = ordinalId(thinkOrdinals, 'k', event);
-
-        rowOf.fill(rows.length, i, j);
-        headOf.fill(i, i, j);
-        rows.push(thinkingRow(events, i, j, kid));
-        i = j - 1;
-        break;
-      }
-      case 'info':
-        rows.push(
-          cachedRow(event, `i-${sid}`, () => ({
-            ...own(event),
-            kind: 'info',
-            id: `i-${sid}`,
-            text: event.text,
-            // Structured notices (severity + label chip) survive the projection
-            // so the transcript renders them like the TUI does, not as plain info.
-            ...(event.notice ? { notice: event.notice } : {}),
-          })),
-        );
-        break;
-      case 'separator':
-        // One boundary, never a double gap, and none at the very top.
-        if (rows.length > 0 && rows[rows.length - 1].kind !== 'separator') {
-          rows.push(cachedRow(event, `s-${sid}`, () => ({ kind: 'separator', id: `s-${sid}` })));
-        }
-        break;
-      case 'spawn-start':
-        rows.push(
-          cachedRow(event, `ss-${sid}`, () => ({
-            ...own(event),
-            kind: 'spawn-start',
-            id: `ss-${sid}`,
-            text: event.text,
-            ...(event.spawn ? { spawn: event.spawn } : {}),
-            ...(event.model ? { model: event.model } : {}),
-          })),
-        );
-        break;
-      case 'spawn-queued':
-        // No row: its call's tool row shows the wait (`spawnQueue`).
-        break;
-      case 'spawn-end':
-        rows.push(
-          cachedRow(event, `se-${sid}`, () => ({
-            ...own(event),
-            kind: 'spawn-end',
-            id: `se-${sid}`,
-            text: event.text,
-            ...(event.spawn ? { spawn: event.spawn } : {}),
-            ...(event.model ? { model: event.model } : {}),
-          })),
-        );
-        break;
-      case 'compact-summary':
-        if (event.compact) {
-          rows.push(
-            cachedRow(event, `cs-${sid}`, () => ({
-              kind: 'compact-summary',
-              id: `cs-${sid}`,
-              text: event.text,
-              compact: event.compact!,
-            })),
-          );
-        }
-
-        break;
-      case 'tool': {
-        if (isUserBashEvent(event)) {
-          const pair = pairings.get(i);
-          const paired = pair ? events[pair.resultIndex] : undefined;
-          /*
-           * Intermediate streamed tails carry `streaming: true`; the final
-           * result (and every replayed one) doesn't. An `error`-kind pair
-           * (host spawn failure) also terminates the running state.
-           */
-          const running = !paired || (pair?.resultKind === 'tool-result' && paired.streaming === true);
-          /*
-           * `resultIndex` in the key: each streamed tail is a NEW appended
-           * event, so the index advances per paint and invalidates the
-           * cached row even when two tails coincide in length.
-           */
-          const errored = pair?.resultKind === 'error';
-          const key = `ub-${sid}|${running}|${errored}|${paired ? rowIdFor(paired) : -1}|${paired?.text.length ?? -1}|${paired?.clipped ?? false}`;
-
-          rows.push(
-            cachedRow(event, key, () => {
-              const command = typeof event.input?.command === 'string' ? event.input.command : event.text;
-              const result = paired ? paired.text : null;
-
-              return {
-                ...own(event),
-                kind: 'user-bash',
-                id: `ub-${sid}`,
-                command,
-                result,
-                running,
-                exit: !running && !errored && result !== null ? parseBashExitMeta(result) : null,
-                ...(errored ? { errored: true } : {}),
-                ...(event.callId ? { callId: event.callId } : {}),
-                ...(paired?.clipped ? { resultClipped: true } : {}),
-              };
-            }),
-          );
-          break;
-        }
-
-        const pair = pairings.get(i);
-        const paired = pair ? events[pair.resultIndex] : undefined;
-        const pairedOk = pair ? pair.resultKind === 'tool-result' : null;
-        /*
-         * The cache key folds in everything beyond the event ref that
-         * shapes the row: pairing state (`resultIndex` — multi-result
-         * pairing re-points a callId to a LATER event, which can
-         * coincide in length with the old one — plus text length +
-         * clipped flag), the edit-diff display flag, and the
-         * streaming-derived `ok` coercion for unpaired calls.
-         */
-        const okCoerced = pairedOk === null && !isStreaming ? false : pairedOk;
-        const waitingFor = okCoerced === null && event.callId ? waiting.get(event.callId) : undefined;
-        // The host's start, else when this window received the call (an older host).
-        const callStart = event.startedAt ?? event.receivedAt;
-        // A call that waited for a slot counts from its worker's start, not its own.
-        const workerStart = event.callId ? workerStartedAt.get(event.callId) : undefined;
-        const since = workerStart ?? callStart;
-        const doneMs = paired ? doneDurationMs(paired, since, workerStart, callStart) : undefined;
-        const resuming = !paired && event.resuming === true;
-        const key = `t-${sid}|${showEditDiffs}|${okCoerced}|${paired ? rowIdFor(paired) : -1}|${paired?.text.length ?? -1}|${paired?.clipped ?? false}|${waitingFor ? 'w' : ''}|${since ?? ''}|${doneMs ?? ''}|${resuming ? 'r' : ''}`;
-
-        rows.push(
-          cachedRow(event, key, () => {
-            const toolName = event.tool ?? '?';
-            const rawInput = event.input;
-            const formatted = rawInput ? formatToolCall(toolName, rawInput) : null;
-
-            let result: string | null = paired ? paired.text : null;
-            const ok: boolean | null = okCoerced;
-
-            if (showEditDiffs && event.edit && ok === true) {
-              result = null;
-            }
-
-            const displayEdit = ok === false && event.edit ? reconcileEditOnError(event.edit) : event.edit;
-
-            return {
-              ...own(event),
-              kind: 'tool',
-              id: `t-${sid}`,
-              name: toolName,
-              displayName: displayNameFor(toolName, rawInput),
-              formatted,
-              rawInput,
-              edit: displayEdit,
-              result,
-              ok,
-              ...(event.callId ? { callId: event.callId } : {}),
-              ...(paired?.clipped ? { resultClipped: true } : {}),
-              ...(waitingFor ? { waitingFor } : {}),
-              ...(resuming ? { resuming: true as const } : {}),
-              ...(event.approval ? { approval: event.approval } : {}),
-              ...(event.parentToolCallId ? { parentId: event.parentToolCallId } : {}),
-              ...(doneMs !== undefined
-                ? { durationMs: doneMs }
-                : !paired && since !== undefined
-                  ? { startedAt: since }
-                  : {}),
-            };
-          }),
-        );
-        break;
-      }
-      case 'tool-result':
-        rows.push(
-          cachedRow(event, `tr-${sid}`, () => ({ ...own(event), kind: 'info', id: `tr-${sid}`, text: event.text })),
-        );
-        break;
-      case 'error':
-        rows.push(
-          cachedRow(event, `e-${sid}`, () => ({
-            ...own(event),
-            kind: 'error',
-            id: `e-${sid}`,
-            text: event.text,
-            ...(event.detail ? { detail: event.detail } : {}),
-            // What tells a run's own end from a tool's or a `/` command's error (`markRunFailures`).
-            ...(event.notice ? { notice: event.notice } : {}),
-            ...(event.tool ? { tool: event.tool } : {}),
-            ...(event.callId ? { callId: event.callId } : {}),
-          })),
-        );
-        break;
-      case 'session-event':
-        rows.push(
-          cachedRow(event, `sv-${sid}`, () => ({
-            ...own(event),
-            kind: 'session-event',
-            id: `sv-${sid}`,
-            text: event.text,
-            ...(event.sessionEvent ? { sessionEvent: event.sessionEvent } : {}),
-          })),
-        );
-        break;
-      case 'run-summary':
-        rows.push(
-          cachedRow(event, `rs-${sid}`, () => ({
-            ...own(event),
-            kind: 'run-summary',
-            id: `rs-${sid}`,
-            text: event.text,
-            ...(event.runSummary ? { runSummary: event.runSummary } : {}),
-          })),
-        );
-        break;
-      case 'command-detail':
-        rows.push(
-          cachedRow(event, `cd-${sid}`, () => ({
-            ...own(event),
-            kind: 'command-detail',
-            id: `cd-${sid}`,
-            text: event.text,
-            ...(event.label ? { label: event.label } : {}),
-            ...(event.syntax === 'diff' ? { syntax: 'diff' as const } : {}),
-          })),
-        );
-        break;
-      case 'command-note':
-        rows.push(
-          cachedRow(event, `cn-${sid}`, () => ({
-            ...own(event),
-            kind: 'command-note',
-            id: `cn-${sid}`,
-            text: event.text,
-          })),
-        );
-        break;
-      case 'custom':
-        /*
-         * Custom command blocks carry MANDATORY fallback markdown in
-         * `text`: a markdown row that keeps the renderer id and its data,
-         * so an extension renderer for the block draws it where one is
-         * registered, and the fallback draws everywhere else.
-         */
-        rows.push(
-          cachedRow(event, `cu-${sid}`, () => ({
-            ...own(event),
-            kind: 'markdown',
-            id: `cu-${sid}`,
-            text: event.text,
-            streaming: false,
-            ...(event.custom
-              ? {
-                  custom: {
-                    renderer: event.custom.renderer,
-                    ...(event.custom.data !== undefined ? { data: event.custom.data } : {}),
-                  },
-                }
-              : {}),
-          })),
-        );
-        break;
-    }
-  }
-
-  if (events.length > 0) {
-    lastPasses.set(events[0], { events, rows, showEditDiffs, isStreaming, rowOf, headOf });
-  }
-
-  return rows;
-}