zidane-ui 9.0.4 → 9.1.3

package/src/session/headless/queue-attachments.ts

@@ -1,73 +0,0 @@
-/**
- * A queued message's attachments while its text is edited: staged with an id
- * and a data URL (the shape the composer stages), converted to and from the
- * wire shape (`PromptAttachment`, base64 without the data-URL prefix).
- */
-import type { PromptAttachment } from 'zidane/chat';
-
-/** An attachment staged in the queue editor. */
-export interface StagedAttachment {
-  /** A local id, stable while staged. */
-  id: string;
-  /** The file name (`''` when it had none). */
-  name: string;
-  /** The media type. */
-  mediaType: string;
-  /** Bytes. */
-  size: number;
-  /** A `data:` URL with the bytes. */
-  dataUrl: string;
-}
-
-const DATA_URL_RE = /^data:([^;]+);base64,(.+)$/;
-
-/**
- * Staged attachments → wire attachments. An entry whose data URL can't be parsed is dropped.
- *
- * @param attachments - The staged attachments.
- */
-export function stagedToWire(
-  attachments: readonly Pick<StagedAttachment, 'name' | 'mediaType' | 'dataUrl'>[],
-): PromptAttachment[] {
-  const out: PromptAttachment[] = [];
-  for (const att of attachments) {
-    const match = DATA_URL_RE.exec(att.dataUrl);
-    if (!match) continue;
-    out.push({ mediaType: match[1] ?? att.mediaType, data: match[2] ?? '', name: att.name });
-  }
-  return out;
-}
-
-/**
- * Wire attachments → staged ones. `size` comes from the base64 length; `name` falls back to `''` so the round trip
- * keeps {@link attachmentsKey} stable.
- *
- * @param attachments - The wire attachments.
- */
-export function wireToStaged(attachments: readonly PromptAttachment[]): StagedAttachment[] {
-  return attachments.map((att, index) => ({
-    id: `sync-${index}-${att.data.length}-${att.name ?? ''}`,
-    name: att.name ?? '',
-    mediaType: att.mediaType,
-    size: Math.floor((att.data.length * 3) / 4),
-    dataUrl: `data:${att.mediaType};base64,${att.data}`,
-  }));
-}
-
-/**
- * An equality key for a wire attachment list: type, name, length and both ends of the data (the whole payload would
- * cost tens of ms per change for multi-MB images).
- *
- * @param attachments - The wire attachments.
- */
-export function attachmentsKey(attachments: readonly PromptAttachment[]): string {
-  return JSON.stringify(
-    attachments.map((att) => [
-      att.mediaType,
-      att.name ?? '',
-      att.data.length,
-      att.data.slice(0, 64),
-      att.data.slice(-64),
-    ]),
-  );
-}

package/src/session/headless/queue.ts

