zidane-ui 9.0.4 → 9.1.3

package/src/chat/transcript/use-transcript-rows.ts

@@ -1,195 +0,0 @@
-/**
- * The transcript's memo chain: events → the rows a `Transcript` paints,
- * one `useMemo` per pass of the headless pipeline so a setting change
- * re-runs only the passes after it, and every pass keeps row identity for
- * unchanged input (memoized rows rely on it). Plus the select-turn stops,
- * derived only while the mode is on and answered on demand for the app.
- */
-import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
-import type { StreamEvent } from 'zidane/chat';
-import { gatherCommandNotes, isCacheNotice, type RunReceipt, turnSelectionOwnership } from 'zidane/chat/pure';
-
-import type { ChatEvent } from '../headless/host';
-import {
-  batchThinkingRuns,
-  batchToolRuns,
-  type Cluster,
-  clusterByOwner,
-  collapseEvents,
-  computeSelectStops,
-  dockRunReceipts,
-  findLastStreamingRow,
-  foldExchanges,
-  markRunFailures,
-  nestedCallVisible,
-  nestToolCalls,
-  type Row,
-  type SelectStops,
-} from '../headless/transcript';
-import { isHiddenRow } from './TranscriptRow';
-
-/** The display options that shape the rows. */
-export interface TranscriptRowsInput {
-  /** Show cache notices (cache expired / break, dropped reasoning). */
-  showCacheNotices: boolean;
-  /** Show the calls a codemode script makes (those running a subagent always show). */
-  codemodeShowCalls: boolean;
-  /** Show edit diffs on edit tool rows. */
-  showEditDiffs: boolean;
-  /** Batch tool rows across the whole exchange, not only adjacent ones. */
-  groupToolCalls: boolean;
-  /** Dock run receipts under their reply; off hides them. */
-  showRunReceipt: boolean;
-  /** Compact density: fold each exchange's work behind one row. */
-  compact: boolean;
-}
-
-/** The rows a `Transcript` paints and what it derives from them. */
-export interface TranscriptRows {
-  /** The rows after every pass, in paint order. */
-  visibleRows: readonly Row[];
-  /** Run receipts docked under their reply, by the reply row's id. */
-  receiptByRowId: ReadonlyMap<string, RunReceipt>;
-  /** The failure row that offers to pick the work back up (the transcript's last word, once idle). */
-  resumableId: string | null;
-  /** `visibleRows` grouped into subagent blocks (`clusterByOwner`). */
-  clusters: readonly Cluster[];
-  /** The reply still streaming: the only row with a caret. */
-  lastStreamingRow: Row | null | undefined;
-}
-
-// zidane's helpers take `StreamEvent`s; a `ChatEvent` is one plus client-side extras.
-const asStream = (events: readonly ChatEvent[]) => events as unknown as readonly StreamEvent[];
-
-/**
- * Runs the headless pipeline over a transcript's events, one `useMemo` per pass, and returns the rows to paint.
- *
- * @param events - The session's events, oldest first.
- * @param streaming - A run is in flight, so the last reply may still be streaming.
- * @param input - The display options that shape the rows.
- */
-export function useTranscriptRows(
-  events: readonly ChatEvent[],
-  streaming: boolean,
-  { showCacheNotices, codemodeShowCalls, showEditDiffs, groupToolCalls, showRunReceipt, compact }: TranscriptRowsInput,
-): TranscriptRows {
-  /*
-   * Cache notices (`⚡ cache expired / break`, dropped reasoning) are the
-   * one info row a setting can hide. Filtered at the event level so every later pass
-   * (batching, folding, anchors) sees the same list the user does.
-   */
-  const shownEvents = useMemo(() => {
-    // A codemode script's calls show only with `codemodeShowCalls`, except those running a subagent.
-    const shown =
-      showCacheNotices && codemodeShowCalls
-        ? events
-        : events.filter(
-            (event) =>
-              (showCacheNotices || !isCacheNotice(event.notice)) && nestedCallVisible(event, codemodeShowCalls),
-          );
-    // A `/` command's notes close its exchange as one receipt line.
-    return gatherCommandNotes(asStream(shown)) as unknown as readonly ChatEvent[];
-  }, [events, showCacheNotices, codemodeShowCalls]);
-  // Nested calls become their calling row's `children` before any pass counts or batches rows.
-  const rows = useMemo(
-    () => nestToolCalls(collapseEvents(shownEvents, showEditDiffs, streaming)),
-    [shownEvents, showEditDiffs, streaming],
-  );
-
-  /*
-   * Row post-processing:
-   *   - `batchToolRuns` collapses ≥2 contiguous tool rows into a single
-   *     `tool-batch` row (one collapsible header, "Ran a command, read a
-   *     file ›"). `groupToolCalls` widens batching from adjacency to
-   *     exchange-wide.
-   *   - `batchThinkingRuns` then folds chained reasoning segments into
-   *     one `thinking-batch` header ("Thought 4 times" and the summed time).
-   *
-   * Subagent rows are not filtered here: `hideSubagentOutput` only decides
-   * a SubagentBlock's default collapsed state.
-   */
-  const batched = useMemo(() => batchThinkingRuns(batchToolRuns(rows, groupToolCalls)), [rows, groupToolCalls]);
-
-  // A failed run reads as one failure row, not as a `[✗ …]` reply (`markRunFailures`).
-  const failed = useMemo(() => markRunFailures(batched), [batched]);
-  // Run receipts fold into the closing assistant row, and disappear when `showRunReceipt` is off.
-  const { visibleRows: dockedRows, receiptByRowId } = useMemo(
-    () => dockRunReceipts(failed, showRunReceipt),
-    [failed, showRunReceipt],
-  );
-  // Compact density folds every exchange's work behind one row; full density skips the pass.
-  const visibleRows = useMemo(
-    () => (compact ? foldExchanges(dockedRows, streaming) : dockedRows),
-    [dockedRows, compact, streaming],
-  );
-
-  const resumableId = useMemo(() => {
-    if (streaming) return null;
-    for (let i = visibleRows.length - 1; i >= 0; i--) {
-      const row = visibleRows[i]!;
-      if (row.kind === 'separator' || row.kind === 'run-summary') continue;
-      return row.kind === 'error' && row.failure ? row.id : null;
-    }
-    return null;
-  }, [visibleRows, streaming]);
-
-  const clusters = useMemo(() => clusterByOwner(visibleRows), [visibleRows]);
-
-  return { visibleRows, receiptByRowId, resumableId, clusters, lastStreamingRow: findLastStreamingRow(visibleRows) };
-}
-
-/**
- * Select-turn stops (`computeSelectStops`): which turns the cursor walks
- * and which rows light up. Derived per transcript change while the mode is
- * on, never per keypress, and not at all outside it. `registerStops` hands
- * the app a function that answers from the rows painted right now (it asks
- * before the mode is on, and on every arrow), cached per input so a burst
- * of arrows computes once.
- *
- * @param visibleRows - The rows painted, from {@link useTranscriptRows}.
- * @param events - The session's events, oldest first.
- * @param showThinking - Reasoning rows are shown, so they can be stops.
- * @param selecting - Select-turn mode is on.
- * @param registerStops - Hands the app the stops source; returns its unregister function.
- */
-export function useSelectStops(
-  visibleRows: readonly Row[],
-  events: readonly ChatEvent[],
-  showThinking: boolean,
-  selecting: boolean,
-  registerStops: ((source: () => SelectStops) => () => void) | undefined,
-): SelectStops | null {
-  const stops = useMemo(
-    () =>
-      selecting
-        ? computeSelectStops(visibleRows, turnSelectionOwnership(asStream(events)), (row) =>
-            isHiddenRow(row, showThinking),
-          )
-        : null,
-    [selecting, visibleRows, events, showThinking],
-  );
-
-  const stopsInput = useRef({ rows: visibleRows, events, showThinking });
-  useLayoutEffect(() => {
-    stopsInput.current = { rows: visibleRows, events, showThinking };
-  });
-  const stopsCache = useRef<{
-    rows: readonly Row[];
-    events: readonly ChatEvent[];
-    show: boolean;
-    stops: SelectStops;
-  } | null>(null);
-  useEffect(() => {
-    if (!registerStops) return undefined;
-    return registerStops(() => {
-      const { rows, events: evts, showThinking: show } = stopsInput.current;
-      const hit = stopsCache.current;
-      if (hit && hit.rows === rows && hit.events === evts && hit.show === show) return hit.stops;
-      const fresh = computeSelectStops(rows, turnSelectionOwnership(asStream(evts)), (row) => isHiddenRow(row, show));
-      stopsCache.current = { rows, events: evts, show, stops: fresh };
-      return fresh;
-    });
-  }, [registerStops]);
-
-  return stops;
-}

