zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/composer/remember-model-pick.ts

@@ -1,132 +0,0 @@
-/**
- * What of a model pick an app remembers as its default (the next new chat's
- * model, the prefs' `lastModelChain` the TUI launches with too): the rule the
- * TUI applies (`rememberableChain` in `zidane/chat/pure`), with "this
- * computer can run it" = a provider this computer is signed in to.
- */
-import { rememberableChain as rememberable } from 'zidane/chat/pure';
-
-import type { ResourceSnapshot } from '../../../app/headless/resource';
-import type { Readable } from '../store';
-import type { ComposerControls, ComposerModels, ComposerPrefs, ComposerRememberedModel } from './host-chrome';
-import type { ModelPickRef } from './models';
-
-/**
- * The chain to remember, `null` for nothing (no primary, or a primary only the server runs).
- *
- * @param chain - The picked chain.
- * @param scope - Whether it was picked on a server, and the providers this computer can run.
- */
-export function rememberableChain(
-  chain: readonly ModelPickRef[],
-  scope: { onServer: boolean; localProviders: ReadonlySet<string> },
-): ModelPickRef[] | null {
-  const kept = rememberable(chain, (entry) => entry.providerKey, {
-    onServer: scope.onServer,
-    canRunHere: (key) => scope.localProviders.has(key),
-  });
-  // A server's account ids name ITS credentials: here they would pin nothing (or the wrong account).
-  return kept && scope.onServer ? kept.map(({ account: _account, ...entry }) => entry) : kept;
-}
-
-/**
- * The first settled value of a resource (subscribing starts its read).
- *
- * @param resource - The resource.
- */
-export function settledResource<T>(resource: Readable<ResourceSnapshot<T>>): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let off: (() => void) | null = null;
-    let done = false;
-    const check = () => {
-      const snap = resource.get();
-      if (done) return;
-      if (snap.status === 'success' && snap.data !== undefined) {
-        done = true;
-        resolve(snap.data);
-      } else if (snap.status === 'error') {
-        done = true;
-        reject(snap.error instanceof Error ? snap.error : new Error(String(snap.error)));
-      } else return;
-      off?.();
-    };
-    off = resource.subscribe(check);
-    check();
-    if (done) off();
-  });
-}
-
-/**
- * {@link rememberableChain} for a pick made on `hostId` (a server, or `null` for this computer).
- *
- * @param chain - The picked chain.
- * @param hostId - Where it was picked.
- * @param models - This computer's catalog, to tell which providers it runs.
- */
-export async function rememberedPick(
-  chain: readonly ModelPickRef[],
-  hostId: string | null | undefined,
-  models: ComposerModels | undefined,
-): Promise<ModelPickRef[] | null> {
-  if (!hostId) return rememberableChain(chain, { onServer: false, localProviders: new Set() });
-  let localProviders = new Set<string>();
-  try {
-    if (models) {
-      const catalog = await settledResource(models.catalog(undefined, null));
-      localProviders = new Set(catalog.map((entry) => entry.providerKey));
-    }
-  } catch {
-    // This computer's providers unknown: remember nothing rather than a pick it may not run.
-  }
-  return rememberableChain(chain, { onServer: true, localProviders });
-}
-
-/**
- * The prefs' `lastModelChain` entries for a chain (core `ModelChainEntry` shape, account included).
- *
- * @param chain - The chain.
- */
-export function lastModelChainOf(chain: readonly ModelPickRef[]): ComposerRememberedModel[] {
-  return chain.map((e) => ({
-    provider: e.providerKey,
-    model: e.modelId,
-    ...(e.account ? { account: e.account } : {}),
-  }));
-}
-
-/** Sets the app's default model (the next new chat's); `persist: false` holds it for this window only. */
-export type SetDefaultModel = (pick: ModelPickRef, opts?: { persist?: boolean }) => void;
-
-/**
- * Commits a picked chain, the ONE path every model picker takes: the
- * session's model (when there is one), then the app's default (the next
- * chat's model and `lastModelChain`) when this computer can run it. A draft
- * whose pick only a server can run still launches under it: held for this
- * window, not remembered. `remember: false` (a side chat's pick) only sets
- * the session's model.
- *
- * @param host - The host's `controls`, `models` and `prefs`.
- * @param target - The session (`null`: a draft) and the host it runs on.
- * @param chain - The picked chain, primary first.
- * @param setDefaultModel - Sets the app's default model.
- * @param options - `remember: false` to leave the default alone.
- */
-export async function commitModelPick(
-  host: { controls?: ComposerControls; models?: ComposerModels; prefs?: ComposerPrefs },
-  target: { sessionId: string | null; hostId: string | null | undefined },
-  chain: readonly ModelPickRef[],
-  setDefaultModel: SetDefaultModel,
-  { remember = true }: { remember?: boolean } = {},
-): Promise<void> {
-  const primary = chain[0];
-  if (!primary) return;
-  if (target.sessionId) await host.controls?.setModel?.(target.sessionId, primary, chain.slice(1));
-  if (!remember) return;
-  const remembered = await rememberedPick(chain, target.hostId, host.models);
-  if (remembered?.[0]) {
-    setDefaultModel(remembered[0]);
-    await host.prefs?.set({ lastModelChain: lastModelChainOf(remembered) });
-  } else if (!target.sessionId) {
-    setDefaultModel(primary, { persist: false });
-  }
-}