@@ -1,122 +0,0 @@
-/**
- * A view of the backend's per-session type-ahead queue, never a queue of its
- * own. The backend owns the entries, delivers them in order when a run ends,
- * steers a pushed entry into the live run and keeps the attachments and
- * skills that rode with the text. This state mirrors its `queue:changed`
- * broadcasts, drops and edits optimistically (the broadcast converges), and
- * forwards intent. Hosts build their `SessionQueue` on it.
- */
-import type { QueuedItem } from 'zidane/chat';
-
-import type { Readable } from '../../chat/headless/store';
-import type { PromptAttachment, QueuedAttachment, QueuedMessage } from './host';
-import { createKeyedState } from './keyed';
-
-/** The backend calls the queue state makes. */
-export interface QueueBackend {
-  /** The session's entries. */
-  list(sessionId: string): Promise<readonly QueuedItem[]>;
-  /** Drops an entry. */
-  remove(sessionId: string, id: string): Promise<unknown>;
-  /** Replaces an entry's text (and attachments when given). */
-  update(sessionId: string, id: string, text: string, attachments?: PromptAttachment[]): Promise<unknown>;
-}
-
-/** The queues of every session a host has seen. */
-export interface QueueState {
-  /** The session's entries store (empty when none). */
-  items(sessionId: string): Readable<readonly QueuedMessage[]>;
-  /** Reads the session from the backend and remembers it as the active one. Best effort. */
-  refresh(sessionId: string): void;
-  /** The entries the backend broadcast for a session. */
-  replace(sessionId: string, items: readonly QueuedItem[]): void;
-  /** Drops an entry at once and tells the backend. */
-  drop(sessionId: string, id: string): void;
-  /** Edits an entry at once and tells the backend; resolves when it answered (never rejects). */
-  edit(sessionId: string, id: string, text: string, attachments?: PromptAttachment[]): Promise<void>;
-  /** Forgets every queue (the backend changed: a reconnect), then re-reads the active session when `reread`. */
-  reset(reread: boolean): void;
-}
-
-const EMPTY: readonly QueuedMessage[] = [];
-
-/**
- * The queue rows of a session's entries.
- *
- * @param sessionId - The session the entries belong to.
- * @param items - The backend's entries.
- */
-export function toQueuedMessages(sessionId: string, items: readonly QueuedItem[]): QueuedMessage[] {
-  return items.map((item) => ({
-    id: item.id,
-    text: item.text,
-    sessionId,
-    ...(item.attachments?.length ? { attachments: item.attachments } : {}),
-  }));
-}
-
-function toSummaries(attachments: readonly PromptAttachment[]): QueuedAttachment[] {
-  return attachments.map((a) => ({ mediaType: a.mediaType, ...(a.name ? { name: a.name } : {}) }));
-}
-
-/**
- * Creates a {@link QueueState}.
- *
- * @param backend - The backend's queue calls.
- */
-export function createQueueState(backend: QueueBackend): QueueState {
-  const state = createKeyedState<readonly QueuedMessage[], readonly QueuedMessage[]>(EMPTY);
-  // The last session read (the active one), re-read after a reconnect.
-  let last: string | null = null;
-  // Bumped per session on every write: a list reply that started before one is stale and dropped.
-  const writes = new Map<string, number>();
-  const set = (sessionId: string, next: readonly QueuedMessage[]) => {
-    writes.set(sessionId, (writes.get(sessionId) ?? 0) + 1);
-    state.set(sessionId, next);
-  };
-  const refresh = (sessionId: string) => {
-    last = sessionId;
-    const at = writes.get(sessionId) ?? 0;
-    void backend
-      .list(sessionId)
-      .then((items) => {
-        if ((writes.get(sessionId) ?? 0) === at) set(sessionId, toQueuedMessages(sessionId, items));
-      })
-      .catch(() => undefined);
-  };
-  return {
-    items: (sessionId) => state.readable(sessionId),
-    refresh,
-    replace: (sessionId, items) => set(sessionId, toQueuedMessages(sessionId, items)),
-    drop(sessionId, id) {
-      const current = state.get(sessionId);
-      if (current)
-        set(
-          sessionId,
-          current.filter((m) => m.id !== id),
-        );
-      void backend.remove(sessionId, id).catch(() => undefined);
-    },
-    async edit(sessionId, id, text, attachments) {
-      const current = state.get(sessionId);
-      const idx = current?.findIndex((m) => m.id === id) ?? -1;
-      if (current && idx !== -1) {
-        const next = [...current];
-        const entry = next[idx]!;
-        const summary = attachments ? toSummaries(attachments) : entry.attachments;
-        next[idx] = {
-          id: entry.id,
-          sessionId: entry.sessionId,
-          text,
-          ...(summary?.length ? { attachments: summary } : {}),
-        };
-        set(sessionId, next);
-      }
-      await backend.update(sessionId, id, text, attachments).catch(() => undefined);
-    },
-    reset(reread) {
-      state.clear();
-      if (reread && last) refresh(last);
-    },
-  };
-}

package/src/session/headless/running-work.ts

