zidane-ui 9.1.1 → 9.1.4

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;
-}

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

@@ -1,36 +0,0 @@
-/**
- * The clock the session stream store paces with. The store never touches
- * `requestAnimationFrame` or timers itself: it asks a scheduler, so a test
- * drives frames by hand and a non-browser host (a worker, a server) runs on
- * timers alone.
- */
-
-/** Frames and timers for the session stream store (see {@link defaultFrameScheduler}). */
-export interface FrameScheduler {
-  /** The current time in milliseconds, on the clock frame callbacks receive (`performance.now()` in a browser). */
-  now(): number;
-  /** Runs `callback` before the next paint, with the frame's time. Returns a handle, or `null` where there are no frames (the store falls back to {@link FrameScheduler.timeout}). */
-  frame(callback: (now: number) => void): unknown;
-  /** Cancels a pending {@link FrameScheduler.frame} by its handle. */
-  cancelFrame(handle: unknown): void;
-  /** Runs `callback` after `ms` milliseconds. Returns a handle. */
-  timeout(callback: () => void, ms: number): unknown;
-  /** Cancels a pending {@link FrameScheduler.timeout} by its handle. */
-  cancelTimeout(handle: unknown): void;
-}
-
-/**
- * The browser's frames and timers, looked up on every call (so a test that
- * stubs `requestAnimationFrame` or fakes timers after the store exists is
- * still heard). Without `requestAnimationFrame` (a worker, Node) `frame`
- * returns `null` and the store paces on timers.
- */
-export const defaultFrameScheduler: FrameScheduler = {
-  now: () => performance.now(),
-  frame: (callback) => (typeof requestAnimationFrame === 'function' ? requestAnimationFrame(callback) : null),
-  cancelFrame: (handle) => {
-    if (typeof cancelAnimationFrame === 'function') cancelAnimationFrame(handle as number);
-  },
-  timeout: (callback, ms) => setTimeout(callback, ms),
-  cancelTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
-};

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

@@ -1,76 +0,0 @@
-/**
- * Reads of one session's slice of the store, as the per-session subscriptions
- * take them: each returns the store's own snapshot, so an unchanged slice
- * keeps its identity. Plus the selection the Files and Diffs tabs read (a
- * session's file edits) and the rule that keeps a selection's identity while
- * its items are the same.
- */
-import type { SystemMdFile } from 'zidane/chat';
-
-import type { ChatEvent } from '../host';
-import type { SessionStreamStore } from './store';
-import type { SessionFallbackModel, SessionPageState, SessionRetryState } from './types';
-
-/** One session's read of the store. Module-level reads keep the subscription stable. */
-export type SessionStreamRead<T, K extends string = string> = (store: SessionStreamStore<K>, sessionId: K | null) => T;
-
-/** The session's events. */
-export function readSessionEvents<K extends string>(store: SessionStreamStore<K>, id: K | null): readonly ChatEvent[] {
-  return store.getEventsSnapshot(id);
-}
-/** The session's scrollback state. */
-export function readSessionPage<K extends string>(store: SessionStreamStore<K>, id: K | null): SessionPageState {
-  return store.getPageSnapshot(id);
-}
-/** Whether a run is in flight. */
-export function readSessionRunning<K extends string>(store: SessionStreamStore<K>, id: K | null): boolean {
-  return store.getRunningSnapshot(id);
-}
-/** The fallback model the run switched to, `null` when none. */
-export function readSessionFallback<K extends string>(
-  store: SessionStreamStore<K>,
-  id: K | null,
-): SessionFallbackModel | null {
-  return store.getFallbackSnapshot(id);
-}
-/** The provider retry in progress, `null` when none. */
-export function readSessionRetry<K extends string>(
-  store: SessionStreamStore<K>,
-  id: K | null,
-): SessionRetryState | null {
-  return store.getRetrySnapshot(id);
-}
-/** The session's `SYSTEM.md` override, `null` when none. */
-export function readSessionSystemMd<K extends string>(store: SessionStreamStore<K>, id: K | null): SystemMdFile | null {
-  return store.getSystemMdSnapshot(id);
-}
-
-/**
- * The events that carry a file edit, in order.
- *
- * @param events - A session's events.
- */
-export function selectEditEvents<E extends ChatEvent>(events: readonly E[]): E[] {
-  const out: E[] = [];
-  for (const event of events) if (event.kind === 'tool' && event.edit) out.push(event);
-  return out;
-}
-
-/**
- * A selection that keeps returning the previous list while the new one holds
- * the same items in the same order, so a reader re-renders only when an item
- * changes.
- *
- * @param select - Picks the items from the events.
- */
-export function stableSelection<E, T>(
-  select: (events: readonly E[]) => readonly T[],
-): (events: readonly E[]) => readonly T[] {
-  let last: readonly T[] = [];
-  return (events) => {
-    const next = select(events);
-    if (next.length === last.length && next.every((item, i) => item === last[i])) return last;
-    last = next;
-    return next;
-  };
-}