zidane-ui 9.0.4 → 9.1.3

package/src/approvals/SafelistPanel.tsx

@@ -1,149 +0,0 @@
-/**
- * The "Always allow" entries the user granted, grouped by project, each with
- * a Revoke action. It reads the host's `safelist` (again on mount and when the
- * window regains focus: entries are granted from approval cards meanwhile).
- */
-import { useCallback, useEffect, useState, type CSSProperties, type ReactNode } from 'react';
-
-import { BTN_DANGER } from '../components/button';
-import { ErrorNote, FormSection } from '../components/Form';
-import { EmptyState, SectionLabel } from '../components/Surface';
-import { useReadable } from '../chat/headless/store';
-import { ApprovalShell, type ApprovalShellProps } from './ApprovalShell';
-import { useApprovalsHost, useApprovalsLabels } from './ApprovalsProvider';
-import type { ApprovalsError, ApprovalsSafelist } from './headless/host';
-
-/** Props for {@link SafelistPanel}. */
-export interface SafelistPanelProps {
-  /** Draws the panel around the list (an app's own modal shell). It receives the title, description and body. Default: {@link ApprovalShell}. */
-  renderShell?: (props: ApprovalShellProps) => ReactNode;
-  /** Extra classes on the default shell. */
-  className?: string;
-  /** Inline styles on the default shell. */
-  style?: CSSProperties;
-}
-
-/**
- * Renders the safelist: each project's "Always allow" entries with a Revoke button (when the host
- * offers `safelist.remove`), the empty state, and read or revoke errors. Renders nothing when the
- * host has no safelist.
- *
- * @param props - An optional `renderShell`, `className` and `style`.
- */
-export function SafelistPanel(props: SafelistPanelProps) {
-  const safelist = useApprovalsHost().safelist;
-  return safelist ? <SafelistBody safelist={safelist} {...props} /> : null;
-}
-
-function SafelistBody({
-  safelist,
-  renderShell,
-  className,
-  style,
-}: SafelistPanelProps & { safelist: ApprovalsSafelist }) {
-  const labels = useApprovalsLabels();
-  const state = useReadable(safelist.state);
-  const groups = state.projects;
-  // A revoke's failure; a failed read shows its own error (never an empty list).
-  const [revokeError, setRevokeError] = useState<ApprovalsError | null>(null);
-  const shown = revokeError ?? (state.status === 'error' ? state.error : null);
-  const [busyKey, setBusyKey] = useState<string | null>(null);
-
-  useEffect(() => {
-    void safelist.refresh();
-    const onFocus = () => void safelist.refresh();
-    window.addEventListener('focus', onFocus);
-    return () => window.removeEventListener('focus', onFocus);
-  }, [safelist]);
-
-  const remove = safelist.remove;
-  const revoke = useCallback(
-    async (project: string, entry: string) => {
-      if (!remove) return;
-      setBusyKey(`${project}::${entry}`);
-      try {
-        setRevokeError(null);
-        await remove(project, entry);
-      } catch (err) {
-        setRevokeError(err as ApprovalsError);
-      } finally {
-        setBusyKey(null);
-      }
-    },
-    [remove],
-  );
-
-  const empty = groups !== null && groups.every((g) => g.entries.length === 0);
-
-  const body = (
-    <>
-      {groups === null && state.status !== 'error' && (
-        <div className="text-sm text-[var(--zg-text-muted)]">{labels.safelistLoading}</div>
-      )}
-
-      {shown && (
-        <div className="mb-3">
-          <ErrorNote>{labels.approvalsError(shown)}</ErrorNote>
-        </div>
-      )}
-
-      {groups !== null && empty && (
-        <EmptyState icon="i-ph-shield-check-duotone" title={labels.safelistEmpty} hint={labels.safelistEmptyHint} />
-      )}
-
-      {groups !== null && !empty && (
-        <div className="flex flex-col gap-5">
-          {groups
-            .filter((g) => g.entries.length > 0)
-            .map((g) => (
-              <FormSection
-                key={g.project}
-                title={
-                  <span className="flex items-baseline gap-2 min-w-0 normal-case tracking-normal">
-                    <SectionLabel>{labels.safelistProject}</SectionLabel>
-                    <span className="zg-meta !text-[var(--zg-text)] truncate" title={g.project}>
-                      {g.project}
-                    </span>
-                    <span className="zg-meta">{labels.safelistCount(g.entries.length)}</span>
-                  </span>
-                }
-              >
-                <ul className="list-none m-0 p-0 flex flex-col">
-                  {g.entries.map((entry) => {
-                    const key = `${g.project}::${entry}`;
-                    return (
-                      <li
-                        key={key}
-                        className="flex items-center gap-2 pl-3 pr-1 py-1 rounded-zg-md hover:bg-[var(--zg-row-hover)] transition-colors"
-                      >
-                        <span className="flex-1 min-w-0 font-mono text-xs text-[var(--zg-text)] truncate" title={entry}>
-                          {entry}
-                        </span>
-                        {remove && (
-                          <button
-                            type="button"
-                            onClick={() => void revoke(g.project, entry)}
-                            disabled={busyKey === key}
-                            className={BTN_DANGER}
-                          >
-                            {busyKey === key ? labels.safelistRevoking : labels.safelistRevoke}
-                          </button>
-                        )}
-                      </li>
-                    );
-                  })}
-                </ul>
-              </FormSection>
-            ))}
-        </div>
-      )}
-    </>
-  );
-
-  const shell: ApprovalShellProps = {
-    title: labels.safelistTitle,
-    description: labels.safelistDescription,
-    children: body,
-  };
-  return renderShell ? renderShell(shell) : <ApprovalShell {...shell} className={className} style={style} />;
-}

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

