zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/smooth-stream.ts

@@ -1,76 +0,0 @@
-/**
- * Smooth streaming's pace: streamed reply text waits in a per-owner bucket
- * and leaves it at a steady rate, one slice a frame, so a reply reveals
- * evenly however unevenly its deltas arrive (the `smoothStreaming`
- * setting). The math only; the caller owns the frame loop: the desktop
- * app's `StreamProvider` drives one ticker for all its sessions,
- * `createStreamPacer` (`adapters/stream-pacer.ts`) one per run. The pace is
- * core's (`smoothCharsForTick`), the TUI's too: a continuous ramp from 200
- * to 4000 chars a second as the backlog grows, never a one-frame dump.
- */
-
-import { smoothCharsForTick, takeChars } from 'zidane/chat/pure';
-
-/** Tick interval (ms). Matches one frame at 60fps. */
-export const SMOOTH_TICK_MS = 16;
-
-/** One owner's streamed text waiting to reveal. */
-export interface DeltaBucket {
-  /** Un-emitted text awaiting drain. */
-  pending: string;
-
-  /**
-   * Fractional char accumulator — prevents drift when `cps * dtMs / 1000`
-   * doesn't divide evenly into 1 over a single tick. Without this, a slow
-   * base rate (200cps * 0.016s = 3.2 chars) would always floor to 3,
-   * effectively running at 187cps.
-   */
-  carry: number;
-}
-
-/**
- * Slice `n` UTF-16 code units off the head of `text`, extending by one
- * if the cut would land between a high surrogate and its low surrogate
- * (core's `takeChars`).
- *
- * Returns `[head, tail]`: caller decides what to do with each side.
- * `n <= 0` yields `['', text]`; `n >= text.length` yields `[text, '']`.
- *
- * @param text - The text to cut.
- * @param n - How many code units the head takes.
- */
-export function safeSurrogateSlice(text: string, n: number): [string, string] {
-  const { taken, rest } = takeChars(text, n);
-  return [taken, rest];
-}
-
-/**
- * Compute how many chars to emit from `bucket` on this tick, at the pace
- * its backlog sets. Mutates `bucket.carry` so caller can repeatedly tick
- * without re-seeding. An empty bucket yields 0.
- *
- * @param bucket - The bucket to tick.
- * @param dtMs - Milliseconds since its last tick.
- */
-export function tickBucket(bucket: DeltaBucket, dtMs: number): number {
-  const { take, carry } = smoothCharsForTick(bucket.pending.length, bucket.carry, dtMs);
-  bucket.carry = carry;
-  return take;
-}
-
-/**
- * Pop the head off `bucket.pending` using the surrogate-safe slice.
- * Convenience over a raw `safeSurrogateSlice` call when the caller
- * doesn't need the remainder.
- *
- * @param bucket - The bucket to drain.
- * @param n - How many code units to take (see {@link tickBucket}).
- */
-export function drainBucket(bucket: DeltaBucket, n: number): string {
-  const { taken, rest } = takeChars(bucket.pending, n);
-  bucket.pending = rest;
-  // A drained bucket starts the next stream from zero, as core's ticker does.
-  if (!rest) bucket.carry = 0;
-
-  return taken;
-}

package/src/chat/headless/store.ts