@@ -1,85 +0,0 @@
-/**
- * Each session's running work: its cancellable tool calls and background
- * tasks. Seeded per session by a read the first time something asks, kept
- * live by the backend's snapshots (one on every tool lifecycle edge). A
- * session's list keeps its identity until its own work changes, and a read
- * that started before the latest snapshot is stale and dropped.
- */
-import type { RunningWorkItem } from 'zidane/ipc';
-
-import type { Readable } from '../../chat/headless/store';
-import { createKeyedState } from './keyed';
-
-export type { RunningWorkItem };
-
-const NO_WORK: readonly RunningWorkItem[] = [];
-
-/**
- * Same items, in the same order and states: the list on screen stays.
- *
- * @param a - One list.
- * @param b - The other.
- */
-export function sameRunningWork(a: readonly RunningWorkItem[], b: readonly RunningWorkItem[]): boolean {
-  return (
-    a.length === b.length &&
-    a.every((item, i) => {
-      const other = b[i]!;
-      return (
-        other.id === item.id &&
-        other.kind === item.kind &&
-        other.label === item.label &&
-        other.startedAt === item.startedAt
-      );
-    })
-  );
-}
-
-/** The running work of every session a host has seen. */
-export interface RunningWorkState {
-  /** The session's work (empty for none). One store per session id. */
-  items(sessionId: string): Readable<readonly RunningWorkItem[]>;
-  /** Reads the session now and records it, unless a snapshot landed meanwhile. Rejects when the read fails. */
-  refresh(sessionId: string): Promise<void>;
-  /** Reads the session once, the first time it is asked for. Never rejects (the snapshots fill it in). */
-  ensure(sessionId: string): void;
-  /** The backend's snapshot of the session's work. */
-  push(sessionId: string, items: readonly RunningWorkItem[]): void;
-}
-
-/**
- * Creates a {@link RunningWorkState}.
- *
- * @param list - Reads one session's work from the backend.
- */
-export function createRunningWorkState(
-  list: (sessionId: string) => Promise<readonly RunningWorkItem[]>,
-): RunningWorkState {
-  const state = createKeyedState<readonly RunningWorkItem[], readonly RunningWorkItem[]>(NO_WORK);
-  const seeded = new Set<string>();
-  /** Snapshots seen per session: a read that started before the latest one is stale. */
-  const versions = new Map<string, number>();
-  const record = (sessionId: string, items: readonly RunningWorkItem[]) => {
-    const prev = state.get(sessionId);
-    if (prev && sameRunningWork(prev, items)) return;
-    state.set(sessionId, items.length === 0 ? NO_WORK : items);
-  };
-  const refresh = async (sessionId: string) => {
-    seeded.add(sessionId);
-    const version = versions.get(sessionId) ?? 0;
-    const items = await list(sessionId);
-    if ((versions.get(sessionId) ?? 0) === version) record(sessionId, items);
-  };
-  return {
-    items: (sessionId) => state.readable(sessionId),
-    refresh,
-    ensure(sessionId) {
-      if (seeded.has(sessionId)) return;
-      void refresh(sessionId).catch(() => undefined);
-    },
-    push(sessionId, items) {
-      versions.set(sessionId, (versions.get(sessionId) ?? 0) + 1);
-      record(sessionId, items);
-    },
-  };
-}

package/src/session/headless/session-actions.ts