@@ -1,73 +0,0 @@
-/**
- * An `ApprovalsHost` held in memory, for docs, demos and an app's own tests:
- * the requests you give it are pending, a decision removes one, and the
- * safelist answers from memory.
- */
-import type { ApprovalDecision, ApprovalRequest, ApprovalsHost, SafelistProject } from './host';
-import { createPendingApprovals } from './pending';
-import { createSafelist } from './safelist';
-
-/** Options for {@link createFixtureApprovalsHost}. */
-export interface FixtureApprovalsOptions {
-  /** The approvals pending at the start, oldest first. Default: none. */
-  pending?: readonly ApprovalRequest[];
-  /** The safelist's projects. Default: empty. `false`: no safelist member. */
-  safelist?: readonly SafelistProject[] | false;
-  /** `false` leaves out `resolve` and `denyAll` (a host that shows approvals but can't answer them). Default `true`. */
-  canResolve?: boolean;
-  /** Called with every decision, after the request left the queue. */
-  onResolve?(requestId: string, decision: ApprovalDecision): void;
-  /** Called with every bulk deny (`undefined`: every session), after the requests left the queue. */
-  onDenyAll?(sessionId: string | undefined): void;
-}
-
-/** The fixture host, plus a way to raise a request as a running agent would. */
-export interface FixtureApprovalsHost extends ApprovalsHost {
-  /** Adds a request to the queue, as a tool call that needs approval does. */
-  raise(request: ApprovalRequest): void;
-  /** Removes a request without a decision, as when another window answered it. */
-  dismiss(requestId: string): void;
-}
-
-/**
- * Creates an {@link ApprovalsHost} held in memory.
- *
- * @param options - The pending approvals, the safelist, and whether decisions are offered.
- */
-export function createFixtureApprovalsHost(options: FixtureApprovalsOptions = {}): FixtureApprovalsHost {
-  const { canResolve = true, onResolve, onDenyAll } = options;
-  const pending = createPendingApprovals();
-  pending.merge(options.pending ?? []);
-  let projects: SafelistProject[] =
-    options.safelist === false ? [] : (options.safelist ?? []).map((p) => ({ ...p, entries: [...p.entries] }));
-
-  return {
-    pending,
-    raise: pending.add,
-    dismiss: pending.drop,
-    ...(canResolve
-      ? {
-          async resolve(requestId: string, decision: ApprovalDecision) {
-            if (pending.take(requestId)) onResolve?.(requestId, decision);
-          },
-          async denyAll(sessionId?: string) {
-            pending.takeAll(sessionId);
-            onDenyAll?.(sessionId);
-          },
-        }
-      : {}),
-    ...(options.safelist === false
-      ? {}
-      : {
-          safelist: createSafelist({
-            list: async () =>
-              projects.filter((p) => p.entries.length > 0).map((p) => ({ ...p, entries: [...p.entries] })),
-            remove: async (project, entry) => {
-              projects = projects.map((p) =>
-                p.project === project ? { ...p, entries: p.entries.filter((e) => e !== entry) } : p,
-              );
-            },
-          }),
-        }),
-  };
-}