package/src/chat/headless/composer/run-meter.ts

@@ -1,228 +0,0 @@
-/**
- * Per-session counters of the current run, for the composer's run chip and
- * the cost pill: when it started, the output tokens of its settled parent
- * turns, the cost of turns settled since the last cost read, and the
- * streaming turn's live counters (`stream:progress`).
- *
- * Kept per session, outside React, from every session's stream signals
- * (`handle`): an app keeps one for the window's life, so switching
- * conversations never resets them. The live counters tick about 4 times a
- * second, so only the pills read them.
- */
-import type { Readable } from '../store';
-import type { LiveStreamProgress } from './live-cost';
-
-/** One session's run counters. */
-export interface RunMeterState {
-  /**
-   * When the run began: the host's `run:start` stamp, else its saved run
-   * record (a session row's `runStartedAt`, or the read of a run this window
-   * joined mid-way), else when this window first saw it (an older host, which
-   * sends neither).
-   */
-  startedAt: number | null;
-  /** Where `startedAt` came from: the host's own signal wins, the run's record corrects a first sighting. */
-  startedFrom: 'host' | 'record' | 'seen' | null;
-  /**
-   * Output tokens of the run's settled parent turns: the host's count from
-   * each `turn:end` (`runOutputTokens`) or the joined run's read, summed
-   * here only for an older host.
-   */
-  outputTokens: number;
-  /** Σ `turn:end` usage cost since the last cost read that settled it (`settleCost`). */
-  accruedCost: number;
-  /**
-   * Bumped at each run's start and end: a read issued during one run must
-   * not land on the next state (settle a newer run's accrual, seed a run
-   * that has ended).
-   */
-  generation: number;
-  /** The streaming parent turn's live counters, `null` between turns. */
-  progress: LiveStreamProgress | null;
-}
-
-/** The counters of a session with no run seen. */
-export const EMPTY_RUN_METER: RunMeterState = Object.freeze({
-  startedAt: null,
-  startedFrom: null,
-  outputTokens: 0,
-  accruedCost: 0,
-  generation: 0,
-  progress: null,
-});
-
-/** The stream signals the meter follows (the host's `HostSignal` variants, structurally). */
-export type RunMeterSignal =
-  | { kind: 'run:start'; sessionId: string; startedAt?: number }
-  | {
-      kind: 'stream:progress';
-      sessionId: string;
-      turnId: string;
-      outputTokens: number;
-      estimated: boolean;
-      elapsedMs: number;
-      estCostUsd?: number;
-    }
-  | {
-      kind: 'turn:end';
-      sessionId: string;
-      childId?: string;
-      usage?: { output?: number; cost?: number };
-      runOutputTokens?: number;
-    }
-  | { kind: 'run:end'; sessionId: string };
-
-/** A session row's word on its run (the session list's `runStartedAt`). */
-export interface RunMeterRow {
-  /** The session. */
-  id: string;
-  /** Its status (`running` counts). */
-  status: string;
-  /** When its run began (epoch ms). */
-  runStartedAt?: number;
-}
-
-/** The run counters of every session. */
-export interface RunMeter {
-  /** Follows one stream signal. Other kinds are ignored. */
-  handle(signal: { kind: string; sessionId?: string }): void;
-  /** Drops a deleted session's counters. */
-  forget(sessionId: string): void;
-  /** A session's counters as a store (one per session, the same each call). */
-  session(sessionId: string): Readable<RunMeterState>;
-  /** A session's counters now. */
-  get(sessionId: string): RunMeterState;
-  /** A running run with no start known yet counts from now. */
-  noteSeen(sessionId: string): void;
-  /** The session list's run starts: a window that missed a `run:start` times the run from its real start. */
-  noteStarts(rows: readonly RunMeterRow[]): void;
-  /** A run this window joined midway, as its host counts it; dropped when the run changed while it was read. */
-  noteProgress(sessionId: string, generation: number, progress: { startedAt: number; outputTokens: number }): void;
-  /** The session's run generation, to hand back to `settleCost` / `noteProgress`. */
-  generation(sessionId: string): number;
-  /** A cost read issued while idle settled every turn: zero the accrual, unless a newer run started since. */
-  settleCost(sessionId: string, generation: number): void;
-}
-
-/**
- * Creates an empty {@link RunMeter}.
- *
- * @param now - The clock (epoch ms), for runs whose start the host does not stamp.
- */
-export function createRunMeter(now: () => number = () => Date.now()): RunMeter {
-  const meters = new Map<string, RunMeterState>();
-  const listeners = new Map<string, Set<() => void>>();
-  const stores = new Map<string, Readable<RunMeterState>>();
-
-  const get = (sessionId: string): RunMeterState => meters.get(sessionId) ?? EMPTY_RUN_METER;
-  const notify = (sessionId: string) => {
-    for (const listener of listeners.get(sessionId) ?? []) listener();
-  };
-  const update = (sessionId: string, patch: Partial<RunMeterState>): void => {
-    const prev = get(sessionId);
-    const next = { ...prev, ...patch };
-    if ((Object.keys(patch) as (keyof RunMeterState)[]).every((k) => prev[k] === next[k])) return;
-    meters.set(sessionId, next);
-    notify(sessionId);
-  };
-  const subscribe = (sessionId: string, listener: () => void): (() => void) => {
-    let set = listeners.get(sessionId);
-    if (!set) {
-      set = new Set();
-      listeners.set(sessionId, set);
-    }
-    set.add(listener);
-    return () => {
-      set.delete(listener);
-      if (set.size === 0 && listeners.get(sessionId) === set) listeners.delete(sessionId);
-    };
-  };
-
-  const handle = (raw: { kind: string; sessionId?: string }): void => {
-    if (typeof raw.sessionId !== 'string') return;
-    const signal = raw as RunMeterSignal;
-    const id = signal.sessionId;
-    const meter = get(id);
-    switch (signal.kind) {
-      case 'run:start':
-        update(id, {
-          startedAt: signal.startedAt ?? now(),
-          startedFrom: signal.startedAt !== undefined ? 'host' : 'seen',
-          outputTokens: 0,
-          // The previous run's turns are in `run.cost` now; this run accrues from zero.
-          accruedCost: 0,
-          generation: meter.generation + 1,
-          progress: null,
-        });
-        return;
-      case 'stream:progress':
-        update(id, {
-          progress: {
-            turnId: signal.turnId,
-            outputTokens: signal.outputTokens,
-            estimated: signal.estimated,
-            elapsedMs: signal.elapsedMs,
-            ...(signal.estCostUsd !== undefined ? { estCostUsd: signal.estCostUsd } : {}),
-          },
-        });
-        return;
-      case 'turn:end': {
-        const parent = signal.childId === undefined;
-        // The host's count as is: one this window seeded mid-run never takes a turn twice.
-        const outputTokens = signal.runOutputTokens ?? meter.outputTokens + (signal.usage?.output ?? 0);
-        update(id, {
-          ...(parent ? { progress: null, outputTokens } : {}),
-          accruedCost: meter.accruedCost + (signal.usage?.cost ?? 0),
-        });
-        return;
-      }
-      case 'run:end':
-        update(id, { progress: null, startedAt: null, startedFrom: null, generation: meter.generation + 1 });
-        return;
-      default:
-    }
-  };
-
-  return {
-    handle,
-    forget(sessionId) {
-      stores.delete(sessionId);
-      if (meters.delete(sessionId)) notify(sessionId);
-    },
-    session(sessionId) {
-      let store = stores.get(sessionId);
-      if (!store) {
-        store = { get: () => get(sessionId), subscribe: (listener) => subscribe(sessionId, listener) };
-        stores.set(sessionId, store);
-      }
-      return store;
-    },
-    get,
-    noteSeen(sessionId) {
-      if (get(sessionId).startedAt === null) update(sessionId, { startedAt: now(), startedFrom: 'seen' });
-    },
-    noteStarts(rows) {
-      for (const row of rows) {
-        if (row.status !== 'running' || row.runStartedAt === undefined) continue;
-        const meter = get(row.id);
-        // The host's own `run:start` stamp stays: a row can be older than it.
-        if (meter.startedFrom !== 'host' && meter.startedAt !== row.runStartedAt) {
-          update(row.id, { startedAt: row.runStartedAt, startedFrom: 'record' });
-        }
-      }
-    },
-    noteProgress(sessionId, generation, progress) {
-      const meter = get(sessionId);
-      if (meter.generation !== generation) return;
-      update(sessionId, {
-        ...(meter.startedFrom !== 'host' ? { startedAt: progress.startedAt, startedFrom: 'record' as const } : {}),
-        // Never back: a `turn:end` that came meanwhile carries a newer count.
-        outputTokens: Math.max(meter.outputTokens, progress.outputTokens),
-      });
-    },
-    generation: (sessionId) => get(sessionId).generation,
-    settleCost(sessionId, generation) {
-      if (get(sessionId).generation === generation) update(sessionId, { accruedCost: 0 });
-    },
-  };
-}