@@ -1,198 +0,0 @@
-/**
- * The session actions an app binds to keys, menus and the palette: generate a
- * title, compact, export (Markdown, JSON), delete (asked first), favorite,
- * copy the id, fork from a turn. They run over the session host
- * (`SessionHost.details`, `SessionHost.turns`) and the session list
- * (`ChatHost.sessions` or the app's own directory), so every app gets the
- * same behaviour. An action whose capability is left out is absent, and so
- * is its key command (`sessionKeyCommands`).
- *
- * Actions never reject, except `fork` (its caller words the failure): a
- * failure goes to `onError` and the action resolves. A key press needs no
- * dialog for it.
- */
-import type { SessionEnvironmentSummary } from 'zidane/chat';
-
-import { deleteSessionPrompt } from '../../chat/headless/sidebar/environment';
-import { DEFAULT_SIDEBAR_LABELS, type SidebarLabels } from '../../chat/headless/sidebar/labels';
-import type { KeyCommands } from '../../keybindings/headless/commands';
-import type { SessionHost } from './host';
-
-/** The session an action runs on: what the actions read off its row. */
-export interface SessionActionTarget {
-  /** The session's id (the app's key). */
-  id: string;
-  /** Its title, for the delete confirmation. Absent: the id. */
-  title?: string | null;
-  /** Where it runs, for the delete confirmation (a remote sandbox goes with it). */
-  environment?: SessionEnvironmentSummary;
-  /** Whether it is a favorite (what `toggleFavorite` flips). */
-  favorite?: boolean;
-  /** The pinned main session: never a favorite. */
-  isMain?: boolean;
-}
-
-/** What `confirm` is asked before a delete. */
-export interface SessionConfirmOptions {
-  /** The question. */
-  title: string;
-  /** What else goes with it. */
-  message?: string;
-  /** The confirm button's text. */
-  confirmLabel: string;
-  /** Always `true`: a delete is undo-less. */
-  destructive: true;
-}
-
-/** The names `onError` reports. */
-export type SessionActionName =
-  'generateTitle' | 'compact' | 'exportMarkdown' | 'exportJson' | 'remove' | 'toggleFavorite' | 'copyId';
-
-/** What the session actions run over. Each member left out removes the actions that need it. */
-export interface SessionActionsDeps {
-  /** The session host: `details` (title, compact, export) and `turns` (fork). */
-  session?: Pick<SessionHost, 'details' | 'turns'>;
-  /** The session list's writes (`ChatHost.sessions`, or the app's directory, which also re-reads the list). */
-  sessions?: {
-    setFavorite?(sessionId: string, favorite: boolean): Promise<void>;
-    remove?(sessionId: string): Promise<unknown>;
-  };
-  /** Asks before a delete. Absent: no delete action (a delete is never unasked). */
-  confirm?(options: SessionConfirmOptions): Promise<boolean>;
-  /** Re-reads the session list after a write the list shows (a title, a fork). */
-  refresh?(): Promise<unknown> | void;
-  /** Shows a session (the fork). */
-  open?(sessionId: string): void;
-  /** Writes text to the clipboard. Absent: no copy-id action. */
-  copyText?(text: string): Promise<void>;
-  /** The id to copy: the one the session's host knows it by. Absent: the session's id. */
-  idOf?(sessionId: string): string;
-  /** Hears a failed action. Absent: failures are dropped. */
-  onError?(action: SessionActionName, error: unknown): void;
-  /** The delete confirmation's wording. */
-  labels?: SidebarLabels;
-}
-
-/** The session actions; each one present only when its capability is. */
-export interface SessionActions {
-  /** Writes a title generated from the conversation, then re-reads the list. */
-  generateTitle?(session: SessionActionTarget): Promise<void>;
-  /** Summarizes older turns to free context. */
-  compact?(session: SessionActionTarget): Promise<void>;
-  /** Writes the transcript as Markdown. */
-  exportMarkdown?(session: SessionActionTarget): Promise<void>;
-  /** Writes the transcript as JSON. */
-  exportJson?(session: SessionActionTarget): Promise<void>;
-  /** Asks, then deletes. Resolves whether it was deleted. */
-  remove?(session: SessionActionTarget): Promise<boolean>;
-  /** Marks or unmarks the session as a favorite. Absent on the main session's actions too (see `sessionKeyCommands`). */
-  toggleFavorite?(session: SessionActionTarget): Promise<void>;
-  /** Copies the session's id. */
-  copyId?(session: SessionActionTarget): Promise<void>;
-  /**
-   * Forks the session from a turn: creates it, calls `onCreated`, re-reads the list and shows it. Resolves the new
-   * session's id; rejects when the fork failed.
-   */
-  fork?(sessionId: string, turnId: string, onCreated?: (newId: string) => void): Promise<string>;
-}
-
-/**
- * The session actions over an app's hosts.
- *
- * @param deps - What they run over.
- */
-export function createSessionActions(deps: SessionActionsDeps): SessionActions {
-  const { session, sessions, confirm, refresh, open, copyText, onError } = deps;
-  const details = session?.details;
-  const turns = session?.turns;
-  const labels = deps.labels ?? DEFAULT_SIDEBAR_LABELS;
-  const guard =
-    (name: SessionActionName, run: (s: SessionActionTarget) => Promise<unknown>) =>
-    async (s: SessionActionTarget): Promise<void> => {
-      try {
-        await run(s);
-      } catch (error) {
-        onError?.(name, error);
-      }
-    };
-
-  const actions: SessionActions = {};
-  const generate = details?.generateTitle;
-  if (generate) {
-    actions.generateTitle = guard('generateTitle', async (s) => {
-      await generate(s.id);
-      await refresh?.();
-    });
-  }
-  const compact = details?.compact;
-  if (compact) actions.compact = guard('compact', (s) => compact(s.id));
-  const exportAs = details?.export;
-  if (exportAs) {
-    actions.exportMarkdown = guard('exportMarkdown', (s) => exportAs(s.id, 'markdown'));
-    actions.exportJson = guard('exportJson', (s) => exportAs(s.id, 'json'));
-  }
-  const remove = sessions?.remove;
-  if (remove && confirm) {
-    actions.remove = async (s) => {
-      const { question, detail } = deleteSessionPrompt(s.title ?? s.id, s.environment, labels);
-      const ok = await confirm({
-        title: question,
-        ...(detail ? { message: detail } : {}),
-        confirmLabel: labels.deleteConfirmLabel,
-        destructive: true,
-      });
-      if (!ok) return false;
-      try {
-        await remove(s.id);
-        return true;
-      } catch (error) {
-        onError?.('remove', error);
-        return false;
-      }
-    };
-  }
-  const setFavorite = sessions?.setFavorite;
-  if (setFavorite) {
-    actions.toggleFavorite = guard('toggleFavorite', (s) => setFavorite(s.id, s.favorite !== true));
-  }
-  if (copyText) {
-    actions.copyId = guard('copyId', (s) => copyText(deps.idOf ? deps.idOf(s.id) : s.id));
-  }
-  const fork = turns?.fork;
-  if (fork) {
-    actions.fork = async (sessionId, turnId, onCreated) => {
-      const newId = await fork(sessionId, turnId);
-      onCreated?.(newId);
-      await refresh?.();
-      open?.(newId);
-      return newId;
-    };
-  }
-  return actions;
-}
-
-/**
- * The session actions as key commands on the session on show (`sessionGenerateTitle`, `sessionCompact`,
- * `sessionExportMarkdown`, `sessionExportJson`, `sessionDelete`, `sessionCopyId`, `sessionFavorite`). None without a
- * session; no favorite on the main session.
- *
- * @param actions - The app's session actions.
- * @param session - The session on show, or `null`.
- */
-export function sessionKeyCommands(actions: SessionActions, session: SessionActionTarget | null): KeyCommands {
-  if (!session) return {};
-  const bind = (run: ((s: SessionActionTarget) => Promise<unknown>) | undefined) =>
-    run ? () => void run(session) : undefined;
-  const commands: KeyCommands = {};
-  const set = (action: keyof KeyCommands, handler: (() => void) | undefined) => {
-    if (handler) commands[action] = handler;
-  };
-  set('sessionGenerateTitle', bind(actions.generateTitle));
-  set('sessionCompact', bind(actions.compact));
-  set('sessionExportMarkdown', bind(actions.exportMarkdown));
-  set('sessionExportJson', bind(actions.exportJson));
-  set('sessionDelete', bind(actions.remove));
-  set('sessionCopyId', bind(actions.copyId));
-  if (!session.isMain) set('sessionFavorite', bind(actions.toggleFavorite));
-  return commands;
-}