package/src/approvals/headless/fixtures.ts

@@ -1,86 +0,0 @@
-/**
- * Demo approvals for docs, galleries and tests: a shell command, a one-hunk
- * edit, a multi-hunk edit with a hunk the resolver could not find, and a
- * safelist.
- */
-import type { ApprovalRequest, SafelistProject } from './host';
-
-/** A shell command waiting for approval, with its working directory and timeout. */
-export const DEMO_SHELL_APPROVAL: ApprovalRequest = {
-  id: 'demo-shell',
-  sessionId: 'demo',
-  cwd: '/work/api',
-  tool: 'shell',
-  input: { command: 'git push --force-with-lease origin main', cwd: '/work/api', timeout: 30000 },
-  suggestedSafelistEntries: ['shell:git:*'],
-};
-
-/** A one-hunk `edit`, with its resolved preview. */
-export const DEMO_EDIT_APPROVAL: ApprovalRequest = {
-  id: 'demo-edit',
-  sessionId: 'demo',
-  cwd: '/work/api',
-  tool: 'edit',
-  input: { file_path: 'src/limits.ts', old_string: 'const MAX = 10', new_string: 'const MAX = 50' },
-  suggestedSafelistEntries: ['edit'],
-  edit: {
-    tool: 'edit',
-    path: 'src/limits.ts',
-    hunks: [
-      { oldString: 'const MAX = 10\nconst WINDOW_MS = 1000', newString: 'const MAX = 50\nconst WINDOW_MS = 60_000' },
-    ],
-  },
-  preview: {
-    diffText: '',
-    perHunkDiff: [''],
-    resolution: [{ resolved: true, via: 'exact', occurrences: 1 }],
-    resolvedPayload: {
-      tool: 'edit',
-      path: 'src/limits.ts',
-      hunks: [
-        { oldString: 'const MAX = 10\nconst WINDOW_MS = 1000', newString: 'const MAX = 50\nconst WINDOW_MS = 60_000' },
-      ],
-    },
-  },
-};
-
-const MULTI_HUNKS = [
-  { oldString: "import { log } from './log'", newString: "import { log, warn } from './log'" },
-  { oldString: "  log('retrying')", newString: "  warn('retrying', { attempt })" },
-  { oldString: '  return null', newString: '  throw new RetryError(attempt)', replaceAll: true },
-];
-
-/** A three-hunk `multi_edit` from a subagent: one hunk matched a close variant, one is not in the file. */
-export const DEMO_MULTI_EDIT_APPROVAL: ApprovalRequest = {
-  id: 'demo-multi-edit',
-  sessionId: 'demo',
-  cwd: '/work/api',
-  tool: 'multi_edit',
-  input: { file_path: 'src/retry.ts', edits: [] },
-  suggestedSafelistEntries: ['multi_edit'],
-  originator: { kind: 'child', label: 'child-2' },
-  edit: { tool: 'multi_edit', path: 'src/retry.ts', hunks: MULTI_HUNKS },
-  preview: {
-    diffText: '',
-    perHunkDiff: ['', '', ''],
-    resolution: [
-      { resolved: true, via: 'exact', occurrences: 1 },
-      { resolved: true, via: 'quotes', occurrences: 1 },
-      { resolved: false, occurrences: 0 },
-    ],
-    resolvedPayload: { tool: 'multi_edit', path: 'src/retry.ts', hunks: MULTI_HUNKS },
-  },
-};
-
-/** The demo approvals, oldest first. */
-export const DEMO_APPROVALS: readonly ApprovalRequest[] = [
-  DEMO_SHELL_APPROVAL,
-  DEMO_EDIT_APPROVAL,
-  DEMO_MULTI_EDIT_APPROVAL,
-];
-
-/** A demo safelist: two projects. */
-export const DEMO_SAFELIST: readonly SafelistProject[] = [
-  { project: '/work/api', entries: ['shell:git:*', 'shell:bun:test', 'fetch_url'] },
-  { project: '/work/site', entries: ['shell:npm:run:*'] },
-];