package/src/chat/headless/composer-modes.ts

@@ -1,170 +0,0 @@
-/**
- * Composer prompt modes — pure state-machine helpers for the `!` (shell)
- * and `?` (transcript search) sentinels, mirroring the TUI's grammar
- * (src/tui/prompt/ `useSyncBuffer` / `usePromptKeyDown`):
- *
- *   - Entry: the sentinel must be TYPED as the first character of an
- *     empty composer (exactly-one-char transition — pasted/recalled
- *     `!cmd` stays literal text). The sentinel is consumed; it never
- *     enters the buffer.
- *   - Exit: Backspace with the caret at offset 0 leaves the mode
- *     (search also exits on Delete-at-0 and on Esc; shell does NOT
- *     exit on Esc — TUI parity).
- *   - Submit (shell): the bang is re-attached (`!cmd`) so the host
- *     routing and prompt history keep the TUI's on-disk grammar; a
- *     blank command is a no-op.
- *   - History: `!`-prefixed entries recall INTO shell mode with the
- *     bang stripped; stashing a shell-mode draft re-encodes the bang.
- *
- * Kept free of TipTap/React so the grammar is unit-testable.
- */
-
-export type ComposerMode = 'normal' | 'shell' | 'search';
-
-/**
- * Mode entered by typing `char` into the composer, or `null` when the
- * keystroke should be handled as ordinary input. Requires an empty
- * buffer and no active mode — matches the TUI's exactly-`!` /
- * exactly-`?` on `lastSynced === ''` checks (`useSyncBuffer`,
- * src/tui/prompt/use-sync-buffer.ts).
- *
- * @param char - The character just typed.
- * @param mode - The composer's mode now.
- * @param bufferEmpty - Whether the composer was empty before it.
- */
-export function modeForTypedChar(char: string, mode: ComposerMode, bufferEmpty: boolean): ComposerMode | null {
-  if (mode !== 'normal' || !bufferEmpty) {
-    return null;
-  }
-
-  if (char === '!') {
-    return 'shell';
-  }
-
-  if (char === '?') {
-    return 'search';
-  }
-
-  return null;
-}
-
-/**
- * Is the caret effectively at the buffer start for the mode-exit check?
- *
- * The obvious answer (`selection.empty && from === atStart`) misses a
- * ProseMirror trap: Cmd/Ctrl+A creates an `AllSelection`, and deleting
- * it leaves that SAME AllSelection spanning the now-empty doc — `empty`
- * stays `false`, `from` stays `0` — until a click or a typed character
- * replaces it. Without the empty-doc escape hatch, Backspace after a
- * select-all-clear can never exit shell mode (Esc doesn't exit it
- * either), so the mode — and its ghost-autocomplete suppression — stick
- * for the rest of the draft.
- *
- * A Backspace on an empty doc is a no-op edit whatever the selection
- * shape — exactly the TUI's "backspace at offset 0" exit trigger
- * (`handleShellExitKey`, src/tui/prompt/prompt-key-handlers.ts).
- *
- * @param selection - The editor's selection: where the caret is and whether it spans text.
- * @param atStartPos - The document position of the start of the text.
- * @param docEmpty - Whether the document holds no text.
- */
-export function caretEffectivelyAtStart(
-  selection: { empty: boolean; from: number },
-  atStartPos: number,
-  docEmpty: boolean,
-): boolean {
-  if (selection.empty) {
-    return selection.from === atStartPos;
-  }
-
-  return docEmpty;
-}
-
-/**
- * Whether `key` (a DOM `KeyboardEvent.key`) exits the active mode.
- * `caretAtStart` = collapsed selection at buffer offset 0.
- *
- *   - shell: Backspace-at-0 only (`handleShellExitKey`) — Esc stays free
- *     for its global meaning (stop run).
- *   - search: Backspace/Delete-at-0 (`isTranscriptSearchExitKey`,
- *     src/tui/prompt/prompt-key-handlers.ts) or Esc (`usePromptModes`,
- *     src/tui/prompt/use-prompt-modes.ts).
- *
- * @param mode - The composer's mode now.
- * @param key - The key pressed (`KeyboardEvent.key`).
- * @param caretAtStart - Whether the caret is at the start of the text.
- */
-export function exitsModeOnKey(mode: ComposerMode, key: string, caretAtStart: boolean): boolean {
-  if (mode === 'shell') {
-    return key === 'Backspace' && caretAtStart;
-  }
-
-  if (mode === 'search') {
-    return key === 'Escape' || ((key === 'Backspace' || key === 'Delete') && caretAtStart);
-  }
-
-  return false;
-}
-
-/**
- * Final submit text for the active mode, or `null` when the submit is
- * a no-op. Shell re-attaches the consumed bang (TUI `submit` in
- * src/tui/prompt/use-composer-actions.ts);
- * a blank shell command never submits, even with attachments staged.
- * Search mode never submits — Enter navigates matches instead.
- *
- * @param mode - The composer's mode.
- * @param text - The composer's text.
- */
-export function composeSubmitText(mode: ComposerMode, text: string): string | null {
-  if (mode === 'search') {
-    return null;
-  }
-
-  if (mode === 'shell') {
-    const command = text.trim();
-
-    return command.length > 0 ? `!${command}` : null;
-  }
-
-  return text;
-}
-
-/**
- * A submit that was not sent (its chat could not be created) back as the
- * draft it came from: the box is cleared on Enter, so a failure must not
- * lose what was typed. The inverse of {@link composeSubmitText}.
- *
- * @param submitted - The text the composer submitted (a `!` command keeps its sentinel).
- */
-export function unsentDraft(submitted: string): { text: string; shell: boolean } {
-  return submitted.startsWith('!') ? { text: submitted.slice(1), shell: true } : { text: submitted, shell: false };
-}
-
-/**
- * Encode the in-progress draft for the prompt-history stash so a
- * shell-mode draft survives the cycle round trip with its bang
- * (`usePromptHistory`, src/tui/prompt/use-prompt-history.ts). Search-mode drafts are never stashed (history
- * cycling is disabled in search mode).
- *
- * @param mode - The composer's mode the entry was sent in.
- * @param text - The text sent.
- */
-export function encodeHistoryDraft(mode: ComposerMode, text: string): string {
-  return mode === 'shell' ? `!${text}` : text;
-}
-
-/**
- * Decode a recalled history entry: `!`-prefixed entries recall INTO
- * shell mode with the bang stripped (`applyRecalledPrompt`,
- * src/tui/prompt/use-prompt-history.ts); everything else recalls as a normal prompt.
- *
- * @param entry - A prompt history entry.
- */
-export function decodeHistoryEntry(entry: string): { mode: 'normal' | 'shell'; text: string } {
-  if (entry.startsWith('!')) {
-    return { mode: 'shell', text: entry.slice(1) };
-  }
-
-  return { mode: 'normal', text: entry };
-}

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

