zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/draft-target.ts

@@ -1,87 +0,0 @@
-/**
- * Where the new-chat draft runs, as rules: the recent folders its folder menu
- * offers, the folder it is in, and when that folder makes the window's draft
- * scope. The app keeps the picks (they reset with the draft) and feeds them in.
- */
-
-/** A session row as {@link recentLocalFolders} reads it. */
-export interface DraftFolderSource {
-  /** The session's folder (`''`: none). */
-  cwd?: string | null;
-  /** Set for a server's session: its folders are not on this computer. */
-  hostId?: string | null;
-}
-
-/**
- * This computer's recent folders, most recent first (the rows' order), each once.
- *
- * @param sessions - The session rows, most recently updated first.
- * @param limit - How many to keep.
- */
-export function recentLocalFolders(sessions: readonly DraftFolderSource[], limit = 5): string[] {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const s of sessions) {
-    if (!s.cwd || s.hostId || seen.has(s.cwd)) continue;
-    seen.add(s.cwd);
-    out.push(s.cwd);
-    if (out.length >= limit) break;
-  }
-  return out;
-}
-
-/**
- * A saved server's recent folders (its sessions' folders there), most recent first, each once.
- *
- * @param sessions - The session rows, most recently updated first.
- * @param hostId - The server.
- * @param limit - How many to keep.
- */
-export function recentHostFolders(sessions: readonly DraftFolderSource[], hostId: string, limit = 5): string[] {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const s of sessions) {
-    if (!s.cwd || s.hostId !== hostId || seen.has(s.cwd)) continue;
-    seen.add(s.cwd);
-    out.push(s.cwd);
-    if (out.length >= limit) break;
-  }
-  return out;
-}
-
-/** What {@link draftFolderPath} and {@link draftLocalFolder} read. */
-export interface DraftFolderState {
-  /** The open session's folder (`''` for none); `undefined` on the draft. */
-  sessionCwd?: string;
-  /** The draft runs on a saved server. */
-  onServer: boolean;
-  /** The draft runs on a machine's environment. */
-  onMachine?: boolean;
-  /** "Start without a folder" was picked for this draft. */
-  folderless: boolean;
-  /** The folder new chats open in (`null`: none picked yet). */
-  defaultFolder: string | null;
-}
-
-/**
- * The conversation's folder: `null` while the draft has none picked (the
- * folder gate shows), `''` for none (a server's draft has none on this
- * computer), else the folder.
- *
- * @param state - The draft's picks, or the open session's folder.
- */
-export function draftFolderPath(state: DraftFolderState): string | null {
-  if (state.sessionCwd !== undefined) return state.sessionCwd;
-  return state.onServer || state.folderless ? '' : state.defaultFolder;
-}
-
-/**
- * The draft's folder when it is a folder on this computer, the only kind that
- * makes a draft scope (a server's or machine's draft, or a folderless one, has none).
- *
- * @param state - The draft's picks (`sessionCwd` set: not a draft, `null`).
- */
-export function draftLocalFolder(state: DraftFolderState): string | null {
-  if (state.sessionCwd !== undefined || state.onServer || state.onMachine || state.folderless) return null;
-  return draftFolderPath(state) || null;
-}

package/src/chat/headless/file-chip.ts