package/src/approvals/headless/heads.ts

@@ -1,81 +0,0 @@
-/**
- * Each session's first pending approval, as its own store: a sidebar row or a
- * status dot re-renders only when ITS session's head changes, never when an
- * approval lands in another session.
- */
-import type { Readable } from '../../chat/headless/store';
-import type { ApprovalRequest } from './host';
-
-/** Per-session heads of a pending queue. */
-export interface ApprovalHeads {
-  /** The first pending approval of `sessionId` (same reference while it stays the head), or `null`. */
-  get(sessionId: string | null): ApprovalRequest | null;
-  /** Calls `onChange` when the head of `sessionId` changes. Returns the unsubscribe. A `null` session never changes. */
-  subscribe(sessionId: string | null, onChange: () => void): () => void;
-}
-
-/**
- * Indexes a pending queue by session: the first request of each session (first arrival wins).
- * It listens to the queue only while a session has a subscriber; a read without one indexes the
- * queue as it is.
- *
- * @param pending - The pending approvals, oldest first.
- */
-export function createApprovalHeads(pending: Readable<readonly ApprovalRequest[]>): ApprovalHeads {
-  const heads = new Map<string, ApprovalRequest>();
-  const listeners = new Map<string, Set<() => void>>();
-  let indexed: readonly ApprovalRequest[] | null = null;
-  let off: (() => void) | null = null;
-  let count = 0;
-
-  /** Re-indexes when the queue changed; returns the sessions whose head changed. */
-  const sync = (): Set<string> => {
-    const queue = pending.get();
-    const touched = new Set<string>();
-    if (queue === indexed) return touched;
-    indexed = queue;
-    const next = new Map<string, ApprovalRequest>();
-    for (const entry of queue) if (!next.has(entry.sessionId)) next.set(entry.sessionId, entry);
-    for (const [sessionId, head] of next) if (heads.get(sessionId) !== head) touched.add(sessionId);
-    for (const sessionId of heads.keys()) if (!next.has(sessionId)) touched.add(sessionId);
-    heads.clear();
-    for (const [sessionId, head] of next) heads.set(sessionId, head);
-    return touched;
-  };
-
-  const onQueue = () => {
-    for (const sessionId of sync()) for (const fn of [...(listeners.get(sessionId) ?? [])]) fn();
-  };
-
-  return {
-    get(sessionId) {
-      if (!sessionId) return null;
-      if (!off) sync();
-      return heads.get(sessionId) ?? null;
-    },
-    subscribe(sessionId, onChange) {
-      if (!sessionId) return () => undefined;
-      let set = listeners.get(sessionId);
-      if (!set) listeners.set(sessionId, (set = new Set()));
-      set.add(onChange);
-      count += 1;
-      if (!off) {
-        sync();
-        off = pending.subscribe(onQueue);
-      }
-      let live = true;
-      return () => {
-        if (!live) return;
-        live = false;
-        const current = listeners.get(sessionId);
-        current?.delete(onChange);
-        if (current?.size === 0) listeners.delete(sessionId);
-        count -= 1;
-        if (count === 0 && off) {
-          off();
-          off = null;
-        }
-      };
-    },
-  };
-}