@@ -1,136 +0,0 @@
-/**
- * The new-chat draft's scope: its id, the local folder picked for it and that
- * folder's project root. Only a local folder makes a draft scope (a folderless
- * draft, or one on a server or machine, has none). The id is renewed after
- * each send, and when the draft moves to another project, so what was opened
- * in one draft (its terminals, its layout) never leaks into the next.
- */
-import type { Readable } from './store';
-
-/** The draft's state, as {@link DraftScopeStore} holds it. */
-export interface DraftScopeState {
-  /** The draft's id (what its terminals open under). */
-  id: string;
-  /** The local folder picked for the draft, `null` for none (or not local). */
-  folder: string | null;
-  /** The folder's project root once resolved. */
-  root: string | null;
-}
-
-/** A draft's scope: where its terminals and layout attach. */
-export interface DraftScope {
-  /** The project root. */
-  root: string;
-  /** The folder things open in. */
-  cwd: string;
-  /** The draft's id. */
-  draft: string;
-}
-
-/** What {@link createDraftScopeStore} asks the app. */
-export interface DraftScopeStoreOptions {
-  /** The folder's project root (worktrees fold into their main checkout); `null` when unknown. */
-  projectRoot(folder: string): Promise<string | null>;
-  /** A draft id was replaced: release what was opened under it (its terminals stay with the old project). */
-  release?(draftId: string): void;
-  /** A draft id is never shown again: forget what was kept for it (its layout record). */
-  forget?(draftId: string): void;
-  /** A new draft id. Default: `crypto.randomUUID`, else a time-and-random id. */
-  newId?(): string;
-}
-
-/** The draft's scope, readable (`get` returns the same state until it changes). */
-export interface DraftScopeStore extends Readable<DraftScopeState> {
-  /** The draft's local folder (`null` for folderless, server or machine drafts). */
-  publishFolder(folder: string | null): void;
-  /** A send turned the draft into a session: the next draft starts fresh. */
-  renew(): void;
-  /** The draft's scope, `null` while it has no local folder or its root is still resolving. */
-  scope(): DraftScope | null;
-  /** Back to a fresh draft with nothing cached (tests). */
-  reset(): void;
-}
-
-function randomId(): string {
-  return typeof crypto !== 'undefined' && 'randomUUID' in crypto
-    ? crypto.randomUUID()
-    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-
-/**
- * The scope of a draft state, `null` while it has none.
- *
- * @param state - The draft's state.
- */
-export function draftScopeOf(state: DraftScopeState): DraftScope | null {
-  return state.folder && state.root ? { root: state.root, cwd: state.folder, draft: state.id } : null;
-}
-
-/**
- * Creates the draft's scope store.
- *
- * @param options - How roots resolve and what a replaced id releases.
- */
-export function createDraftScopeStore(options: DraftScopeStoreOptions): DraftScopeStore {
-  const newId = options.newId ?? randomId;
-  const listeners = new Set<() => void>();
-  const roots = new Map<string, string | null>();
-  let draft: DraftScopeState = { id: newId(), folder: null, root: null };
-  /** The project root the current id has been scoped to, `null` before it had one. */
-  let idRoot: string | null = null;
-
-  const forget = (id: string) => options.forget?.(id);
-
-  const set = (input: DraftScopeState) => {
-    let next = input;
-    // Moved to another project: its terminals stay with the old one, under a new id.
-    if (next.id === draft.id && next.root && idRoot && next.root !== idRoot) {
-      const old = draft.id;
-      options.release?.(old);
-      forget(old);
-      next = { ...next, id: newId() };
-    }
-    if (next.root) idRoot = next.root;
-    if (next.id === draft.id && next.folder === draft.folder && next.root === draft.root) return;
-    draft = next;
-    for (const listener of listeners) listener();
-  };
-
-  return {
-    get: () => draft,
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    publishFolder(folder) {
-      if (folder === draft.folder) return;
-      if (!folder) {
-        set({ ...draft, folder: null, root: null });
-        return;
-      }
-      if (roots.has(folder)) {
-        set({ ...draft, folder, root: roots.get(folder) ?? null });
-        return;
-      }
-      set({ ...draft, folder, root: null });
-      void options
-        .projectRoot(folder)
-        .catch(() => null)
-        .then((root) => {
-          roots.set(folder, root);
-          if (draft.folder === folder) set({ ...draft, root });
-        });
-    },
-    renew() {
-      idRoot = null;
-      forget(draft.id);
-      set({ ...draft, id: newId() });
-    },
-    scope: () => draftScopeOf(draft),
-    reset() {
-      draft = { id: newId(), folder: null, root: null };
-      idRoot = null;
-      roots.clear();
-    },
-  };
-}