@@ -1,62 +0,0 @@
-/**
- * The one reactive shape the chat layer reads: `get()` the current value,
- * `subscribe()` to hear it changed. Hosts back it with whatever they have
- * (the desktop app's stream store, a WebSocket, a fixture); components read
- * it with `useReadable`, which is `useSyncExternalStore`.
- */
-import { useSyncExternalStore } from 'react';
-
-/** The shape every chat host exposes its data in: read the current value and subscribe to changes. */
-export interface Readable<T> {
-  /** Returns the current value. */
-  get(): T;
-  /** Registers a listener called after the value changes. Returns a function that removes the listener. */
-  subscribe(onChange: () => void): () => void;
-}
-
-/** A {@link Readable} you can also write to. */
-export interface Writable<T> extends Readable<T> {
-  /** Replaces the value, or computes the next one from the previous. Listeners run only when the value changes by `Object.is`. */
-  set(next: T | ((prev: T) => T)): void;
-}
-
-/**
- * A plain value store: the building block for simple hosts and fixtures.
- *
- * @param initial - The starting value.
- */
-export function writable<T>(initial: T): Writable<T> {
-  let value = initial;
-  const listeners = new Set<() => void>();
-  return {
-    get: () => value,
-    set(next) {
-      const resolved = typeof next === 'function' ? (next as (prev: T) => T)(value) : next;
-      if (Object.is(resolved, value)) return;
-      value = resolved;
-      for (const l of [...listeners]) l();
-    },
-    subscribe(onChange) {
-      listeners.add(onChange);
-      return () => listeners.delete(onChange);
-    },
-  };
-}
-
-/**
- * A store that never changes.
- *
- * @param value - The value the store always returns.
- */
-export function constant<T>(value: T): Readable<T> {
-  return { get: () => value, subscribe: () => () => {} };
-}
-
-/**
- * Subscribes a component to a {@link Readable} and returns its current value, re-rendering when it changes.
- *
- * @param store - The store to read.
- */
-export function useReadable<T>(store: Readable<T>): T {
-  return useSyncExternalStore(store.subscribe, store.get, store.get);
-}

package/src/chat/headless/streams/actions.ts

@@ -1,85 +0,0 @@
-/**
- * The session streams' writes as one object of bound functions: what an app
- * hands to the code that dispatches (a send, a reset, a hydration) without
- * subscribing it to the store. Created once per streams, so every function
- * keeps its identity for as long as the streams live.
- */
-import type { SystemMdFile } from 'zidane/chat';
-import type { PromptSegmentRef } from 'zidane/chat/pure';
-
-import type { ChatAttachment } from '../host';
-import type { LoadEarlierOptions, SessionStreams } from './session-streams';
-import type { SessionStreamPage } from './types';
-
-/** The bound writes of a {@link SessionStreams}, from {@link createSessionStreamActions}. */
-export interface SessionStreamActions<K extends string = string> {
-  /** Clears the session's transcript and run state, keeping its record. */
-  reset(sessionId: K): void;
-  /** Forgets the session (a deleted one). */
-  drop(sessionId: K): void;
-  /** Shows a sent prompt at once; the host's echo of it is then dropped. */
-  appendUserPrompt(
-    sessionId: K,
-    text: string,
-    refs?: readonly PromptSegmentRef[],
-    attachments?: readonly ChatAttachment[],
-  ): void;
-  /** Unwinds one pending echo after a failed send. */
-  dropPendingEcho(sessionId: K, text: string): void;
-  /** Keeps a queued prompt's previews until the host sends it. */
-  rememberPromptPreviews(sessionId: K, text: string, attachments: readonly ChatAttachment[]): void;
-  /** Unwinds a queued prompt's previews after a failed enqueue. */
-  dropPromptPreviews(sessionId: K, text: string): void;
-  /** Re-keys a queued prompt's previews after its text is edited. */
-  renamePromptPreviews(sessionId: K, from: string, to: string): void;
-  /** Adds an error row to the session's transcript. */
-  appendErrorEvent(sessionId: K, text: string): void;
-  /** Whether the store holds any record for the session (no subscription). */
-  hasEvents(sessionId: K): boolean;
-  /** Seeds a run seen only through the session list. */
-  markRunning(sessionId: K): void;
-  /** Confirms the session is idle (a run that ended while nobody listened). */
-  confirmIdle(sessionId: K): void;
-  /** Evicts hydrated windows outside `keep`; running and mid-scrollback sessions stay. */
-  evictExcept(keep: ReadonlySet<K>): void;
-  /** Forgets every session. */
-  dropAll(): void;
-  /** Hydrates a tail page (events and scrollback bookkeeping, one notify). */
-  setEventsPage(sessionId: K, page: SessionStreamPage): void;
-  /** Seeds the session's `SYSTEM.md` override. */
-  seedSystemMd(sessionId: K, file: SystemMdFile | null): void;
-  /** Names the session the user reads: its run-end compaction waits until it is backgrounded. */
-  noteActiveSession(sessionId: K | null): void;
-  /** Fetches and splices the page before the window. `false` when no fetch started. */
-  loadEarlier(sessionId: K, options?: LoadEarlierOptions): boolean;
-}
-
-/**
- * Binds the writes of `streams` (and its store) into one stable object.
- *
- * @param streams - The session streams to write to.
- */
-export function createSessionStreamActions<K extends string>(streams: SessionStreams<K>): SessionStreamActions<K> {
-  const store = streams.store;
-  return {
-    reset: (sessionId) => streams.reset(sessionId),
-    drop: (sessionId) => streams.drop(sessionId),
-    dropAll: () => streams.dropAll(),
-    evictExcept: (keep) => streams.evictExcept(keep),
-    setEventsPage: (sessionId, page) => store.setEventsPage(sessionId, page),
-    seedSystemMd: (sessionId, file) => store.seedSystemMd(sessionId, file),
-    loadEarlier: (sessionId, options) => streams.loadEarlier(sessionId, options),
-    appendUserPrompt: (sessionId, text, refs, attachments) =>
-      store.appendUserPrompt(sessionId, text, refs, attachments),
-    dropPendingEcho: (sessionId, text) => store.dropPendingEcho(sessionId, text),
-    rememberPromptPreviews: (sessionId, text, attachments) =>
-      store.rememberPromptPreviews(sessionId, text, attachments),
-    dropPromptPreviews: (sessionId, text) => store.dropPromptPreviews(sessionId, text),
-    renamePromptPreviews: (sessionId, from, to) => store.renamePromptPreviews(sessionId, from, to),
-    appendErrorEvent: (sessionId, text) => store.appendErrorEvent(sessionId, text),
-    hasEvents: (sessionId) => store.hasEvents(sessionId),
-    markRunning: (sessionId) => store.markRunning(sessionId),
-    confirmIdle: (sessionId) => streams.confirmIdle(sessionId),
-    noteActiveSession: (sessionId) => streams.noteActiveSession(sessionId),
-  };
-}