package/src/approvals/headless/host.ts

@@ -1,80 +0,0 @@
-/**
- * The contract between the approval components and an app, as `ChatHost` is
- * for the chat: the tool calls waiting for the user's decision (safe mode),
- * the decisions, and the "Always allow" entries the user granted.
- *
- * The desktop app implements it over IPC, `createServerApprovalsHost`
- * (`zidane-ui/adapters`) over zidane-server, `createFixtureApprovalsHost`
- * (`zidane-ui/approvals/testing`) in memory.
- *
- * If the host leaves out a member, its UI does not show. Without `resolve`,
- * the approval card shows the request without its buttons. Without
- * `safelist`, there is no safelist panel to open.
- */
-import type { ApprovalDecision, WireApprovalRequest } from 'zidane/chat';
-
-import type { Readable } from '../../chat/headless/store';
-
-/** A decision on an approval: allow once, for the session, always (safelist), deny, or a subset of an edit's hunks. */
-export type { ApprovalDecision };
-
-/**
- * A tool call waiting for the user's decision: the tool and its input, the session that raised
- * it, the safelist entries "Always allow" adds, and for edit tools the edit and its diff preview.
- */
-export type ApprovalRequest = WireApprovalRequest;
-
-/** What went wrong, for the UI to word through its labels. `detail` is the backend's own message. */
-export interface ApprovalsError {
-  /** `read`: listing failed. `revoke`: removing a safelist entry failed. */
-  kind: 'read' | 'revoke';
-  /** The backend's message, shown as is by the default labels. */
-  detail: string;
-}
-
-/** The "Always allow" entries of one project. */
-export interface SafelistProject {
-  /** The project the entries apply to (its root folder). */
-  project: string;
-  /** The entries, as zidane stores them (`shell:git:*`, `fetch_url`…). */
-  entries: readonly string[];
-}
-
-/** Where the safelist is: not read yet, being read, read, or failed. */
-export interface SafelistState {
-  /** `idle` before the first read; `loading` while a read is in flight; `ready` or `error` after. */
-  status: 'idle' | 'loading' | 'ready' | 'error';
-  /** The projects from the last read that succeeded, `null` until one did. */
-  projects: readonly SafelistProject[] | null;
-  /** Why the last read failed, `null` when it did not. */
-  error: ApprovalsError | null;
-}
-
-/** The safelist: what the user allowed with "Always allow", and revoking an entry. */
-export interface ApprovalsSafelist {
-  /** The safelist as last read. */
-  state: Readable<SafelistState>;
-  /** Reads the safelist again. Never rejects: a failure lands in `state.error`. */
-  refresh(): Promise<void>;
-  /** Removes one entry, then reads the safelist again. Rejects with an {@link ApprovalsError}. Absent: the list is read-only. */
-  remove?(project: string, entry: string): Promise<void>;
-}
-
-/** What the approval components read and the decisions they send. */
-export interface ApprovalsHost {
-  /**
-   * The approvals waiting for a decision, oldest first. The host keeps it current: new requests,
-   * requests answered elsewhere (another window, a terminal), and a re-read after a reconnect.
-   * The host starts listening when the store gets its first subscriber.
-   */
-  pending: Readable<readonly ApprovalRequest[]>;
-  /**
-   * Answers a pending approval. The request leaves `pending` at once; an id that is not pending
-   * does nothing. Absent: the host can show approvals but not answer them.
-   */
-  resolve?(requestId: string, decision: ApprovalDecision): Promise<void>;
-  /** Denies every pending approval, or only those of `sessionId`. Absent: no bulk deny. */
-  denyAll?(sessionId?: string): Promise<void>;
-  /** The "Always allow" entries. Absent: no safelist panel. */
-  safelist?: ApprovalsSafelist;
-}

package/src/approvals/headless/index.ts