@@ -1,175 +0,0 @@
-/**
- * Inline-code → file chip classification. Pure so it can be unit-tested.
- *
- * Markdown inline code that names a file or directory (`src/a.ts`,
- * `README.md`, `packages/gui/`) renders as a chip with a type icon instead
- * of a plain code span. The rule is deliberately conservative: a bare word
- * with no extension and no separator (`MapIR`, `useState`) stays code.
- *
- * Icons are static class names (UnoCSS scans this file), so keep every
- * icon literal here rather than composing names at runtime.
- */
-
-export type FileChipKind = 'dir' | 'file';
-
-/** A path in prose, as a chip shows it: its kind, name, icon or language letters, and tone. */
-export interface FileChip {
-  /** A file or a folder. */
-  kind: FileChipKind;
-  /** What the chip shows: the last path segment (with trailing `/` stripped). */
-  name: string;
-  /** Full text as written, for the tooltip and for opening. */
-  path: string;
-  /** Iconify class, e.g. `i-ph-folder`. */
-  icon: string;
-  /** Two-letter text badge used instead of an icon for languages that read better as text. */
-  badge?: string;
-  /** Accent hue token for the badge/icon: a `--zg-*` var name. */
-  tone?: string;
-}
-
-interface IconRule {
-  exts: readonly string[];
-  icon?: string;
-  badge?: string;
-  tone?: string;
-}
-
-const RULES: readonly IconRule[] = [
-  { exts: ['tsx', 'jsx'], icon: 'i-ph-atom', tone: 'var(--zg-info)' },
-  { exts: ['ts', 'mts', 'cts'], badge: 'TS', tone: 'var(--zg-info)' },
-  { exts: ['js', 'mjs', 'cjs'], badge: 'JS', tone: 'var(--zg-warn)' },
-  { exts: ['json', 'jsonc', 'json5'], icon: 'i-ph-brackets-curly', tone: 'var(--zg-warn)' },
-  { exts: ['md', 'mdx', 'txt', 'rst'], icon: 'i-ph-file-text' },
-  { exts: ['css', 'scss', 'sass', 'less'], icon: 'i-ph-palette', tone: 'var(--zg-accent)' },
-  { exts: ['html', 'htm', 'vue', 'svelte', 'astro'], icon: 'i-ph-code', tone: 'var(--zg-danger)' },
-  { exts: ['sh', 'bash', 'zsh', 'fish', 'ps1', 'bat'], icon: 'i-ph-terminal' },
-  { exts: ['py'], badge: 'PY', tone: 'var(--zg-info)' },
-  { exts: ['rs'], badge: 'RS', tone: 'var(--zg-warn)' },
-  { exts: ['go'], badge: 'GO', tone: 'var(--zg-info)' },
-  { exts: ['rb'], badge: 'RB', tone: 'var(--zg-danger)' },
-  { exts: ['java', 'kt', 'kts', 'scala'], icon: 'i-ph-coffee' },
-  { exts: ['c', 'h', 'cpp', 'cc', 'hpp', 'cs', 'swift', 'm', 'mm', 'zig'], icon: 'i-ph-file-code' },
-  { exts: ['yml', 'yaml', 'toml', 'ini', 'env', 'cfg', 'conf', 'lock'], icon: 'i-ph-sliders-horizontal' },
-  { exts: ['sql', 'db', 'sqlite'], icon: 'i-ph-database' },
-  { exts: ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'ico', 'avif', 'heic'], icon: 'i-ph-image' },
-  { exts: ['mp4', 'mov', 'webm', 'mp3', 'wav', 'ogg'], icon: 'i-ph-film-strip' },
-  { exts: ['pdf'], icon: 'i-ph-text-aa' },
-  { exts: ['zip', 'tar', 'gz', 'tgz', 'bz2', 'xz', '7z'], icon: 'i-ph-archive' },
-  { exts: ['csv', 'tsv', 'xlsx', 'parquet'], icon: 'i-ph-table' },
-  { exts: ['graphql', 'gql', 'proto', 'prisma', 'wasm'], icon: 'i-ph-file-code' },
-];
-
-const EXT_INDEX: ReadonlyMap<string, IconRule> = new Map(RULES.flatMap((r) => r.exts.map((e) => [e, r] as const)));
-
-/** Well-known extensionless files that still deserve a file chip. */
-const SPECIAL_FILES = new Set([
-  'Dockerfile',
-  'Makefile',
-  'LICENSE',
-  'CHANGELOG',
-  'README',
-  '.gitignore',
-  '.npmrc',
-  '.nvmrc',
-  '.env',
-  '.editorconfig',
-  '.prettierrc',
-  '.eslintrc',
-]);
-
-const DEFAULT_FILE_ICON = 'i-ph-file';
-const DIR_ICON = 'i-ph-folder';
-
-/** Reject anything that isn't plausibly a path: spaces, quotes, operators, prose. */
-const PATH_SHAPE = /^(?:\.{1,2}\/|\/|~\/)?[\w@.-]+(?:\/[\w@.-]+)*\/?$/;
-
-/**
- * What inline code names, read from its text alone: a file or folder chip, or `null` for plain code.
- *
- * @param raw - The inline code's text.
- */
-export function classifyInlineCode(raw: string): FileChip | null {
-  const text = raw.trim();
-  if (text.length === 0 || text.length > 200 || !PATH_SHAPE.test(text)) {
-    return null;
-  }
-  // Version-ish and number-ish tokens (`1.2.3`, `3.14`) are not files.
-  if (/^\d[\d.]*$/.test(text)) {
-    return null;
-  }
-
-  const isDir = text.endsWith('/');
-  const trimmed = isDir ? text.slice(0, -1) : text;
-  const segments = trimmed.split('/').filter((s) => s.length > 0 && s !== '.' && s !== '..' && s !== '~');
-  if (segments.length === 0) {
-    return null;
-  }
-  const name = segments[segments.length - 1];
-
-  if (isDir) {
-    return { kind: 'dir', name, path: text, icon: DIR_ICON };
-  }
-
-  const dot = name.lastIndexOf('.');
-  const ext = dot > 0 ? name.slice(dot + 1).toLowerCase() : '';
-  const rule = ext ? EXT_INDEX.get(ext) : undefined;
-
-  if (rule) {
-    return {
-      kind: 'file',
-      name,
-      path: text,
-      icon: rule.icon ?? DEFAULT_FILE_ICON,
-      ...(rule.badge ? { badge: rule.badge } : {}),
-      ...(rule.tone ? { tone: rule.tone } : {}),
-    };
-  }
-  if (SPECIAL_FILES.has(name) || (name.startsWith('.') && dot === 0 && segments.length === 1)) {
-    return { kind: 'file', name, path: text, icon: DEFAULT_FILE_ICON };
-  }
-  // A path with separators but no recognised extension on its tail is
-  // most likely a directory (`src/chat`, `packages/gui`). Extension-like
-  // tails we don't know (`foo.xyz`) still get a generic file chip.
-  if (segments.length > 1) {
-    return ext
-      ? { kind: 'file', name, path: text, icon: DEFAULT_FILE_ICON }
-      : { kind: 'dir', name, path: text, icon: DIR_ICON };
-  }
-  // Bare single token: only chip it when it clearly has an extension.
-  return ext && ext.length <= 5 ? { kind: 'file', name, path: text, icon: DEFAULT_FILE_ICON } : null;
-}
-
-/**
- * The chip of a path known to be a file or folder (a mention): never plain code.
- *
- * @param path - The file's path, as written.
- */
-export function chipForPath(path: string): FileChip {
-  const chip = classifyInlineCode(path);
-  if (chip) return chip;
-  const name = path.replace(/\/$/, '').split('/').pop() || path;
-  return path.endsWith('/')
-    ? { kind: 'dir', name, path, icon: DIR_ICON }
-    : { kind: 'file', name, path, icon: DEFAULT_FILE_ICON };
-}
-
-/**
- * Absolute path for opening: relative chips resolve against `cwd`.
- *
- * @param chip - The chip.
- * @param cwd - The session's folder (`null`: none).
- */
-export function resolveChipPath(chip: FileChip, cwd: string | null): string | null {
-  const p = chip.path.replace(/\/$/, '');
-  if (p.startsWith('/')) {
-    return p;
-  }
-  if (p.startsWith('~/')) {
-    return null; // needs the home dir; main resolves nothing here
-  }
-  if (!cwd) {
-    return null;
-  }
-  return `${cwd.replace(/\/$/, '')}/${p.replace(/^\.\//, '')}`;
-}