package/src/chat/transcript/useComposerSearch.ts

@@ -1,106 +0,0 @@
-/**
- * The composer's `?` search over the conversation's transcript. The Chatbox owns the
- * MODE (sentinel entry/exit, query editing); this hosts the ENGINE, since the
- * match walk needs the transcript's scroll container and events. A `null`
- * query = mode inactive (the engine stays mounted but idle: its ownership
- * guard keeps it from clearing the ⌘F overlay's highlights).
- *
- * The mode and query are shared per session with its other windows
- * (`ChatHost.searchSync`): every local change is published, and a change
- * another window made to this session is applied here and handed to the
- * composer (`remoteApply`). The host never echoes a window's own change, so
- * any notice is a genuine remote one; `lastSync` only breaks the
- * apply→publish echo (the applied value round-trips through
- * `onQueryChange`). Without a host's `searchSync`, the search stays here.
- */
-import { useCallback, useEffect, useRef, useState, type RefObject } from 'react';
-
-import { useOptionalChatHost } from '../ChatProvider';
-import { useTranscriptSearch } from './useTranscriptSearch';
-
-/** What {@link useComposerSearch} returns. */
-export type ComposerSearch = ReturnType<typeof useComposerSearch>;
-
-/**
- * The composer's `?` search: its query, the engine over the transcript, and a change another window made
- * (`remoteApply`) for the composer to show.
- *
- * @param sessionId - The conversation searched.
- * @param scrollRef - The transcript's scroll container.
- * @param closeOverlay - Closes the ⌘F overlay (the two searches share one highlight registry).
- * @param useRevision - A hook returning a value whose identity changes when the transcript re-renders, read
- *   while the search is `active` (its rescans follow the transcript); a constant otherwise, so the stream never
- *   re-renders the conversation through this.
- */
-export function useComposerSearch<K extends string>(
-  sessionId: K | null,
-  scrollRef: RefObject<HTMLElement | null>,
-  closeOverlay: () => void,
-  useRevision: (active: boolean) => unknown,
-) {
-  const sync = useOptionalChatHost()?.searchSync;
-  const [query, setQuery] = useState<string | null>(null);
-  const revision = useRevision(query !== null);
-  const engine = useTranscriptSearch(scrollRef, query ?? '', revision);
-
-  const onQueryChange = useCallback(
-    (next: string | null) => {
-      setQuery(next);
-      // The two search surfaces share the document-wide highlight registry: entering
-      // composer search closes the ⌘F overlay (the Chatbox handles the reverse).
-      if (next !== null) closeOverlay();
-    },
-    [closeOverlay],
-  );
-
-  const lastSync = useRef<{ sessionId: string | null; active: boolean; query: string }>({
-    sessionId: null,
-    active: false,
-    query: '',
-  });
-  const [remoteApply, setRemoteApply] = useState<{ active: boolean; query: string; seq: number } | null>(null);
-
-  /** Composer search is per-transcript — drop it on session switch. */
-  useEffect(() => {
-    // eslint-disable-next-line react-hooks/set-state-in-effect -- a switch drops the old session's search
-    setQuery(null);
-    setRemoteApply(null);
-  }, [sessionId]);
-
-  useEffect(() => {
-    if (!sessionId) return;
-    /*
-     * Session just switched: in this commit `query` still holds the PREVIOUS
-     * session's value (the reset above lands next commit). Rebase the
-     * baseline and publish nothing — the old session's shared state belongs
-     * to the windows still on it.
-     */
-    if (lastSync.current.sessionId !== sessionId) {
-      lastSync.current = { sessionId, active: false, query: '' };
-      return;
-    }
-    const next = { sessionId, active: query !== null, query: query ?? '' };
-    if (lastSync.current.active === next.active && lastSync.current.query === next.query) return;
-    lastSync.current = next;
-    void sync?.set(sessionId, { active: next.active, query: next.query }).catch(() => undefined);
-  }, [query, sessionId, sync]);
-
-  /** Live mirror for the signal handler, subscribed once. */
-  const sessionIdRef = useRef(sessionId);
-  // eslint-disable-next-line react-hooks/refs -- the signal handler reads the live session without resubscribing
-  sessionIdRef.current = sessionId;
-  useEffect(
-    () =>
-      sync?.onChanged((signal) => {
-        if (signal.sessionId !== sessionIdRef.current) return;
-        lastSync.current = { sessionId: signal.sessionId, active: signal.active, query: signal.query };
-        setQuery(signal.active ? signal.query : null);
-        // Same exclusivity rule as a local entry: composer search closes ⌘F.
-        if (signal.active) closeOverlay();
-        setRemoteApply((prev) => ({ active: signal.active, query: signal.query, seq: (prev?.seq ?? 0) + 1 }));
-      }),
-    [sync, closeOverlay],
-  );
-
-  return { query, engine, onQueryChange, remoteApply };
-}