package/src/session/headless/session-diffs.ts

@@ -1,136 +0,0 @@
-/**
- * Pure: turn a session's transcript events into the per-file patch list the
- * Diffs panel renders. Each `edit` payload on a tool event becomes one entry;
- * several edits to the same file stay separate entries in order (a diff per
- * change), newest last. Denied hunks are dropped so the patch shows what
- * actually landed.
- */
-import type { EditPayload } from 'zidane/chat';
-import { buildUnifiedDiff } from 'zidane/chat/pure';
-
-/** A transcript event as the Diffs panel reads it: a tool event may carry the edit it made. */
-export interface SessionEditEvent {
-  /** The event kind; only `tool` events carry edits. */
-  kind: string;
-  /** The edit the tool call made. */
-  edit?: EditPayload;
-  /** The tool call's id. */
-  callId?: string;
-  /** The turn's id. */
-  turnId?: string;
-}
-
-/** One edit the agent made, as a patch. */
-export interface SessionDiffEntry {
-  /** Stable id: the call (or turn) id and the entry's position. */
-  id: string;
-  /** The edited file. */
-  path: string;
-  /** The tool that made it. */
-  tool: EditPayload['tool'];
-  /** A unified diff with bare header paths. */
-  patch: string;
-  /** Added lines. */
-  added: number;
-  /** Removed lines. */
-  removed: number;
-}
-
-/**
- * Per event: the built patch and counts. Events are immutable once appended,
- * so each is built once and a new edit does not rebuild earlier diffs.
- */
-const built = new WeakMap<SessionEditEvent, Omit<SessionDiffEntry, 'id'> | null>();
-
-function buildEntry(ev: SessionEditEvent): Omit<SessionDiffEntry, 'id'> | null {
-  const hit = built.get(ev);
-  if (hit !== undefined) return hit;
-  const entry = buildEntryUncached(ev);
-  built.set(ev, entry);
-  return entry;
-}
-
-/**
- * The patches of a session's edits, in order (several edits to one file stay separate entries).
- *
- * @param events - The session's transcript events.
- */
-export function collectSessionDiffs(events: readonly SessionEditEvent[]): SessionDiffEntry[] {
-  const out: SessionDiffEntry[] = [];
-  for (const ev of events) {
-    const entry = buildEntry(ev);
-    if (entry) out.push({ id: `${ev.callId ?? ev.turnId ?? entry.path}:${out.length}`, ...entry });
-  }
-  return out;
-}
-
-function buildEntryUncached(ev: SessionEditEvent): Omit<SessionDiffEntry, 'id'> | null {
-  {
-    const edit = ev.edit;
-    if (!edit || ev.kind !== 'tool') {
-      return null;
-    }
-    const applied = edit.outcomes
-      ? edit.hunks.filter((_, i) => edit.outcomes?.[i]?.kind !== 'denied' && edit.outcomes?.[i]?.kind !== 'failed')
-      : edit.hunks;
-    if (applied.length === 0) {
-      return null;
-    }
-    const payload: EditPayload = { ...edit, hunks: applied };
-    // `buildUnifiedDiff` emits git's `a/` `b/` prefixes; pierre treats
-    // differing header paths as a rename, so normalise both to the bare path.
-    const patch = buildUnifiedDiff(payload)
-      .replace(/^--- a\//m, '--- ')
-      .replace(/^\+\+\+ b\//m, '+++ ');
-    let added = 0;
-    let removed = 0;
-    for (const line of patch.split('\n')) {
-      if (line.startsWith('+') && !line.startsWith('+++')) added++;
-      else if (line.startsWith('-') && !line.startsWith('---')) removed++;
-    }
-    return { path: edit.path, tool: edit.tool, patch, added, removed };
-  }
-}
-
-/**
- * Changed-line counts for a parsed working-tree file. pierre's
- * `FileDiffMetadata.additionLines` / `deletionLines` are the LINE CONTENTS
- * (context included), not counts; rendering them printed file content where
- * the list should show `+12 −3`. The hunks carry the real `+` / `-` counts.
- *
- * @param file - A parsed file diff (its hunks' counts).
- */
-export function fileDiffCounts(file: { hunks: readonly { additionLines: number; deletionLines: number }[] }): {
-  added: number;
-  removed: number;
-} {
-  let added = 0;
-  let removed = 0;
-  for (const hunk of file.hunks) {
-    added += hunk.additionLines;
-    removed += hunk.deletionLines;
-  }
-  return { added, removed };
-}
-
-/**
- * The entries per path, in first-seen order, with summed counts: the file list on top of the panel.
- *
- * @param entries - The session's diff entries.
- */
-export function groupByPath(
-  entries: readonly SessionDiffEntry[],
-): { path: string; entries: SessionDiffEntry[]; added: number; removed: number }[] {
-  const map = new Map<string, SessionDiffEntry[]>();
-  for (const e of entries) {
-    const list = map.get(e.path) ?? [];
-    list.push(e);
-    map.set(e.path, list);
-  }
-  return [...map.entries()].map(([path, list]) => ({
-    path,
-    entries: list,
-    added: list.reduce((n, e) => n + e.added, 0),
-    removed: list.reduce((n, e) => n + e.removed, 0),
-  }));
-}

package/src/session/headless/side.ts

@@ -1,63 +0,0 @@
-/**
- * `/side [question]` from a conversation's composer, handed to its side
- * chat: the side chat may not be mounted yet (its tab opens on it), so the
- * question waits here until the side chat takes it. React-free.
- */
-
-/** Why a `/side` cannot open: no conversation yet, a host without side chats there, no side panel to open. */
-export type SideRefusal = 'no-conversation' | 'unavailable' | 'no-panel';
-
-/**
- * Reads `/side` with an optional question: the question (`''` for none), or `null` for any other prompt.
- *
- * @param text - The prompt.
- */
-export function parseSideCommand(text: string): string | null {
-  const match = /^\/side(?:\s+([\s\S]*))?$/i.exec(text.trim());
-  return match ? (match[1] ?? '').trim() : null;
-}
-
-/** The `/side` hand-over between a composer and the side chat. */
-export interface SideRequests {
-  /**
-   * Opens `parent`'s side chat with `question` (`''`: just opens it) through `open`. Returns why it can't instead,
-   * or `null` once handed over.
-   */
-  request(
-    parent: string | null,
-    question: string,
-    options: { available: boolean; open: (() => void) | null },
-  ): SideRefusal | null;
-  /** The waiting question for `parent`, removed as it is returned. */
-  take(parent: string): string | undefined;
-  /** Calls `onRequest` when a question starts waiting. Returns the unsubscribe. */
-  subscribe(onRequest: () => void): () => void;
-}
-
-/** Creates an empty {@link SideRequests}: one per window. */
-export function createSideRequests(): SideRequests {
-  const pending = new Map<string, string>();
-  const listeners = new Set<() => void>();
-  return {
-    request(parent, question, { available, open }) {
-      if (!parent) return 'no-conversation';
-      if (!available) return 'unavailable';
-      if (!open) return 'no-panel';
-      if (question) {
-        pending.set(parent, question);
-        for (const listener of listeners) listener();
-      }
-      open();
-      return null;
-    },
-    take(parent) {
-      const question = pending.get(parent);
-      pending.delete(parent);
-      return question;
-    },
-    subscribe(onRequest) {
-      listeners.add(onRequest);
-      return () => void listeners.delete(onRequest);
-    },
-  };
-}