@@ -1,12 +0,0 @@
-/**
- * `zidane-ui/approvals/headless`: the React-free half of the approvals area.
- * The `ApprovalsHost` seam, the pending queue every host keeps
- * (`createPendingApprovals`), the per-session heads, the safelist store,
- * the preview helpers and the labels.
- */
-export * from './host';
-export * from './pending';
-export * from './heads';
-export * from './safelist';
-export * from './preview';
-export * from './labels';

package/src/approvals/headless/labels.ts

@@ -1,67 +0,0 @@
-/**
- * The approval components' strings. One flat dictionary, every key prefixed
- * (`approval…`, `hunk…`, `safelist…`) so it shares a `<LabelsProvider>`
- * with the other areas' keys; the headless helpers take it as an argument.
- */
-import type { ModelApproval } from 'zidane/chat';
-import { modelConcern } from 'zidane/chat/pure';
-
-import type { ApprovalsError } from './host';
-
-/** The default English strings of the approval components. Override any of them through `ApprovalsProvider` or `LabelsProvider`. */
-export const DEFAULT_APPROVALS_LABELS = {
-  /** Before the tool name in the inline card's title: "Allow Zidane to run `shell`?". */
-  approvalRunBefore: 'Allow Zidane to run',
-  /** After the tool name in the inline card's title. */
-  approvalRunAfter: '?',
-  approvalDeny: 'Deny',
-  approvalAlwaysAllow: 'Always allow',
-  approvalAllowOnce: 'Allow once',
-  approvalAllowForSession: 'Allow for session',
-  approvalAllow: 'Allow',
-  approvalAllowNoneSelected: 'Allow (none selected)',
-  approvalApplySelected: (selected: number, total: number) => `Apply selected (${selected} of ${total})`,
-  approvalCwd: (cwd: string) => `cwd ${cwd}`,
-  approvalTimeout: (timeout: string) => `timeout ${timeout}`,
-  /** What worried the decision model when it handed the call to the user. */
-  approvalConcern: (concern: ModelApproval) => modelConcern(concern),
-  approvalFileEditTitle: (tool: string, path: string | null) => `Allow Zidane to ${tool}${path ? ` ${path}` : ''}?`,
-  approvalFileEditReview: 'Review the change before you allow it.',
-  approvalFileEditNoPath: 'No file path given. Check the input below.',
-  approvalFromSubagent: (label: string) => `From subagent ${label}`,
-  approvalClose: 'Close',
-  hunksOf: 'of',
-  hunksSelected: 'hunks selected',
-  hunksSelectAll: 'Select all',
-  hunksClear: 'Clear',
-  hunksSomeMissing: 'Some hunks are not in the file',
-  hunkInclude: (index: number, total: number) => `Include hunk ${index} of ${total}`,
-  hunkTitle: (index: number, total: number) => `Hunk ${index}/${total}`,
-  hunkReplaceAll: 'replace all',
-  hunkAmbiguous: (matches: number) => `ambiguous (${matches} matches)`,
-  hunkAmbiguousHint: (matches: number) =>
-    `The old_string matches ${matches} places in the file. The edit needs replace_all or a unique snippet.`,
-  hunkNotInFile: 'not in file',
-  hunkNotInFileHint:
-    'The old_string is not in the file. The file may have changed since the model read it. If you allow this hunk, it fails.',
-  hunkVia: (via: string) => `via ${via}`,
-  hunkViaHint: (via: string) => `The exact old_string is not in the file. A close variant matched (${via}).`,
-  hunkFile: '(file)',
-  hunkNewFile: 'new file',
-  hunkAdded: (count: number) => `+${count}`,
-  hunkRemoved: (count: number) => `−${count}`,
-  safelistTitle: 'Safelisted commands',
-  safelistDescription: 'Commands you allowed with "Always allow". If you revoke one, Zidane asks again next time.',
-  safelistLoading: 'Loading…',
-  safelistEmpty: 'No safelisted commands yet',
-  safelistEmptyHint: 'Click "Always allow" on an approval to add one.',
-  safelistProject: 'Project',
-  safelistCount: (count: number) => `(${count})`,
-  safelistRevoke: 'Revoke',
-  safelistRevoking: 'Revoking…',
-  /** A failed read or revoke. The default shows the backend's message. */
-  approvalsError: (error: ApprovalsError) => error.detail,
-};
-
-/** The approval components' strings: the shape of {@link DEFAULT_APPROVALS_LABELS}. */
-export type ApprovalsLabels = typeof DEFAULT_APPROVALS_LABELS;