package/src/chat/headless/fixture-host.ts

@@ -1,294 +0,0 @@
-/**
- * A complete `ChatHost` over static data: the kit's demos, docs and tests
- * run on it. Sessions can be renamed, archived, favorited and deleted (in memory);
- * `send` appends the prompt and plays `reply` back as a stream when given,
- * with `interrupt`, `steer` (the message joins the run's transcript) and
- * `followUp` (sent when the run ends). A reply step can raise an interaction:
- * the run waits on it and resumes with what `then` makes of the answer.
- */
-import type { InteractionRequest, InteractionResponse } from 'zidane/chat';
-
-import type {
-  ChatEvent,
-  ChatHost,
-  ChatInteraction,
-  ChatModelProvider,
-  ChatSession,
-  SessionSearchHit,
-  TranscriptState,
-} from './host';
-import type { SessionArchiveFilter, SidebarListSession } from './sidebar/types';
-import { constant, writable, type Writable } from './store';
-import { fixtureTranscriptMembers, type ChatTranscriptFixture } from './fixture-transcript';
-
-/** Static data a {@link createFixtureHost} serves: sessions, their transcripts, models, and pending interactions. */
-export interface ChatFixture {
-  /** The sessions the list starts with. */
-  sessions: ChatSession[];
-  /** Events per session id. */
-  transcripts?: Record<string, ChatEvent[]>;
-  /** Providers and models for the model picker. Default: none. */
-  models?: ChatModelProvider[];
-  /** Requests already waiting, per session id. */
-  interactions?: Record<string, InteractionRequest[]>;
-  /** The transcript extras (references, chips, card facts, badge actions, a shared search). Each part left out leaves its member out. */
-  extras?: ChatTranscriptFixture;
-}
-
-/** A scripted pause: the run waits on `interaction`, then streams `then(answer)` (`null`: dismissed). */
-export interface FixtureInteractionStep {
-  /** The question, plan, or approval the run raises. */
-  interaction: InteractionRequest;
-  /** Builds the events to stream after the user answers. Receives the response, or `null` when the request was dismissed. */
-  then?: (response: InteractionResponse | null) => ChatEvent[];
-}
-
-/** One step of a scripted reply: a transcript event to stream, or a {@link FixtureInteractionStep} that pauses the run. */
-export type FixtureStep = ChatEvent | FixtureInteractionStep;
-
-/** Options for {@link createFixtureHost}. */
-export interface FixtureHostOptions {
-  /** Allow create / rename / archive / favorite / delete (default true). */
-  editable?: boolean;
-  /** What the "agent" answers to a sent prompt; streamed in. None: `send`, `interrupt`, `steer` and `followUp` are absent. */
-  reply?: (prompt: string, sessionId: string) => FixtureStep[];
-  /** Milliseconds between streamed chunks (default 24). */
-  tickMs?: number;
-}
-
-const EMPTY: TranscriptState = { events: [], running: false, hydrated: true };
-
-/**
- * Creates a complete {@link ChatHost} over static data, held in memory. The kit's demos, docs, and tests run on it.
- *
- * @param fixture - The sessions, transcripts, models, and interactions to serve.
- * @param options - Whether the host is editable, how it replies to prompts, and the streaming pace.
- */
-export function createFixtureHost(fixture: ChatFixture, options: FixtureHostOptions = {}): ChatHost {
-  const editable = options.editable ?? true;
-  const tick = options.tickMs ?? 24;
-  const list = writable<readonly ChatSession[]>(fixture.sessions);
-  const transcripts = new Map<string, Writable<TranscriptState>>();
-  const transcriptOf = (id: string) => {
-    let t = transcripts.get(id);
-    if (!t) {
-      t = writable<TranscriptState>({ ...EMPTY, events: fixture.transcripts?.[id] ?? [] });
-      transcripts.set(id, t);
-    }
-    return t;
-  };
-  const changed = new Set<(id: string) => void>();
-  const announce = (id: string) => {
-    for (const listener of [...changed]) listener(id);
-  };
-  const patch = (id: string, change: Partial<ChatSession>) => {
-    list.set((all) => all.map((s) => (s.id === id ? { ...s, ...change } : s)));
-    announce(id);
-  };
-  const spaceOf = new Map<string, string>();
-  const views: Record<string, unknown> = {};
-  let shownSpace: string | null = null;
-  const archived = (filter: SessionArchiveFilter | undefined) => (s: ChatSession) =>
-    !filter || filter === 'all' || Boolean(s.archived) === (filter === 'archived');
-  const textOf = (event: ChatEvent) => ('text' in event && typeof event.text === 'string' ? event.text : '');
-
-  const host: ChatHost = {
-    ...fixtureTranscriptMembers(fixture.extras),
-    sessions: {
-      list,
-      ...(editable
-        ? {
-            async rename(id: string, title: string) {
-              patch(id, { title, updatedAt: Date.now() });
-            },
-            async setArchived(id: string, archived: boolean) {
-              patch(id, { archived });
-            },
-            async setFavorite(id: string, favorite: boolean) {
-              patch(id, { favorite });
-            },
-            async remove(id: string) {
-              list.set((all) => all.filter((s) => s.id !== id));
-              announce(id);
-            },
-            async query({ archive, hostId }: { archive: SessionArchiveFilter; hostId?: string }) {
-              if (hostId) return [];
-              return list
-                .get()
-                .filter(archived(archive))
-                .map((s): SidebarListSession => {
-                  const spaceId = spaceOf.get(s.id);
-                  return { ...s, cwd: s.group ?? '', ...(spaceId ? { spaceId } : {}) };
-                });
-            },
-            async setSpace(id: string, spaceId: string) {
-              spaceOf.set(id, spaceId);
-              announce(id);
-            },
-            async search(query: string, filter?: { archive?: SessionArchiveFilter }) {
-              const needle = query.trim().toLowerCase();
-              if (!needle) return [];
-              return list
-                .get()
-                .filter(archived(filter?.archive))
-                .flatMap((s): SessionSearchHit[] => {
-                  const texts = transcriptOf(s.id)
-                    .get()
-                    .events.map(textOf)
-                    .filter((t) => t.toLowerCase().includes(needle));
-                  return texts.length > 0
-                    ? [
-                        {
-                          sessionId: s.id,
-                          title: s.title,
-                          excerpt: texts[0]!,
-                          matchCount: texts.length,
-                          updatedAt: s.updatedAt,
-                        },
-                      ]
-                    : [];
-                });
-            },
-            onChanged(listener: (id: string) => void) {
-              changed.add(listener);
-              return () => changed.delete(listener);
-            },
-            views: {
-              getViews: async () => ({ ...views }),
-              setView: async (spaceId: string, view: unknown) => {
-                views[spaceId] = view;
-              },
-              getSpace: async () => shownSpace,
-              setSpace: async (spaceId: string) => {
-                shownSpace = spaceId;
-              },
-            },
-            async create(input?: { title?: string }) {
-              const now = Date.now();
-              const s: ChatSession = {
-                id: `s-${now}`,
-                title: input?.title ?? 'New session',
-                status: 'idle',
-                createdAt: now,
-                updatedAt: now,
-              };
-              list.set((all) => [s, ...all]);
-              return s;
-            },
-          }
-        : {}),
-    },
-    transcript: transcriptOf,
-    models: constant(fixture.models ?? []),
-  };
-
-  const pending = new Map<string, Writable<readonly ChatInteraction[]>>();
-  const pendingOf = (id: string) => {
-    let p = pending.get(id);
-    if (!p) {
-      const seeded = (fixture.interactions?.[id] ?? []).map((request) => ({
-        requestId: request.id,
-        sessionId: id,
-        request,
-      }));
-      p = writable<readonly ChatInteraction[]>(seeded);
-      pending.set(id, p);
-    }
-    return p;
-  };
-  const waiters = new Map<string, (response: InteractionResponse | null) => void>();
-  const settle = (requestId: string, response: InteractionResponse | null) => {
-    for (const p of pending.values()) p.set((all) => all.filter((i) => i.requestId !== requestId));
-    waiters.get(requestId)?.(response);
-    waiters.delete(requestId);
-  };
-  host.interactions = {
-    pending: pendingOf,
-    async answer(requestId, response) {
-      settle(requestId, response);
-    },
-    async cancel(requestId) {
-      settle(requestId, null);
-    },
-  };
-
-  if (options.reply) {
-    const reply = options.reply;
-    // The run in flight per session: a run whose token is gone was interrupted.
-    const runs = new Map<string, symbol>();
-    const queued = new Map<string, string[]>();
-    const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-    const stream = async (sessionId: string, run: symbol, steps: readonly FixtureStep[]): Promise<boolean> => {
-      const t = transcriptOf(sessionId);
-      const live = () => runs.get(sessionId) === run;
-      for (const step of steps) {
-        if (!live()) return false;
-        if ('interaction' in step) {
-          const { interaction } = step;
-          const answered = new Promise<InteractionResponse | null>((resolve) => waiters.set(interaction.id, resolve));
-          pendingOf(sessionId).set((all) => [...all, { requestId: interaction.id, sessionId, request: interaction }]);
-          const response = await answered;
-          // Interrupted while it waited: the dismissal settled it, but the run is over.
-          if (!live()) return false;
-          if (!(await stream(sessionId, run, step.then?.(response) ?? []))) return false;
-          continue;
-        }
-        const event = step;
-        if (event.kind === 'markdown' && event.text.length > 24) {
-          // Stream prose in word chunks, like a live run.
-          const words = event.text.split(/(?<=\s)/);
-          const start = t.get().events.length;
-          for (let i = 1; i <= words.length; i += 3) {
-            await wait(tick);
-            if (!live()) return false;
-            const text = words.slice(0, i).join('');
-            t.set((s) => ({
-              ...s,
-              events: [...s.events.slice(0, start), { ...event, text, streaming: true } as ChatEvent],
-            }));
-          }
-          t.set((s) => ({ ...s, events: [...s.events.slice(0, start), { ...event, streaming: false } as ChatEvent] }));
-        } else {
-          await wait(tick * 4);
-          if (!live()) return false;
-          t.set((s) => ({ ...s, events: [...s.events, event] }));
-        }
-      }
-      return live();
-    };
-
-    host.send = async ({ sessionId, prompt, attachments }) => {
-      const t = transcriptOf(sessionId);
-      const run = Symbol(sessionId);
-      runs.set(sessionId, run);
-      const echo: ChatEvent = { kind: 'user-prompt', text: prompt, ...(attachments?.length ? { attachments } : {}) };
-      t.set((s) => ({ ...s, running: true, events: [...s.events, echo] }));
-      patch(sessionId, { status: 'running', updatedAt: Date.now() });
-      if (!(await stream(sessionId, run, reply(prompt, sessionId)))) return;
-      runs.delete(sessionId);
-      t.set((s) => ({ ...s, running: false }));
-      patch(sessionId, { status: 'completed', updatedAt: Date.now() });
-      const next = queued.get(sessionId)?.shift();
-      if (next !== undefined) await host.send!({ sessionId, prompt: next });
-    };
-    host.interrupt = (sessionId) => {
-      runs.delete(sessionId);
-      queued.delete(sessionId);
-      for (const i of pendingOf(sessionId).get()) settle(i.requestId, null);
-      transcriptOf(sessionId).set((s) => ({ ...s, running: false }));
-      patch(sessionId, { status: 'idle', updatedAt: Date.now() });
-    };
-    host.steer = async (sessionId, message) => {
-      if (!runs.has(sessionId)) return false;
-      transcriptOf(sessionId).set((s) => ({ ...s, events: [...s.events, { kind: 'user-prompt', text: message }] }));
-      return true;
-    };
-    host.followUp = async (sessionId, message) => {
-      if (!runs.has(sessionId)) return false;
-      queued.set(sessionId, [...(queued.get(sessionId) ?? []), message]);
-      return true;
-    };
-  }
-  return host;
-}