package/src/chat/transcript/useSelectTurnKeys.ts

@@ -1,204 +0,0 @@
-/**
- * Select-turn mode from the keyboard and the pointer, over the
- * `SelectTurnProvider` above: `enterSelectTurnMode` puts the cursor on the
- * last stop (browse from the bottom, like the TUI); ↑/↓ walk the stops,
- * Enter opens the turn, C copies, F forks, Esc leaves the mode. In the mode,
- * hovering a row (`data-stop`) moves the cursor and a click opens it. The
- * hint bar's buttons run the same commands (`registerCommands`).
- *
- * The stops are the Timeline's (`registerStops`: the rows it paints, work
- * merged into its answer); `fallbackStops` answers before it has mounted.
- * The listeners attach once and read everything at event time, so a run
- * streaming (the session row changing) never re-attaches them. Switching
- * session leaves the mode: the cursor is per session.
- */
-import { useCallback, useEffect, useRef } from 'react';
-
-import { isTypingTarget } from '../../keybindings/headless/key-scope';
-import { useChatLabels } from '../useChatLabels';
-import { useSelectTurn } from './SelectTurnProvider';
-
-/** Options for {@link useSelectTurnKeys}. */
-export interface SelectTurnKeysOptions<K extends string = string> {
-  /** The session on show, or `null`. */
-  sessionId: K | null;
-  /** The session's stops before its Timeline has mounted (the transcript's selectable turns). */
-  fallbackStops?(sessionId: K): readonly string[];
-  /** Opens a turn's details. */
-  open(sessionId: K, turnId: string): void;
-  /** Copies a turn; resolves whether there was something to copy. Absent: no copy. */
-  copy?(sessionId: K, turnId: string): Promise<boolean>;
-  /** Forks from a turn, calling `onCreated` once the fork exists; rejects when it failed. Absent: no fork. */
-  fork?(sessionId: K, turnId: string, onCreated: () => void): Promise<unknown>;
-  /** Whether something else owns input now (a modal is open). */
-  blocked?(): boolean;
-}
-
-const CONTROL = 'button, a, input, textarea, select, summary, [role="button"]';
-
-/**
- * Drives select-turn mode for the session on show.
- *
- * @param options - The session, its stops and the turn commands.
- * @returns The `enterSelectTurnMode` handler, `undefined` without a session.
- */
-export function useSelectTurnKeys<K extends string = string>(
-  options: SelectTurnKeysOptions<K>,
-): (() => void) | undefined {
-  const selectTurn = useSelectTurn<K>();
-  const labels = useChatLabels();
-  const { sessionId } = options;
-
-  // Read at event time: the listeners below attach once.
-  const latest = useRef({ options, selectTurn, labels });
-  // eslint-disable-next-line react-hooks/refs -- read at event time only, never during render
-  latest.current = { options, selectTurn, labels };
-
-  const stopsFor = useCallback((id: K): readonly string[] => {
-    const { selectTurn: sel, options: opts } = latest.current;
-    return sel.stops(id)?.order ?? opts.fallbackStops?.(id) ?? [];
-  }, []);
-
-  const copy = useCallback(async (id: K, turnId: string) => {
-    const { options: opts, selectTurn: sel, labels: l } = latest.current;
-    if (!opts.copy) return;
-    sel.flash((await opts.copy(id, turnId)) ? l.selectTurnCopied : l.selectTurnNothingToCopy);
-  }, []);
-
-  const fork = useCallback(async (id: K, turnId: string) => {
-    const { options: opts, selectTurn: sel, labels: l } = latest.current;
-    if (!opts.fork) return;
-    try {
-      await opts.fork(id, turnId, () => latest.current.selectTurn.exit());
-    } catch {
-      sel.flash(l.selectTurnForkFailed);
-    }
-  }, []);
-
-  // The hint bar's buttons run the same commands as the keys.
-  const { registerCommands } = selectTurn;
-  useEffect(
-    () =>
-      registerCommands({
-        open: (id, turnId) => latest.current.options.open(id, turnId),
-        copy: (id, turnId) => void copy(id, turnId),
-        fork: (id, turnId) => void fork(id, turnId),
-      }),
-    [registerCommands, copy, fork],
-  );
-
-  useEffect(() => {
-    /** The session the mode is on, when it is on in the session on show and nothing else owns input. */
-    const inMode = (): { id: K; turnId: string | null } | null => {
-      const { selectTurn: sel, options: opts } = latest.current;
-      const state = sel.state;
-      if (!state || !opts.sessionId || state.sessionId !== opts.sessionId || opts.blocked?.()) return null;
-      return { id: state.sessionId, turnId: state.turnId };
-    };
-
-    const onKey = (event: KeyboardEvent) => {
-      const mode = inMode();
-      if (!mode) return;
-      if (isTypingTarget(event)) return;
-      const sel = latest.current.selectTurn;
-
-      if (event.key === 'Escape') {
-        // Stopped here: Esc in the mode only leaves the mode; a second Esc reaches the app.
-        event.preventDefault();
-        event.stopPropagation();
-        sel.exit();
-        return;
-      }
-
-      const ids = stopsFor(mode.id);
-      if (ids.length === 0) return;
-      const currentIdx = mode.turnId ? ids.indexOf(mode.turnId) : -1;
-
-      if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
-        // Stopped here: the arrows would also scroll the transcript.
-        event.preventDefault();
-        event.stopPropagation();
-        const next =
-          event.key === 'ArrowUp'
-            ? currentIdx <= 0
-              ? 0
-              : currentIdx - 1
-            : currentIdx < 0
-              ? 0
-              : Math.min(ids.length - 1, currentIdx + 1);
-        sel.set(mode.id, ids[next]!);
-      } else if (event.key === 'Enter') {
-        event.preventDefault();
-        event.stopPropagation();
-        if (mode.turnId) latest.current.options.open(mode.id, mode.turnId);
-      } else if (
-        (event.key === 'c' || event.key === 'f') &&
-        !event.metaKey &&
-        !event.ctrlKey &&
-        !event.altKey &&
-        mode.turnId
-      ) {
-        event.preventDefault();
-        event.stopPropagation();
-        if (event.key === 'c') void copy(mode.id, mode.turnId);
-        else void fork(mode.id, mode.turnId);
-      }
-    };
-
-    /*
-     * Pointer: in the mode, rows carry `data-stop`. Hover moves the cursor,
-     * a click opens the turn. Clicks on controls inside a row (buttons,
-     * links, a fold's header) keep their own meaning, and a drag that
-     * selected text is a text selection, not a click.
-     */
-    const stopUnder = (target: EventTarget | null): string | null => {
-      const el = target instanceof Element ? target.closest<HTMLElement>('[data-stop]') : null;
-      return el?.dataset.stop ?? null;
-    };
-    // Only a pointer that actually moved: rows scrolling under a resting
-    // mouse (the cursor following the keyboard) must not steal the cursor.
-    let lastPointer = { x: Number.NaN, y: Number.NaN };
-    const onPointerMove = (event: PointerEvent) => {
-      if (event.clientX === lastPointer.x && event.clientY === lastPointer.y) return;
-      lastPointer = { x: event.clientX, y: event.clientY };
-      const mode = inMode();
-      const stop = mode ? stopUnder(event.target) : null;
-      if (mode && stop) latest.current.selectTurn.set(mode.id, stop);
-    };
-    const onClick = (event: MouseEvent) => {
-      const mode = inMode();
-      if (!mode || event.button !== 0) return;
-      const target = event.target instanceof Element ? event.target : null;
-      if (target?.closest(CONTROL)) return;
-      if ((window.getSelection()?.toString() ?? '') !== '') return;
-      const stop = stopUnder(target);
-      if (!stop) return;
-      latest.current.selectTurn.set(mode.id, stop);
-      latest.current.options.open(mode.id, stop);
-    };
-
-    document.addEventListener('keydown', onKey, true);
-    document.addEventListener('pointermove', onPointerMove, { passive: true });
-    document.addEventListener('click', onClick);
-    return () => {
-      document.removeEventListener('keydown', onKey, true);
-      document.removeEventListener('pointermove', onPointerMove);
-      document.removeEventListener('click', onClick);
-    };
-  }, [stopsFor, copy, fork]);
-
-  // The cursor is per session: switching session leaves the mode.
-  const { state, exit, enter } = selectTurn;
-  useEffect(() => {
-    if (state && state.sessionId !== sessionId) exit();
-  }, [sessionId, state, exit]);
-
-  const enterMode = useCallback(() => {
-    if (!sessionId) return;
-    const ids = stopsFor(sessionId);
-    if (ids.length === 0) return;
-    enter(sessionId, ids[ids.length - 1]!);
-  }, [sessionId, stopsFor, enter]);
-
-  return sessionId ? enterMode : undefined;
-}