package/src/approvals/headless/pending.ts

@@ -1,91 +0,0 @@
-/**
- * The pending-approvals queue every host keeps the same way: new requests
- * appended once (by id), requests answered elsewhere dropped without an
- * answer, a re-read after a (re)connect merged in, and a decision taking the
- * request out at once (optimistic, so a second click is a no-op).
- *
- * It listens to its backend only while someone reads it: `connect` runs on
- * the first subscriber and its cleanup on the last unsubscribe.
- */
-import { writable, type Readable } from '../../chat/headless/store';
-import type { ApprovalRequest } from './host';
-
-/** What a backend does to the queue: what `connect` receives. */
-export interface PendingApprovalsSink {
-  /** Appends a request, unless one with its id is already pending. */
-  add(request: ApprovalRequest): void;
-  /** Drops a request answered elsewhere. Unknown ids do nothing. */
-  drop(requestId: string): void;
-  /** Appends the requests of a re-read that are not pending yet (a re-read never removes). */
-  merge(requests: readonly ApprovalRequest[]): void;
-}
-
-/** The queue: a readable list, what a backend does to it, and taking requests out to answer them. */
-export interface PendingApprovals extends Readable<readonly ApprovalRequest[]>, PendingApprovalsSink {
-  /** Takes a request out to answer it. `undefined` when it is not pending. */
-  take(requestId: string): ApprovalRequest | undefined;
-  /** Takes out every pending request, or those of `sessionId`, to deny them. */
-  takeAll(sessionId?: string): ApprovalRequest[];
-}
-
-/**
- * Creates a pending-approvals queue.
- *
- * @param connect - Starts listening to the backend with the queue's sink; returns how to stop. Runs while the queue has subscribers.
- */
-export function createPendingApprovals(connect?: (sink: PendingApprovalsSink) => () => void): PendingApprovals {
-  const list = writable<readonly ApprovalRequest[]>([]);
-  let subscribers = 0;
-  let stop: (() => void) | null = null;
-
-  const without = (keep: (r: ApprovalRequest) => boolean) => {
-    const prev = list.get();
-    const next = prev.filter(keep);
-    if (next.length !== prev.length) list.set(next);
-    return prev.filter((r) => !keep(r));
-  };
-
-  const sink: PendingApprovalsSink = {
-    add(request) {
-      list.set((prev) => (prev.some((r) => r.id === request.id) ? prev : [...prev, request]));
-    },
-    drop(requestId) {
-      without((r) => r.id !== requestId);
-    },
-    merge(requests) {
-      list.set((prev) => {
-        const seen = new Set(prev.map((r) => r.id));
-        const additions = requests.filter((r) => !seen.has(r.id));
-        return additions.length === 0 ? prev : [...prev, ...additions];
-      });
-    },
-  };
-
-  return {
-    ...sink,
-    get: list.get,
-    subscribe(onChange) {
-      const off = list.subscribe(onChange);
-      subscribers += 1;
-      if (subscribers === 1 && connect) stop = connect(sink);
-      let live = true;
-      return () => {
-        if (!live) return;
-        live = false;
-        off();
-        subscribers -= 1;
-        if (subscribers === 0 && stop) {
-          const done = stop;
-          stop = null;
-          done();
-        }
-      };
-    },
-    take(requestId) {
-      return without((r) => r.id !== requestId)[0];
-    },
-    takeAll(sessionId) {
-      return without((r) => sessionId !== undefined && r.sessionId !== sessionId);
-    },
-  };
-}