package/src/chat/headless/fixture-transcript.ts

@@ -1,125 +0,0 @@
-/**
- * The transcript extras of the fixture host (`createFixtureHost`'s
- * `ChatFixture.extras`): reference providers and views, what prose chips
- * name, commits, the facts chip cards read and badge actions, all served
- * from static data. Each part left out of the fixture leaves its member
- * out of the host.
- */
-import type { BadgeActionEffect, BadgeMenuItem, ExtensionReferenceView, ReferenceProviderWire } from 'zidane/chat/pure';
-
-import type { ChatHost } from './host';
-import type {
-  ChatCommandFacts,
-  ChatCommit,
-  ChatContextFacts,
-  ChatResolvedPath,
-  ChatSearchState,
-  ChatSessionFacts,
-  ChatSkillFacts,
-} from './transcript-host';
-
-/** Static data for the transcript extras. */
-export interface ChatTranscriptFixture {
-  /** Reference providers per folder, and the views of their keys by `providerId:key`. */
-  references?: {
-    providers: Readonly<Record<string, readonly ReferenceProviderWire[]>>;
-    views: Readonly<Record<string, ExtensionReferenceView>>;
-  };
-  /** What each text names, per folder (a text missing here names nothing). */
-  paths?: Readonly<Record<string, Readonly<Record<string, ChatResolvedPath>>>>;
-  /** Commits by full sha. */
-  commits?: Readonly<Record<string, ChatCommit>>;
-  /** The sessions `#chat` cards read. */
-  sessions?: readonly ChatSessionFacts[];
-  /** Context gauges by session id. */
-  contexts?: Readonly<Record<string, ChatContextFacts>>;
-  /** Skills per folder. */
-  skills?: Readonly<Record<string, readonly ChatSkillFacts[]>>;
-  /** Commands per folder. */
-  commands?: Readonly<Record<string, readonly ChatCommandFacts[]>>;
-  /** Badge items per folder, and the effect each item id answers. */
-  badges?: {
-    items: Readonly<Record<string, readonly BadgeMenuItem[]>>;
-    effects: Readonly<Record<string, BadgeActionEffect>>;
-  };
-  /** Share the transcript search between the windows of this page (one host per window). */
-  searchSync?: boolean;
-  /** Site icons (data URLs) by origin. */
-  siteIcons?: Readonly<Record<string, string>>;
-}
-
-type Members = Pick<ChatHost, 'searchSync' | 'references' | 'paths' | 'chips' | 'badges' | 'siteIcons'>;
-
-/** The search a page's fixture hosts share, as a session's windows do. */
-const searchListeners = new Set<{ owner: object; listener: (state: ChatSearchState) => void }>();
-
-/**
- * Builds the fixture host's transcript extras from static data.
- *
- * @param fixture - What the extras serve; a part left out leaves its member out.
- */
-export function fixtureTranscriptMembers(fixture: ChatTranscriptFixture | undefined): Members {
-  if (!fixture) return {};
-  const members: Members = {};
-  const { references, paths, commits, sessions, contexts, skills, commands, badges } = fixture;
-  if (fixture.searchSync) {
-    const owner = {};
-    members.searchSync = {
-      async set(sessionId, { active, query }) {
-        for (const entry of [...searchListeners]) {
-          if (entry.owner !== owner) entry.listener({ sessionId, active, query });
-        }
-      },
-      onChanged(listener) {
-        const entry = { owner, listener };
-        searchListeners.add(entry);
-        return () => searchListeners.delete(entry);
-      },
-    };
-  }
-  if (references) {
-    members.references = {
-      providers: async (cwd) => references.providers[cwd] ?? [],
-      resolve: async (_cwd, items) =>
-        items.map(({ providerId, key }) => references.views[`${providerId}:${key}`] ?? null),
-    };
-  }
-  if (paths) {
-    members.paths = {
-      resolve: async (cwd, texts) => texts.map((text) => paths[cwd]?.[text] ?? { kind: 'missing' }),
-    };
-  }
-  if (commits || sessions || contexts || skills || commands) {
-    members.chips = {
-      ...(commits ? { commit: async (_cwd: string, sha: string) => commits[sha] ?? null } : {}),
-      ...(sessions ? { sessions: async () => sessions } : {}),
-      ...(contexts ? { context: async (sessionId: string) => contexts[sessionId] ?? null } : {}),
-      ...(skills ? { skills: async (cwd: string) => skills[cwd] ?? [] } : {}),
-      ...(commands ? { commands: async (cwd: string) => commands[cwd] ?? [] } : {}),
-    };
-  }
-  const icons = fixture.siteIcons;
-  if (icons) {
-    const loaded = new Map<string, string | null>();
-    const listeners = new Set<() => void>();
-    members.siteIcons = {
-      get: (origin) => loaded.get(origin) ?? null,
-      request(origin) {
-        if (loaded.has(origin)) return;
-        loaded.set(origin, icons[origin] ?? null);
-        if (icons[origin]) for (const listener of [...listeners]) listener();
-      },
-      subscribe(listener) {
-        listeners.add(listener);
-        return () => listeners.delete(listener);
-      },
-    };
-  }
-  if (badges) {
-    members.badges = {
-      actions: async (cwd) => badges.items[cwd] ?? [],
-      run: async (_cwd, _source, id) => badges.effects[id] ?? {},
-    };
-  }
-  return members;
-}