zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/sidebar/view.ts

@@ -1,367 +0,0 @@
-/**
- * The sidebar's view: the five filter axes (archive, project, activity,
- * group by, sort by) kept per space, the conversation last open in each
- * space, and the space the sidebar shows.
- *
- * Storage-first: a view reads from the app's Storage synchronously at
- * creation, so the first frame already has it. When the host keeps a copy
- * too (`ChatHost.sessions.views`, the desktop app's database), it is read
- * once and wins for every space this run has not changed yet; a space only
- * this device knows is written back to it.
- */
-import { DEFAULT_SPACE_ID } from 'zidane/chat/pure';
-
-import { writable, type Readable } from '../store';
-import type {
-  SessionActivityFilter,
-  SessionArchiveFilter,
-  SidebarExtensionView,
-  SidebarGroupBy,
-  SidebarSortBy,
-  SidebarView,
-} from './types';
-
-/** A view nobody changed yet. */
-export const DEFAULT_SIDEBAR_VIEW: SidebarView = {
-  archive: 'active',
-  project: null,
-  activity: 'all',
-  groupBy: 'project',
-  sortBy: 'recency',
-};
-
-/** Where the views persist: one map of space id → view. */
-export const SIDEBAR_VIEW_KEY = 'zg-sidebar-view:v1';
-/** Where the shown space persists. */
-export const SIDEBAR_SPACE_KEY = 'zg-sidebar-space';
-
-/** A space's record as stored: its view, plus the conversation last open in it (`session`, when one was). */
-export type SidebarViewRecord = SidebarView & { session?: string };
-
-/** The views the host keeps for this user, next to the device's Storage. */
-export interface SidebarViewsHost {
-  /** Every saved view, keyed by space id (anything malformed is dropped). */
-  getViews(): Promise<unknown>;
-  /** Saves a space's record (its view and last open conversation). */
-  setView(spaceId: string, view: SidebarViewRecord): Promise<unknown>;
-  /** The space last shown, if any. */
-  getSpace(): Promise<unknown>;
-  /** Saves the space shown. */
-  setSpace(spaceId: string): Promise<unknown>;
-}
-
-const oneOf =
-  <T extends string>(members: readonly T[]) =>
-  (raw: string): T | undefined =>
-    members.includes(raw as T) ? (raw as T) : undefined;
-
-const parseArchive = oneOf<SessionArchiveFilter>(['active', 'archived', 'all']);
-const parseActivity = oneOf<SessionActivityFilter>(['all', '1d', '3d', '7d', '30d']);
-const parseGroupBy = oneOf<SidebarGroupBy>(['none', 'date', 'state', 'project', 'host', 'agent']);
-const parseSortBy = oneOf<SidebarSortBy>(['recency', 'createdTime', 'alphabetical']);
-
-function parseExtensionView(raw: unknown): SidebarExtensionView | undefined {
-  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
-  const o = raw as Record<string, unknown>;
-  const filters: Record<string, boolean | string | readonly string[]> = {};
-  if (o.filters && typeof o.filters === 'object' && !Array.isArray(o.filters)) {
-    for (const [id, value] of Object.entries(o.filters as Record<string, unknown>)) {
-      if (value === true || (typeof value === 'string' && value.length > 0)) filters[id] = value;
-      else if (Array.isArray(value)) {
-        const ids = value.filter((v): v is string => typeof v === 'string' && v.length > 0);
-        if (ids.length > 0) filters[id] = ids;
-      }
-    }
-  }
-  const sort = typeof o.sort === 'string' && o.sort.length > 0 ? o.sort : undefined;
-  const group = typeof o.group === 'string' && o.group.length > 0 ? o.group : undefined;
-  if (Object.keys(filters).length === 0 && !sort && !group) return undefined;
-  return { filters, ...(sort ? { sort } : {}), ...(group ? { group } : {}) };
-}
-
-/**
- * A stored view, every axis checked; what is missing or unknown takes the default.
- *
- * @param raw - The stored value.
- */
-export function parseSidebarView(raw: unknown): SidebarView {
-  const o = raw && typeof raw === 'object' ? (raw as Record<string, unknown>) : {};
-  const str = (v: unknown) => (typeof v === 'string' ? v : '');
-  const d = DEFAULT_SIDEBAR_VIEW;
-  const agent = typeof o.agent === 'string' && o.agent.length > 0 ? o.agent : null;
-  const extension = parseExtensionView(o.extension);
-  return {
-    archive: parseArchive(str(o.archive)) ?? d.archive,
-    project: typeof o.project === 'string' && o.project.length > 0 ? o.project : null,
-    activity: parseActivity(str(o.activity)) ?? d.activity,
-    groupBy: parseGroupBy(str(o.groupBy)) ?? d.groupBy,
-    sortBy: parseSortBy(str(o.sortBy)) ?? d.sortBy,
-    ...(agent ? { agent } : {}),
-    ...(extension ? { extension } : {}),
-  };
-}
-
-/** Where the switcher's own order and hidden spaces persist. */
-export const SIDEBAR_SWITCHER_KEY = 'zg:sidebar-switcher:v1';
-
-/**
- * The user's arrangement of the space switcher, over the spaces' own order: extension spaces
- * included, which Settings › Spaces doesn't list.
- */
-export interface SpaceSwitcherPrefs {
-  /** Space ids in the order the user put them; a space not named keeps its place after them. */
-  order: readonly string[];
-  /** Space ids the switcher leaves out (their sessions stay where they are). */
-  hidden: readonly string[];
-}
-
-/** No arrangement yet: the spaces' own order, nothing hidden. */
-export const DEFAULT_SWITCHER_PREFS: SpaceSwitcherPrefs = { order: [], hidden: [] };
-
-/**
- * Stored switcher prefs, checked; anything malformed reads as none.
- *
- * @param raw - The stored value.
- */
-export function parseSwitcherPrefs(raw: unknown): SpaceSwitcherPrefs {
-  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return DEFAULT_SWITCHER_PREFS;
-  const o = raw as Record<string, unknown>;
-  const ids = (v: unknown) =>
-    Array.isArray(v) ? [...new Set(v.filter((x): x is string => typeof x === 'string' && x.length > 0))] : [];
-  return { order: ids(o.order), hidden: ids(o.hidden) };
-}
-
-/** Views per space id. */
-export type SidebarViewMap = Record<string, SidebarView>;
-
-function viewsFrom(stored: unknown): SidebarViewMap | undefined {
-  if (!stored || typeof stored !== 'object' || Array.isArray(stored)) return undefined;
-  return Object.fromEntries(Object.entries(stored).map(([id, view]) => [id, parseSidebarView(view)]));
-}
-
-/** The conversation last open per space id. */
-export type SidebarLastSessions = Record<string, string>;
-
-function sessionsFrom(stored: unknown): SidebarLastSessions {
-  if (!stored || typeof stored !== 'object' || Array.isArray(stored)) return {};
-  return Object.fromEntries(
-    Object.entries(stored).flatMap(([id, record]) => {
-      const session = record && typeof record === 'object' ? (record as Record<string, unknown>).session : undefined;
-      return typeof session === 'string' && session.length > 0 ? [[id, session]] : [];
-    }),
-  );
-}
-
-function parseJson(raw: string | undefined): unknown {
-  if (raw === undefined) return undefined;
-  try {
-    return JSON.parse(raw) as unknown;
-  } catch {
-    return undefined;
-  }
-}
-
-/** One key per axis, from before the views were kept per space: read once into the default space, then removed. */
-const LEGACY_KEYS = {
-  archive: 'zg-sidebar-archive-filter',
-  project: 'zg-sidebar-project-filter',
-  activity: 'zg-sidebar-activity-filter',
-  groupBy: 'zg-sidebar-group-by',
-  sortBy: 'zg-sidebar-sort-by',
-} as const satisfies Record<Exclude<keyof SidebarView, 'agent' | 'extension'>, string>;
-
-/** The Storage the views persist in (`localStorage` in a browser). */
-export type SidebarViewsStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
-
-function read(storage: SidebarViewsStorage | undefined, key: string): string | undefined {
-  try {
-    return storage?.getItem(key) ?? undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function write(storage: SidebarViewsStorage | undefined, key: string, value: string | null): void {
-  try {
-    if (value === null) storage?.removeItem(key);
-    else storage?.setItem(key, value);
-  } catch {
-    // Storage full or blocked: the view still holds for this run.
-  }
-}
-
-/**
- * The views the Storage holds: the per-space map, else the legacy per-axis keys as the default space's view.
- *
- * @param storage - Where the views persist; absent reads nothing.
- */
-export function readSidebarViews(storage: SidebarViewsStorage | undefined): SidebarViewMap {
-  const stored = viewsFrom(parseJson(read(storage, SIDEBAR_VIEW_KEY)));
-  if (stored) return stored;
-  const legacy = Object.fromEntries(Object.entries(LEGACY_KEYS).map(([field, key]) => [field, read(storage, key)]));
-  return Object.values(legacy).some((v) => v !== undefined) ? { [DEFAULT_SPACE_ID]: parseSidebarView(legacy) } : {};
-}
-
-/** The sidebar's views and shown space, outside React. */
-export interface SidebarViews {
-  /** Every space's view. */
-  views: Readable<SidebarViewMap>;
-  /** The space the sidebar shows. */
-  space: Readable<string>;
-  /** The space's view (the default when it has none). */
-  viewOf(spaceId: string): SidebarView;
-  /** Change some axes of a space's view; persisted at once. */
-  patch(spaceId: string, patch: Partial<SidebarView>): void;
-  /** Show another space; persisted at once. */
-  setSpace(spaceId: string): void;
-  /** The conversation last open in a space, if one was. */
-  lastSessionOf(spaceId: string): string | null;
-  /** Remember the conversation open in a space; persisted at once (no-op when unchanged). */
-  rememberSession(spaceId: string, sessionId: string): void;
-  /** Forget a conversation in every space that remembers it (deleted, moved away). */
-  forgetSession(sessionId: string, exceptSpaceId?: string): void;
-  /** Read the host's copies once (no-op without a host). Call after creation. */
-  sync(): void;
-  /** The switcher's order and hidden spaces, on this device. */
-  switcher: Readable<SpaceSwitcherPrefs>;
-  /** Replaces the switcher's prefs; persisted at once. */
-  setSwitcher(prefs: SpaceSwitcherPrefs): void;
-}
-
-/** Options of {@link createSidebarViews}. */
-export interface SidebarViewsOptions {
-  /** Where the views persist on this device. */
-  storage?: SidebarViewsStorage;
-  /** The host's copy (`ChatHost.sessions.views`). */
-  host?: SidebarViewsHost;
-  /** The space shown when none was saved. */
-  fallbackSpace?: string;
-  /** A host read or write failed. */
-  onError?: (what: 'views' | 'view' | 'space', error: unknown) => void;
-}
-
-/**
- * The views store: Storage first, the host's copy merged in once ({@link SidebarViews.sync}).
- *
- * @param options - Storage, host and fallback space.
- */
-export function createSidebarViews(options: SidebarViewsOptions = {}): SidebarViews {
-  const { storage, host, onError } = options;
-  const views = writable<SidebarViewMap>(readSidebarViews(storage));
-  let lastSessions: SidebarLastSessions = sessionsFrom(parseJson(read(storage, SIDEBAR_VIEW_KEY)));
-  const savedSpace = read(storage, SIDEBAR_SPACE_KEY);
-  const space = writable<string>(savedSpace || (options.fallbackSpace ?? DEFAULT_SPACE_ID));
-  /** Spaces whose view changed this run: the host's older copy never overwrites them. */
-  const changed = new Set<string>();
-  /** Spaces whose last open conversation changed this run, likewise. */
-  const reopened = new Set<string>();
-  let switched = false;
-  let synced = false;
-  const switcher = writable<SpaceSwitcherPrefs>(parseSwitcherPrefs(parseJson(read(storage, SIDEBAR_SWITCHER_KEY))));
-
-  const recordOf = (spaceId: string, view = views.get()[spaceId] ?? DEFAULT_SIDEBAR_VIEW): SidebarViewRecord => {
-    const session = lastSessions[spaceId];
-    return session ? { ...view, session } : view;
-  };
-  const persistViews = (next: SidebarViewMap) => {
-    const ids = new Set([...Object.keys(next), ...Object.keys(lastSessions)]);
-    const records = Object.fromEntries([...ids].map((id) => [id, recordOf(id, next[id] ?? DEFAULT_SIDEBAR_VIEW)]));
-    write(storage, SIDEBAR_VIEW_KEY, JSON.stringify(records));
-    for (const key of Object.values(LEGACY_KEYS)) write(storage, key, null);
-  };
-  const saveView = (spaceId: string, view?: SidebarView) => {
-    host?.setView(spaceId, recordOf(spaceId, view)).catch((err: unknown) => onError?.('view', err));
-  };
-  const setLastSession = (spaceId: string, sessionId: string | null) => {
-    const next = { ...lastSessions };
-    if (sessionId) next[spaceId] = sessionId;
-    else delete next[spaceId];
-    lastSessions = next;
-    reopened.add(spaceId);
-  };
-  const saveSpace = (spaceId: string) => {
-    host?.setSpace(spaceId).catch((err: unknown) => onError?.('space', err));
-  };
-
-  return {
-    views,
-    space,
-    viewOf: (spaceId) => views.get()[spaceId] ?? DEFAULT_SIDEBAR_VIEW,
-    patch(spaceId, patch) {
-      const view = { ...(views.get()[spaceId] ?? DEFAULT_SIDEBAR_VIEW), ...patch };
-      changed.add(spaceId);
-      const next = { ...views.get(), [spaceId]: view };
-      views.set(next);
-      persistViews(next);
-      saveView(spaceId, view);
-    },
-    setSpace(spaceId) {
-      switched = true;
-      space.set(spaceId);
-      write(storage, SIDEBAR_SPACE_KEY, spaceId);
-      saveSpace(spaceId);
-    },
-    switcher,
-    setSwitcher(prefs) {
-      const next = parseSwitcherPrefs(prefs);
-      switcher.set(next);
-      write(storage, SIDEBAR_SWITCHER_KEY, JSON.stringify(next));
-    },
-    lastSessionOf: (spaceId) => lastSessions[spaceId] ?? null,
-    rememberSession(spaceId, sessionId) {
-      if (lastSessions[spaceId] === sessionId) return;
-      setLastSession(spaceId, sessionId);
-      persistViews(views.get());
-      saveView(spaceId);
-    },
-    forgetSession(sessionId, exceptSpaceId) {
-      const spaces = Object.keys(lastSessions).filter((id) => id !== exceptSpaceId && lastSessions[id] === sessionId);
-      if (spaces.length === 0) return;
-      for (const id of spaces) setLastSession(id, null);
-      persistViews(views.get());
-      for (const id of spaces) saveView(id);
-    },
-    sync() {
-      if (!host || synced) return;
-      synced = true;
-      host
-        .getViews()
-        .then((stored) => {
-          const saved = viewsFrom(stored) ?? {};
-          const local = views.get();
-          // A space the host keeps takes its record whole (a missing \`session\` included), like its view.
-          const own = lastSessions;
-          const hostSessions = sessionsFrom(stored);
-          const merged: SidebarLastSessions = { ...own, ...hostSessions };
-          for (const id of Object.keys(saved)) if (!(id in hostSessions)) delete merged[id];
-          for (const id of reopened) {
-            if (own[id]) merged[id] = own[id];
-            else delete merged[id];
-          }
-          lastSessions = merged;
-          const next: SidebarViewMap = { ...local, ...saved };
-          for (const id of changed) {
-            const own = local[id];
-            if (own) next[id] = own;
-          }
-          for (const [id, view] of Object.entries(local)) if (!(id in saved)) saveView(id, view);
-          views.set(next);
-          persistViews(next);
-        })
-        .catch((err: unknown) => onError?.('views', err));
-      host
-        .getSpace()
-        .then((saved) => {
-          if (switched) return;
-          if (typeof saved === 'string' && saved.length > 0) {
-            space.set(saved);
-            write(storage, SIDEBAR_SPACE_KEY, saved);
-            return;
-          }
-          const own = read(storage, SIDEBAR_SPACE_KEY);
-          if (own) saveSpace(own);
-        })
-        .catch((err: unknown) => onError?.('space', err));
-    },
-  };
-}

package/src/chat/headless/site-icons.ts

@@ -1,51 +0,0 @@
-/**
- * Site icons for link badges, one request per origin for the whole page
- * (`ChatHost.siteIcons`). An app builds one over its fetcher and shares it,
- * so every badge of a site shares the answer, and badges drawn outside React
- * (an editor's decorations) hear when one lands.
- */
-import type { ChatSiteIcons } from './transcript-host';
-
-/**
- * The `http(s)` origin a link's icon belongs to, or `null` when it has none.
- *
- * @param url - The link's address.
- */
-export function siteOrigin(url: string): string | null {
-  try {
-    const { protocol, origin, hostname } = new URL(url);
-    return (protocol === 'http:' || protocol === 'https:') && hostname ? origin : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Creates the site icon cache over a fetcher.
- *
- * @param fetch - Loads an origin's icon as a data URL; `null` when it has none.
- */
-export function createSiteIcons(fetch: (origin: string) => Promise<string | null>): ChatSiteIcons {
-  const icons = new Map<string, string | null>();
-  const inflight = new Set<string>();
-  const listeners = new Set<() => void>();
-  return {
-    get: (origin) => icons.get(origin) ?? null,
-    request(origin) {
-      if (icons.has(origin) || inflight.has(origin)) return;
-      inflight.add(origin);
-      void Promise.resolve()
-        .then(() => fetch(origin))
-        .catch(() => null)
-        .then((icon) => {
-          inflight.delete(origin);
-          icons.set(origin, icon);
-          if (icon) listeners.forEach((listener) => listener());
-        });
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-  };
-}

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