package/src/chat/headless/streams/index.ts

@@ -1,25 +0,0 @@
-/**
- * The session stream store: every session's live transcript and run state,
- * reduced from zidane's host signals, with per-session subscriptions,
- * smooth-stream pacing, lazy scrollback and run-end compaction. React-free.
- */
-export { createSessionStreams } from './session-streams';
-export type { LoadEarlierOptions, SessionStreams, SessionStreamsOptions } from './session-streams';
-export { SessionStreamStore } from './store';
-export type { SessionStreamStoreOptions, SessionStreamWrite } from './store';
-export type { DrainPlan } from './pacer';
-export { defaultFrameScheduler } from './scheduler';
-export type { FrameScheduler } from './scheduler';
-export { mergeLiveTail } from './merge';
-export { mergePromptPreviews, missingPreviewData } from './prompt-previews';
-export { createSessionStreamActions } from './actions';
-export type { SessionStreamActions } from './actions';
-export { selectEditEvents, stableSelection } from './selectors';
-export type {
-  OtherStreamSignal,
-  SessionFallbackModel,
-  SessionPageState,
-  SessionRetryState,
-  SessionStreamPage,
-  SessionStreamSignal,
-} from './types';

package/src/chat/headless/streams/live-events.ts

@@ -1,124 +0,0 @@
-/**
- * zidane's live event rule, on zidane's own reducers (`zidane/chat/pure`):
- * a `markdown` event with `streaming: true` and every `thinking` event are
- * deltas that grow the same owner's open block (the parent agent's, or a
- * subagent's by `childId`); every other event is a whole row, appended.
- * This is how the TUI and the desktop app reduce the engine's `event`
- * signals. React-free and runtime-free: the SSE server keeps its cached
- * transcripts with it too.
- *
- * A thinking lane is live from its first event (`thinkingStartedAt`) until
- * it closes (`thinkingMs`): a non-thinking event of its owner closes it, and
- * the run's end closes every lane still open.
- */
-import type { Owner, StreamEvent } from 'zidane/chat';
-import {
-  appendMarkdownDelta,
-  appendThinkingLines,
-  finalizeStreamingMarkdown,
-  mergeTargetIndex,
-  ownerOf,
-  type MarkdownDeltaOptions,
-} from 'zidane/chat/pure';
-
-import type { ChatEvent } from '../host';
-
-/** A live transcript event with the live timings (`ChatEvent`'s, the desktop app's `GuiStreamEvent`'s). */
-type TimedEvent = Omit<StreamEvent, 'attachments'> & Pick<ChatEvent, 'thinkingStartedAt' | 'thinkingMs' | 'receivedAt'>;
-
-// The reducers are generic over StreamEvent; a timed event only narrows `attachments`.
-type Rows = StreamEvent[];
-const rows = (events: readonly TimedEvent[]) => events as unknown as Rows;
-const timed = <E extends TimedEvent>(events: readonly TimedEvent[]) => events as unknown as E[];
-
-const closed = <E extends TimedEvent>(event: E, startedAt: number, now: number): E => ({
-  ...event,
-  thinkingMs: Math.max(0, now - startedAt),
-});
-
-/**
- * Closes `owner`'s open thinking segment (the tail's, any owner, when `owner`
- * is omitted): the segment's stamped first event is REPLACED by one carrying
- * `thinkingMs`. The fresh object identity is deliberate: the transcript's
- * collapse cache is keyed by event object, so exactly that one row rebuilds.
- * The segment is the collapse merge's: strictly consecutive thinking events
- * sharing turnId / childId / depth.
- *
- * @param events - The transcript so far.
- * @param owner - The owner whose segment closes; the tail's when omitted.
- * @param now - Epoch milliseconds the segment closes at. Defaults to the current time.
- */
-export function closeThinkingSegment<E extends TimedEvent>(events: E[], owner?: Owner, now = Date.now()): E[] {
-  // An owner's segment may sit behind concurrent siblings' rows.
-  const end = owner === undefined ? events.length - 1 : mergeTargetIndex(events as unknown as Rows, owner);
-  const tail = end >= 0 ? events[end] : undefined;
-  if (!tail || tail.kind !== 'thinking') return events;
-  let start = end;
-  while (start > 0) {
-    const prev = events[start - 1]!;
-    if (
-      prev.kind !== 'thinking' ||
-      prev.turnId !== tail.turnId ||
-      prev.childId !== tail.childId ||
-      prev.depth !== tail.depth
-    )
-      break;
-    start--;
-  }
-  for (let i = start; i <= end; i++) {
-    const startedAt = events[i]!.thinkingStartedAt;
-    if (startedAt !== undefined && events[i]!.thinkingMs === undefined) {
-      const next = events.slice();
-      next[i] = closed(events[i]!, startedAt, now);
-      return next;
-    }
-  }
-  return events;
-}
-
-/**
- * One live event folded into a transcript (`now` stamps arrival on tool rows and thinking lanes).
- * Generic over the event type so the desktop app's `GuiStreamEvent` lanes fold the same way.
- *
- * @param events - The transcript so far.
- * @param event - The live event to fold in.
- * @param now - Epoch milliseconds stamped on tool rows and thinking lanes as their arrival time. Defaults to the current time.
- * @param markdown - How streamed markdown merges (`segmentChars`: where a long message splits). The reducer's default when omitted.
- */
-export function applyLiveEvent<E extends TimedEvent = ChatEvent>(
-  events: readonly E[],
-  event: E,
-  now = Date.now(),
-  markdown?: MarkdownDeltaOptions,
-): E[] {
-  const owner = ownerOf(event as StreamEvent);
-  if (event.kind === 'thinking') {
-    return timed<E>(
-      appendThinkingLines(rows(events), event.text, owner, event.depth, event.turnId, {
-        onLaneOpen: (row) => ({ ...row, thinkingStartedAt: now }) as StreamEvent,
-      }),
-    );
-  }
-  const open = closeThinkingSegment(events as E[], owner, now);
-  if (event.kind === 'markdown' && event.streaming)
-    return timed<E>(appendMarkdownDelta(rows(open), event.text, owner, event.depth, event.turnId, markdown));
-  if (event.kind === 'tool' || event.kind === 'tool-result')
-    return [...open, event.receivedAt ? event : { ...event, receivedAt: now }];
-  return [...open, event];
-}
-
-/**
- * A run ended: close the blocks still marked streaming and every thinking lane still open.
- *
- * @param events - The transcript so far.
- * @param now - Epoch milliseconds the open lanes close at. Defaults to the current time.
- */
-export function finishLive<E extends TimedEvent = ChatEvent>(events: readonly E[], now = Date.now()): E[] {
-  const open = events.some((e) => e.thinkingStartedAt !== undefined && e.thinkingMs === undefined);
-  const settled = open
-    ? events.map((e) =>
-        e.thinkingStartedAt !== undefined && e.thinkingMs === undefined ? closed(e, e.thinkingStartedAt, now) : e,
-      )
-    : events;
-  return timed<E>(finalizeStreamingMarkdown(rows(settled)));
-}