package/src/chat/transcript/useSettledReveal.ts

@@ -1,57 +0,0 @@
-/**
- * A thread that just opened stays invisible (laid out, not shown) until
- * the chip lookups its rows start have answered, then fades in once.
- * Otherwise every answer reflows a line (plain text turning into a badge,
- * a badge gaining its title, a path turning into a file chip), and a view
- * pinned to the bottom moves everything above it each time: the thread
- * visibly jumps while it loads.
- *
- * Veiled from the frame `ready` (the transcript hydrated) holds for `key`,
- * before paint. Revealed once no lookup has been in flight for two frames
- * (a lookup's answer re-renders rows, which may start the next one), or at
- * `maxMs`, so a slow server (a Linear MCP call) never holds a thread back
- * for long: what lands later still moves, but that is the rare cold read;
- * views are kept across reloads (`reference-store.ts`).
- */
-import { useLayoutEffect, useState } from 'react';
-
-import { chipWorkBusy, whenChipsSettle } from '../headless/chip-settle';
-
-const REVEAL_MAX_MS = 500;
-
-const frame = () => new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-
-/** Waits until nothing has been in flight for two frames in a row, or `deadline` (`performance.now()`). */
-async function settled(deadline: number): Promise<void> {
-  for (;;) {
-    await frame();
-    await frame();
-    const left = deadline - performance.now();
-    if (!chipWorkBusy() || left <= 0) return;
-    await whenChipsSettle(left);
-  }
-}
-
-/**
- * Whether the thread is still veiled (see the module comment).
- *
- * @param key - The thread shown (`null`: none).
- * @param ready - Its transcript has hydrated.
- * @param maxMs - The longest it stays veiled.
- */
-export function useSettledReveal(key: string | null, ready: boolean, maxMs = REVEAL_MAX_MS): boolean {
-  const [veiledFor, setVeiledFor] = useState<string | null>(null);
-  useLayoutEffect(() => {
-    if (!key || !ready) return undefined;
-    // eslint-disable-next-line react-hooks/set-state-in-effect -- veiled before paint (layout effect) until the chips settle
-    setVeiledFor(key);
-    let live = true;
-    void settled(performance.now() + maxMs).then(() => {
-      if (live) setVeiledFor((current) => (current === key ? null : current));
-    });
-    return () => {
-      live = false;
-    };
-  }, [key, ready, maxMs]);
-  return key !== null && veiledFor === key;
-}