package/src/chat/headless/streams/merge.ts

@@ -1,60 +0,0 @@
-import { reconcileEvents } from 'zidane/chat/pure';
-
-import type { ChatEvent } from '../host';
-
-/**
- * Hydrate a live-only window: the disk page followed by the live events
- * that disk does not have yet. Persisted turns and their live events share
- * a `turnId` (hooks pre-mint it), so the boundary is the LAST live event
- * whose turn is on the page — everything after it (the in-flight turn's
- * streaming markdown, a display-only error row) is kept; everything before
- * it is superseded by its persisted form. No live turn on the page (the
- * run's first turn is still streaming) keeps the whole live lane.
- *
- * Untagged live events in the kept suffix (a `user-prompt` echo is
- * broadcast bare and only retagged by `prompt-turns`, `steer:inject` echoes
- * likewise) are dropped when the page's trailing part already holds the
- * same `kind` + `text` — otherwise the disk copy and the echo both render.
- *
- * @param live - The window's live events (never hydrated from disk).
- * @param page - The persisted page to hydrate it with.
- */
-export function mergeLiveTail(live: readonly ChatEvent[], page: readonly ChatEvent[]): ChatEvent[] {
-  if (live.length === 0) {
-    return [...page];
-  }
-
-  const persisted = new Set<string>();
-  for (const event of page) {
-    if (event.turnId) {
-      persisted.add(event.turnId);
-    }
-  }
-
-  let lastPersisted = -1;
-  for (let i = live.length - 1; i >= 0; i--) {
-    const turnId = live[i]!.turnId;
-    if (turnId && persisted.has(turnId)) {
-      lastPersisted = i;
-      break;
-    }
-  }
-
-  // Page events after the boundary turn; the whole page when there is none.
-  const boundaryTurn = lastPersisted === -1 ? undefined : live[lastPersisted]!.turnId;
-  let trailingFrom = 0;
-  if (boundaryTurn) {
-    for (let i = page.length - 1; i >= 0; i--) {
-      if (page[i]!.turnId === boundaryTurn) {
-        trailingFrom = i + 1;
-        break;
-      }
-    }
-  }
-  const trailing = page.slice(trailingFrom);
-  const suffix = live
-    .slice(lastPersisted + 1)
-    .filter((event) => event.turnId || !trailing.some((p) => p.kind === event.kind && p.text === event.text));
-
-  return [...reconcileEvents(live, page), ...suffix];
-}

package/src/chat/headless/streams/pacer.ts

@@ -1,189 +0,0 @@
-/**
- * Smooth-stream buckets, one per (session, owner): streamed markdown waits
- * here and a once-per-frame ticker drains it at a steady pace. Keyed by
- * session AND owner so concurrent sessions and nested subagents pace
- * independently. The helpers mutate the bucket map in place and return the
- * text to reveal as a {@link DrainPlan}, which the store applies in one pass.
- */
-import type { Owner } from 'zidane/chat';
-
-import { type DeltaBucket, drainBucket, tickBucket } from '../smooth-stream';
-import type { SessionStreamSignal } from './types';
-
-const PARENT_OWNER: Owner = 'parent';
-
-/**
- * Bucket value extends `DeltaBucket` with the most-recent markdown event's
- * ownership tags so the ticker can synthesize matching child / depth / turn
- * metadata when emitting a delta — without this, drained chars would
- * accidentally surface under `parent` and break subagent grouping.
- */
-export interface OwnerBucket extends DeltaBucket {
-  childId?: string;
-  depth?: number;
-  turnId?: string;
-}
-
-/** Streamed markdown released from a smooth-stream bucket, applied by {@link SessionStreamStore.applyDrainPlan}. */
-export interface DrainPlan<K extends string = string> {
-  /** The session the text belongs to. */
-  sessionId: K;
-  /** The owner it streamed under: `'parent'` or a subagent's child id. */
-  ownerKey: string;
-  /** The text to reveal. */
-  text: string;
-  /** The subagent's child id, for a subagent's reply. */
-  childId?: string;
-  /** The subagent's nesting depth. */
-  depth?: number;
-  /** The turn the text belongs to. */
-  turnId?: string;
-}
-
-export type BucketMap<K extends string> = Map<K, Map<string, OwnerBucket>>;
-
-export function getOrCreateBucket<K extends string>(
-  buckets: BucketMap<K>,
-  sessionId: K,
-  ownerKey: string,
-): OwnerBucket {
-  let sessionMap = buckets.get(sessionId);
-
-  if (!sessionMap) {
-    sessionMap = new Map();
-    buckets.set(sessionId, sessionMap);
-  }
-
-  let bucket = sessionMap.get(ownerKey);
-
-  if (!bucket) {
-    bucket = { pending: '', carry: 0 };
-    sessionMap.set(ownerKey, bucket);
-  }
-
-  return bucket;
-}
-
-export function allBucketsEmpty<K extends string>(buckets: BucketMap<K>): boolean {
-  for (const sessionMap of buckets.values()) {
-    for (const bucket of sessionMap.values()) {
-      if (bucket.pending.length > 0) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-/**
- * Build the per-tick drain plan. Mutates each bucket's `pending` and
- * `carry` so the caller's store update only needs to apply the
- * synthetic deltas — no second pass to update bucket bookkeeping.
- */
-export function planTickDrain<K extends string>(buckets: BucketMap<K>, dtMs: number): DrainPlan<K>[] {
-  const plan: DrainPlan<K>[] = [];
-
-  for (const [sessionId, sessionMap] of buckets) {
-    for (const [ownerKey, bucket] of sessionMap) {
-      const n = tickBucket(bucket, dtMs);
-
-      if (n === 0) {
-        continue;
-      }
-
-      const text = drainBucket(bucket, n);
-
-      if (text.length === 0) {
-        continue;
-      }
-
-      plan.push({
-        sessionId,
-        ownerKey,
-        text,
-        childId: bucket.childId,
-        depth: bucket.depth,
-        turnId: bucket.turnId,
-      });
-    }
-  }
-
-  return plan;
-}
-
-/**
- * Drain decisions when a non-markdown signal arrives. Turn / run
- * boundaries drain unconditionally (across owners) so finalize sees
- * a clean tail; other events drain only the matching owner so unrelated
- * subagents keep their paced rhythm.
- */
-export function planDrainBeforeSignal<K extends string>(
-  buckets: BucketMap<K>,
-  signal: SessionStreamSignal<K>,
-): DrainPlan<K>[] {
-  const plan: DrainPlan<K>[] = [];
-
-  if (signal.kind === 'run:end' || signal.kind === 'run:start') {
-    const sessionMap = buckets.get(signal.sessionId);
-
-    if (sessionMap) {
-      for (const [ownerKey, bucket] of sessionMap) {
-        pushFullDrain(plan, signal.sessionId, ownerKey, bucket);
-      }
-    }
-
-    return plan;
-  }
-
-  if (signal.kind === 'turn:end' || signal.kind === 'event') {
-    const sessionMap = buckets.get(signal.sessionId);
-
-    if (sessionMap) {
-      const ownerKey = (signal.kind === 'event' ? signal.event.childId : signal.childId) ?? PARENT_OWNER;
-      const bucket = sessionMap.get(ownerKey);
-
-      if (bucket) {
-        pushFullDrain(plan, signal.sessionId, ownerKey, bucket);
-      }
-    }
-  }
-
-  return plan;
-}
-
-export function planFullDrain<K extends string>(buckets: BucketMap<K>): DrainPlan<K>[] {
-  const plan: DrainPlan<K>[] = [];
-
-  for (const [sessionId, sessionMap] of buckets) {
-    for (const [ownerKey, bucket] of sessionMap) {
-      pushFullDrain(plan, sessionId, ownerKey, bucket);
-    }
-  }
-
-  return plan;
-}
-
-function pushFullDrain<K extends string>(
-  plan: DrainPlan<K>[],
-  sessionId: K,
-  ownerKey: string,
-  bucket: OwnerBucket,
-): void {
-  if (bucket.pending.length === 0) {
-    return;
-  }
-
-  const text = bucket.pending;
-  bucket.pending = '';
-  bucket.carry = 0;
-
-  plan.push({
-    sessionId,
-    ownerKey,
-    text,
-    childId: bucket.childId,
-    depth: bucket.depth,
-    turnId: bucket.turnId,
-  });
-}

package/src/chat/headless/streams/prompt-previews.ts

@@ -1,64 +0,0 @@
-/**
- * Image and PDF previews for prompts whose bytes never come back from the host.
- *
- * A queued message is sent host-side when the run ends (or on push). The
- * host's `user-prompt` broadcast carries attachment METADATA only (name,
- * media type, size), so the window that queued it rendered a broken
- * thumbnail (or a PDF chip that could not open), and a pushed entry's
- * optimistic copy carried none at all. The window that queued the message
- * still holds the data URLs it built; this matches them back onto whichever
- * copy of the prompt reaches the transcript. Windows that never had the
- * bytes keep a metadata chip until the transcript re-converges from disk,
- * where the rehydrator restores them.
- */
-import type { ChatAttachment } from '../host';
-
-/** An attachment the transcript previews from its bytes: an image or a PDF. */
-const previewed = (att: ChatAttachment): boolean =>
-  att.mediaType.startsWith('image/') || att.mediaType.toLowerCase() === 'application/pdf';
-
-/**
- * Fill `dataUrl` on image and PDF attachments that lack one, from `previews`:
- * same media type and name first, then the next unused preview of that media
- * type. With no incoming metadata at all (a local append that knew nothing
- * of the attachments) the previews are the attachments.
- *
- * @param attachments - The attachments the prompt arrived with, metadata only for a host-sent copy.
- * @param previews - The attachments this client kept when it queued the prompt, with their bytes.
- */
-export function mergePromptPreviews(
-  attachments: readonly ChatAttachment[] | undefined,
-  previews: readonly ChatAttachment[],
-): ChatAttachment[] | undefined {
-  if (previews.length === 0) return attachments ? [...attachments] : undefined;
-  if (!attachments || attachments.length === 0) return [...previews];
-
-  const used = new Set<number>();
-  const claim = (match: (p: ChatAttachment) => boolean): ChatAttachment | undefined => {
-    const index = previews.findIndex((p, i) => !used.has(i) && p.dataUrl !== undefined && match(p));
-    if (index === -1) return undefined;
-    used.add(index);
-    return previews[index];
-  };
-
-  const needs = (att: ChatAttachment): boolean => att.dataUrl === undefined && previewed(att);
-  // Two passes: exact names claim their previews first, so an unnamed match
-  // earlier in the list can't take a preview that belongs to a later name.
-  const byName = attachments.map((att) =>
-    needs(att) ? claim((p) => p.mediaType === att.mediaType && p.name === att.name) : undefined,
-  );
-  return attachments.map((att, i) => {
-    if (!needs(att)) return att;
-    const preview = byName[i] ?? claim((p) => p.mediaType === att.mediaType);
-    return preview ? { ...att, dataUrl: preview.dataUrl } : att;
-  });
-}
-
-/**
- * True when some image or PDF attachment has no bytes to show.
- *
- * @param attachments - The prompt's attachments.
- */
-export function missingPreviewData(attachments: readonly ChatAttachment[] | undefined): boolean {
-  return attachments?.some((a) => previewed(a) && a.dataUrl === undefined) ?? false;
-}