zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/markdown-chunks.ts

@@ -1,134 +0,0 @@
-/**
- * Split long markdown into independently parseable chunks.
- *
- * A boundary is a blank line followed by a line that starts at column 0,
- * outside a fenced code block: nothing can continue across it (an indented
- * line after a blank could still belong to a list item, a fence spans
- * blanks). What it changes is cosmetic at worst: a loose list becomes two
- * adjacent lists (an ordered one keeps its numbering through `start`).
- *
- * Boundaries only depend on the text before them and the line right after,
- * so while a reply streams every chunk but the last keeps its exact text,
- * and its memoised render.
- *
- * Fences open and close by core's rules (`parseFenceOpen` / `isFenceClose`),
- * so a chunk never ends inside a code block the parse sees as still open.
- */
-import { type FenceOpen, isFenceClose, parseFenceOpen } from 'zidane/chat/pure';
-
-/** Below this, one parse is cheap enough: no chunking at all. */
-export const CHUNK_THRESHOLD = 6000;
-/** A chunk closes at the first boundary past this size. */
-const CHUNK_TARGET = 3000;
-
-/** The fence open after `line`, given the one open before it. */
-function stepFence(fence: FenceOpen | null, line: string): FenceOpen | null {
-  if (fence) return isFenceClose(line, fence.char, fence.length) ? null : fence;
-  return parseFenceOpen(line);
-}
-
-/**
- * While a reply streams it is re-rendered on every delta (many per second),
- * so it splits much finer: everything above the growing paragraph stays a
- * memoised chunk and only the tail is parsed again.
- */
-const STREAMING_THRESHOLD = 1200;
-const STREAMING_TARGET = 600;
-
-/** A last line of one or two backticks or tildes: a fence still arriving. */
-const PARTIAL_FENCE = /\n {0,3}(?:`{1,2}|~{1,2})$/;
-
-/**
- * Holds back a fence still arriving at the end of a streaming reply. Text
- * reveals a few characters a frame, so a closing ```` ``` ```` lands as `` ` ``,
- * then ` `` `: until the third, an open code block shows the partial
- * marker as one more line of code, then drops it, and the reply shrinks by
- * a line under a view following its bottom. A frame later the whole fence
- * is there.
- *
- * @param text - The reply so far.
- */
-export function withoutPartialFence(text: string): string {
-  return text.replace(PARTIAL_FENCE, '\n');
-}
-
-/** A streaming chunk's fence that has not closed yet, apart from the text before it. */
-export interface OpenFence {
-  /** The markdown before the fence (may be empty). */
-  before: string;
-  /** The fence's language, as the parsed block names it (`plaintext` when the info string names none). */
-  language: string;
-  /** The code so far. */
-  code: string;
-}
-
-/**
- * The fence a streaming chunk ends inside, when it opened at column 0 (an
- * indented one may belong to a list item, which only the parse can tell).
- * The open fence is the whole tail of the chunk, so parsing it again on
- * every delta re-parses a growing code block for nothing: the code block can
- * draw the text as is, and the chunk parses normally once the fence closes.
- *
- * @param chunk - The last chunk of a streaming reply.
- * @returns The open fence, or `null` when the chunk does not end inside one.
- */
-export function openFenceOf(chunk: string): OpenFence | null {
-  const lines = chunk.split('\n');
-  let fence: FenceOpen | null = null;
-  let at = -1;
-  for (let i = 0; i < lines.length; i++) {
-    const next = stepFence(fence, lines[i]!);
-    if (next && !fence) at = i;
-    fence = next;
-  }
-  if (fence === null || fence.indent !== 0) return null;
-  const info = lines[at]!.slice(fence.length);
-  // The parse's class is `language-<first word of the info string>`, read back as its leading \w run.
-  const language = /^(\w+)/.exec(info.trim().split(/\s/)[0] ?? '')?.[1] ?? 'plaintext';
-  return {
-    before: lines.slice(0, at).join('\n'),
-    language,
-    code: lines
-      .slice(at + 1)
-      .join('\n')
-      .replace(/\n$/, ''),
-  };
-}
-
-/**
- * Splits markdown into chunks that parse on their own, so a long or streaming reply can re-render only its last chunk. Text shorter than the threshold comes back as one chunk.
- *
- * @param text - The markdown to split.
- * @param opts - Split options. `streaming: true` uses finer chunks for a reply that is still growing.
- */
-export function splitMarkdown(text: string, opts: { streaming?: boolean } = {}): string[] {
-  const threshold = opts.streaming ? STREAMING_THRESHOLD : CHUNK_THRESHOLD;
-  const target = opts.streaming ? STREAMING_TARGET : CHUNK_TARGET;
-  if (text.length < threshold) return [text];
-  const lines = text.split('\n');
-  const chunks: string[] = [];
-  let start = 0;
-  let size = 0;
-  let fence: FenceOpen | null = null;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]!;
-    fence = stepFence(fence, line);
-    size += line.length + 1;
-    const next = lines[i + 1];
-    if (
-      fence === null &&
-      size >= target &&
-      line.trim() === '' &&
-      next !== undefined &&
-      next.length > 0 &&
-      next[0] !== ' ' &&
-      next[0] !== '\t'
-    ) {
-      chunks.push(lines.slice(start, i + 1).join('\n'));
-      start = i + 1;
-      size = 0;
-    }
-  }
-  chunks.push(lines.slice(start).join('\n'));
-  return chunks;
-}

package/src/chat/headless/path-resolver.ts

@@ -1,178 +0,0 @@
-/**
- * What a prose chip points at (a file or folder on disk, or a branch), asked
- * of the host (`ChatHost.paths`) in batches.
- *
- * Every chip mounting in the same frame shares one `resolve` call per
- * folder; answers are cached per folder and text so scrolling history back
- * into view costs nothing. An answer older than `STALE_MS` is shown while it
- * is checked again (the agent may have created or removed the file since),
- * and a folder the host says moved (a commit, a checkout) is checked afresh.
- */
-import type { ChatPaths, ChatResolvedPath } from './transcript-host';
-
-/** `null`: not known yet, or the folder can't be checked (sandboxes). */
-export type ChipResolution = ChatResolvedPath | null;
-
-const STALE_MS = 15_000;
-
-interface Entry {
-  value: ChipResolution;
-  at: number;
-  inFlight: boolean;
-}
-
-/** Options for {@link createPathResolver}. */
-export interface PathResolverOptions {
-  /** Marks a first ask (an answer may resize the chip); the returned function ends it (`beginChipWork`). */
-  beginWork?: () => () => void;
-}
-
-/** The chip answers of one host. */
-export interface PathResolver {
-  /** The current answer for `text` in `cwd`. */
-  get(cwd: string, text: string): ChipResolution;
-  /** Asks for `text` in `cwd` unless an answer is fresh or on the wire. */
-  request(cwd: string, text: string): void;
-  /** Asks again now, bypassing the cache (a click: the file may exist since). */
-  resolveNow(cwd: string, text: string): Promise<ChipResolution>;
-  /** Calls `listener` when the answer for `text` in `cwd` changes. Returns the unsubscribe. */
-  subscribe(cwd: string, text: string, listener: () => void): () => void;
-  /** Stops following the host's changes. */
-  dispose(): void;
-}
-
-const keyOf = (cwd: string, text: string) => `${cwd}\0${text}`;
-const NO_WORK = () => () => {};
-
-function sameResolution(a: ChipResolution, b: ChipResolution): boolean {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
-/**
- * Creates the chip answers over a host's paths.
- *
- * @param paths - The host's `paths` member.
- * @param options - The chip-work counter.
- */
-export function createPathResolver(paths: ChatPaths, options: PathResolverOptions = {}): PathResolver {
-  const beginWork = options.beginWork ?? NO_WORK;
-  const cache = new Map<string, Map<string, Entry>>();
-  const listeners = new Map<string, Set<() => void>>();
-  const queued = new Map<string, Set<string>>();
-  let flushScheduled = false;
-  /** First asks (nothing shown yet): an answer may resize the chip, so a thread's reveal waits on them. */
-  const firstAsks = new Map<string, () => void>();
-  let watching = false;
-  let offChanges: (() => void) | undefined;
-
-  const answered = (cwd: string, text: string) => {
-    const key = keyOf(cwd, text);
-    firstAsks.get(key)?.();
-    firstAsks.delete(key);
-  };
-
-  /** `null` when the host can't answer. */
-  const ask = (cwd: string, texts: string[]): Promise<readonly ChatResolvedPath[] | null> =>
-    Promise.resolve()
-      .then(() => paths.resolve(cwd, texts))
-      .catch(() => null);
-
-  const entries = (cwd: string) => {
-    let map = cache.get(cwd);
-    if (!map) {
-      map = new Map();
-      cache.set(cwd, map);
-    }
-    return map;
-  };
-
-  const emit = (cwd: string, text: string) => {
-    for (const listener of listeners.get(keyOf(cwd, text)) ?? []) listener();
-  };
-
-  const watchRepoMoves = () => {
-    if (watching) return;
-    watching = true;
-    // Commits, checkouts and pulls add and remove files (and branches): answer afresh.
-    offChanges = paths.onChanged?.((cwd) => {
-      for (const entry of cache.get(cwd)?.values() ?? []) entry.at = 0;
-    });
-  };
-
-  const flush = async () => {
-    flushScheduled = false;
-    const batches = [...queued];
-    queued.clear();
-    await Promise.all(
-      batches.map(async ([cwd, set]) => {
-        const texts = [...set];
-        const answers = await ask(cwd, texts);
-        const map = entries(cwd);
-        texts.forEach((text, i) => {
-          const value = answers ? (answers[i] ?? { kind: 'missing' as const }) : null;
-          const prev = map.get(text);
-          map.set(text, { value, at: Date.now(), inFlight: false });
-          if (!prev || !sameResolution(prev.value, value)) emit(cwd, text);
-          answered(cwd, text);
-        });
-      }),
-    );
-  };
-
-  const request = (cwd: string, text: string) => {
-    watchRepoMoves();
-    const map = entries(cwd);
-    const entry = map.get(text);
-    if (entry?.inFlight) return;
-    if (entry && Date.now() - entry.at < STALE_MS) return;
-    if (entry) entry.inFlight = true;
-    else {
-      map.set(text, { value: null, at: 0, inFlight: true });
-      firstAsks.set(keyOf(cwd, text), beginWork());
-    }
-    let set = queued.get(cwd);
-    if (!set) {
-      set = new Set();
-      queued.set(cwd, set);
-    }
-    set.add(text);
-    if (!flushScheduled) {
-      flushScheduled = true;
-      // One frame of chips per call: the whole message, not one call per chip.
-      setTimeout(() => void flush(), 0);
-    }
-  };
-
-  return {
-    get: (cwd, text) => cache.get(cwd)?.get(text)?.value ?? null,
-    request,
-    async resolveNow(cwd, text) {
-      const answers = await ask(cwd, [text]);
-      const value = answers ? (answers[0] ?? { kind: 'missing' as const }) : null;
-      const map = entries(cwd);
-      const prev = map.get(text);
-      map.set(text, { value, at: Date.now(), inFlight: false });
-      if (!prev || !sameResolution(prev.value, value)) emit(cwd, text);
-      return value;
-    },
-    subscribe(cwd, text, listener) {
-      const key = keyOf(cwd, text);
-      let set = listeners.get(key);
-      if (!set) {
-        set = new Set();
-        listeners.set(key, set);
-      }
-      set.add(listener);
-      const own = set;
-      return () => {
-        own.delete(listener);
-        if (own.size === 0 && listeners.get(key) === own) listeners.delete(key);
-      };
-    },
-    dispose() {
-      offChanges?.();
-      for (const done of firstAsks.values()) done();
-      firstAsks.clear();
-    },
-  };
-}

package/src/chat/headless/prompt-origin.ts

@@ -1,90 +0,0 @@
-/**
- * Who a prompt came from when it is not the session's own user typing in a
- * window: the `origin` zidane puts on a `user-prompt` event
- * (`StreamEvent.origin`, a `TextOrigin`), and the short sender label the
- * transcript shows above it.
- *
- * Twin of zidane's `originLabel` (`src/tui/transcript/origin-label.ts`): keep
- * the wording the same. A copy, since the TUI's helper is not in zidane's
- * public entries. The origin comes from a remote sender, so it is checked by
- * shape and its strings cleaned.
- */
-
-/** A prompt's origin, as the transcript reads it. Mirrors zidane's `TextOrigin` (`src/text-origin.ts`), without its `messageId`. */
-export interface PromptOrigin {
-  /** 'user': the session's user, through another surface; 'signal': someone else (a channel participant); 'event': something that happened (orchestration, a webhook). */
-  kind: 'user' | 'signal' | 'event';
-  /** Where it came from: 'slack', 'github', 'orchestration'… */
-  source: string;
-  /** Who, when known: a provider id and a display name. */
-  sender?: { id: string; name?: string };
-}
-
-/** The sender label's words. Overridable through `LabelsProvider` like the chat labels. */
-export const PROMPT_ORIGIN_LABELS = {
-  /** A channel participant: `Alice · slack`. */
-  promptOriginSender: (name: string, source: string) => `${name} · ${source}`,
-  /** A participant the channel gave neither a name nor an id. */
-  promptOriginSomeone: 'someone',
-  /** The session's own user, through another surface: `via slack`. */
-  promptOriginVia: (source: string) => `via ${source}`,
-};
-
-/** The words {@link promptOriginLabel} reads. */
-export type PromptOriginLabels = typeof PROMPT_ORIGIN_LABELS;
-
-const KINDS: readonly string[] = ['user', 'signal', 'event'] satisfies readonly PromptOrigin['kind'][];
-
-// Escape sequences go whole (`ESC[31m` leaves nothing), as zidane's `stripTerminalControlChars` does.
-const ESCAPES = /\u001B\][\s\S]*?(?:\u0007|\u001B\\)|\u001B\[[0-9:;<=>?]*[ -/]*[@-~]|\u001B[\s\S]?/g;
-const CONTROLS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g;
-
-/** A remote string made safe to show on one line: no control characters, each whitespace run one space. */
-function cleanText(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined;
-  const clean = value.replace(ESCAPES, '').replace(CONTROLS, '').replace(/\s+/g, ' ').trim();
-  return clean || undefined;
-}
-
-/**
- * The origin of a `user-prompt` event, checked by shape, or `undefined` when
- * it has none or a malformed one. Names and sources come back cleaned.
- *
- * @param event - The stream event. Only its `origin` is read.
- */
-export function promptOriginOf(event: object): PromptOrigin | undefined {
-  const origin: unknown = (event as { origin?: unknown }).origin;
-  if (!origin || typeof origin !== 'object') return undefined;
-  const { kind, source: rawSource, sender: rawSender } = origin as Record<string, unknown>;
-  const source = cleanText(rawSource);
-  if (typeof kind !== 'string' || !KINDS.includes(kind) || !source) return undefined;
-  const read: PromptOrigin = { kind: kind as PromptOrigin['kind'], source };
-  if (rawSender && typeof rawSender === 'object') {
-    const id = cleanText((rawSender as Record<string, unknown>).id);
-    const name = cleanText((rawSender as Record<string, unknown>).name);
-    if (id) read.sender = name ? { id, name } : { id };
-  }
-  return read;
-}
-
-/**
- * The short label above a prompt with an origin: `Alice · slack` for a
- * channel participant, `via slack` for the session's user through another
- * surface, the source (`orchestration`) for an event.
- *
- * @param origin - The prompt's origin.
- * @param labels - The label words.
- */
-export function promptOriginLabel(origin: PromptOrigin, labels: PromptOriginLabels): string {
-  switch (origin.kind) {
-    case 'signal':
-      return labels.promptOriginSender(
-        origin.sender?.name || origin.sender?.id || labels.promptOriginSomeone,
-        origin.source,
-      );
-    case 'user':
-      return labels.promptOriginVia(origin.source);
-    case 'event':
-      return origin.source;
-  }
-}

package/src/chat/headless/reference-store.ts

@@ -1,285 +0,0 @@
-/**
- * The cache behind extension text references (`ChatHost.references`): the
- * providers' patterns per folder, and the views of the keys found in text.
- *
- * Matching runs in the page with the shared matcher (`findReferences`), so a
- * row splits its text synchronously once the providers are known; views are
- * asked of the host in batches, one per microtask, and kept for
- * `VIEW_TTL_MS`. A key whose view is `null` names nothing and stays plain
- * text. A `{ kind: 'all' }` change drops both caches: patterns and views
- * follow the extensions.
- *
- * Both are kept in `storage` (`REFERENCES_STORAGE_KEY`), so a conversation
- * opened again paints its badges on the first frame: stored patterns match at
- * once, stored views show at once and are refreshed in the background when
- * older than `VIEW_TTL_MS` (stale-while-revalidate). Only views that name
- * something are stored; misses are remembered in memory only.
- *
- * Sidebar titles only peek: the host answers from a registry it already
- * built, never builds one per listed project. A miss stays plain text until a
- * full ask for that folder lands.
- *
- * Notifications are per key (a folder's providers, one view): an answer
- * re-renders the rows of that folder and the chips of that view, not every
- * title and markdown block.
- */
-import type { ExtensionReferenceView, ReferenceProviderWire } from 'zidane/chat/pure';
-
-import type { ChatReferences } from './transcript-host';
-
-const VIEW_TTL_MS = 5 * 60_000;
-/** Keys per `resolve` call when the host names no limit. */
-const RESOLVE_MAX = 50;
-const NO_PROVIDERS: readonly ReferenceProviderWire[] = Object.freeze([]);
-/** Where the caches persist. */
-export const REFERENCES_STORAGE_KEY = 'zg:references:v1';
-/** Stored views, at most (the most recently resolved win). */
-const STORED_VIEWS_MAX = 500;
-/** Stored views older than this are not loaded (a ticket untouched for a month repaints from scratch). */
-const STORED_VIEWS_MAX_AGE_MS = 30 * 24 * 60 * 60_000;
-const SAVE_DELAY_MS = 800;
-
-/** A view as cached: `null` names nothing; `at` is when it was resolved (0: stale). */
-export interface ReferenceViewEntry {
-  /** The view; `null` when the key names nothing. */
-  view: ExtensionReferenceView | null;
-  /** When it was resolved, epoch ms (`0`: stale). */
-  at: number;
-}
-
-/** Options for {@link createReferenceStore}. */
-export interface ReferenceStoreOptions {
-  /** Where the caches persist across reloads. Default: `localStorage` when there is one; `null`: memory only. */
-  storage?: Storage | null;
-  /** Marks a lookup that may resize a chip; the returned function ends it (`beginChipWork`). */
-  beginWork?: () => () => void;
-}
-
-/** The reference cache of one host. */
-export interface ReferenceStore {
-  /** The providers for `cwd` (`''`: user-level), empty until known. */
-  providers(cwd: string): readonly ReferenceProviderWire[];
-  /** Asks for `cwd`'s providers unless already asked (`peek`: only what the host has built). */
-  loadProviders(cwd: string, peek: boolean): void;
-  /** The cached view of a key: `undefined` while unknown. */
-  view(cwd: string, providerId: string, key: string): ReferenceViewEntry | undefined;
-  /** Asks for a key's view unless it is fresh or already asked. */
-  requestView(cwd: string, providerId: string, key: string): void;
-  /** Calls `listener` when `cwd`'s providers change. Returns the unsubscribe. */
-  subscribeProviders(cwd: string, listener: () => void): () => void;
-  /** Calls `listener` when a key's view changes. Returns the unsubscribe. */
-  subscribeView(cwd: string, providerId: string, key: string, listener: () => void): () => void;
-  /** Stops following the host's changes and drops pending saves. */
-  dispose(): void;
-}
-
-interface Stored {
-  providers: Record<string, readonly ReferenceProviderWire[]>;
-  views: Record<string, { view: ExtensionReferenceView; at: number }>;
-}
-
-const providersKey = (cwd: string) => `providers:${cwd}`;
-const viewKey = (id: string) => `view:${id}`;
-const viewId = (cwd: string, providerId: string, key: string) => `${cwd}\u0000${providerId}\u0000${key}`;
-const NO_WORK = () => () => {};
-
-function defaultStorage(): Storage | null {
-  try {
-    return typeof localStorage === 'undefined' ? null : localStorage;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Creates the reference cache over a host's references.
- *
- * @param references - The host's `references` member.
- * @param options - Persistence and the chip-work counter.
- */
-export function createReferenceStore(references: ChatReferences, options: ReferenceStoreOptions = {}): ReferenceStore {
-  const storage = options.storage === undefined ? defaultStorage() : options.storage;
-  const beginWork = options.beginWork ?? NO_WORK;
-  const resolveMax = references.resolveMax ?? RESOLVE_MAX;
-
-  const providers = new Map<string, readonly ReferenceProviderWire[]>();
-  /** Per cwd, the strongest ask out or answered: a `peek` never blocks a `full` one. */
-  const providersAsked = new Map<string, 'peek' | 'full'>();
-  const views = new Map<string, ReferenceViewEntry>();
-  const pending = new Map<string, { cwd: string; providerId: string; key: string }>();
-  /** Asked and not answered yet (queued or on the wire): not asked again meanwhile; each ends its chip work when answered. */
-  const inflight = new Map<string, () => void>();
-  /** Per key (`providersKey`, `viewKey`), the hooks reading it. */
-  const listeners = new Map<string, Set<() => void>>();
-  let flushQueued = false;
-  let saveTimer: ReturnType<typeof setTimeout> | undefined;
-
-  const settle = (id: string) => {
-    inflight.get(id)?.();
-    inflight.delete(id);
-  };
-
-  const hydrate = () => {
-    try {
-      const raw = storage?.getItem(REFERENCES_STORAGE_KEY);
-      if (!raw) return;
-      const stored = JSON.parse(raw) as Partial<Stored>;
-      const now = Date.now();
-      for (const [cwd, list] of Object.entries(stored.providers ?? {})) {
-        if (Array.isArray(list)) providers.set(cwd, list);
-      }
-      for (const [id, entry] of Object.entries(stored.views ?? {})) {
-        if (entry?.view?.label && typeof entry.at === 'number' && now - entry.at < STORED_VIEWS_MAX_AGE_MS) {
-          views.set(id, entry);
-        }
-      }
-    } catch {
-      // A corrupt store is dropped on the next save.
-    }
-  };
-
-  const save = () => {
-    saveTimer = undefined;
-    try {
-      const kept = [...views.entries()]
-        .filter((e): e is [string, { view: ExtensionReferenceView; at: number }] => e[1].view !== null)
-        .sort((a, b) => b[1].at - a[1].at)
-        .slice(0, STORED_VIEWS_MAX);
-      const stored: Stored = { providers: Object.fromEntries(providers), views: Object.fromEntries(kept) };
-      storage?.setItem(REFERENCES_STORAGE_KEY, JSON.stringify(stored));
-    } catch {
-      // Quota or no storage: the in-memory caches still work.
-    }
-  };
-
-  const scheduleSave = () => {
-    if (saveTimer === undefined && storage) saveTimer = setTimeout(save, SAVE_DELAY_MS);
-  };
-
-  /** Re-render what reads `key`; every key when omitted (the caches were dropped). */
-  const changed = (key?: string) => {
-    const sets = key === undefined ? [...listeners.values()] : [listeners.get(key)];
-    for (const set of sets) for (const listener of [...(set ?? [])]) listener();
-  };
-
-  const subscribeKey = (key: string, listener: () => void) => {
-    let set = listeners.get(key);
-    if (!set) listeners.set(key, (set = new Set()));
-    set.add(listener);
-    const own = set;
-    return () => {
-      own.delete(listener);
-      if (own.size === 0 && listeners.get(key) === own) listeners.delete(key);
-    };
-  };
-
-  const loadProviders = (cwd: string, peek: boolean) => {
-    const asked = providersAsked.get(cwd);
-    if (asked === 'full' || (asked === 'peek' && peek)) return;
-    const kind = peek ? 'peek' : 'full';
-    providersAsked.set(cwd, kind);
-    // A title's peek never holds a thread's reveal; a full ask does (its rows match once it lands).
-    const done = peek ? () => {} : beginWork();
-    const forget = () => {
-      if (providersAsked.get(cwd) === kind) providersAsked.delete(cwd);
-    };
-    references
-      .providers(cwd, peek ? { peek: true } : undefined)
-      .then((list) => {
-        // Peek miss: nothing cached host-side; a later row or a full ask retries.
-        if (!list) return forget();
-        if (kind === 'peek' && providersAsked.get(cwd) === 'full') return;
-        const before = providers.get(cwd);
-        // One empty list for every cwd without providers: an empty answer keeps the hooks' snapshot.
-        providers.set(cwd, list.length > 0 ? list : NO_PROVIDERS);
-        scheduleSave();
-        if (list.length > 0 || (before?.length ?? 0) > 0) changed(providersKey(cwd));
-      })
-      .catch(forget)
-      // After the rows re-render with the patterns: their views are asked (and counted) before this ends.
-      .finally(() => queueMicrotask(done));
-  };
-
-  const flush = () => {
-    flushQueued = false;
-    const byCwd = new Map<string, { providerId: string; key: string; id: string }[]>();
-    for (const [id, item] of pending) {
-      const list = byCwd.get(item.cwd) ?? [];
-      list.push({ providerId: item.providerId, key: item.key, id });
-      byCwd.set(item.cwd, list);
-    }
-    pending.clear();
-    for (const [cwd, items] of byCwd) {
-      for (let at = 0; at < items.length; at += resolveMax) {
-        const batch = items.slice(at, at + resolveMax);
-        references
-          .resolve(
-            cwd,
-            batch.map(({ providerId, key }) => ({ providerId, key })),
-          )
-          .then((answers) => {
-            const now = Date.now();
-            batch.forEach((item, i) => views.set(item.id, { view: answers[i] ?? null, at: now }));
-            scheduleSave();
-            for (const item of batch) changed(viewKey(item.id));
-          })
-          .catch(() => undefined)
-          .finally(() => {
-            for (const item of batch) settle(item.id);
-          });
-      }
-    }
-  };
-
-  const requestView = (cwd: string, providerId: string, key: string) => {
-    const id = viewId(cwd, providerId, key);
-    const hit = views.get(id);
-    // An expired view stays shown while its refresh is out.
-    if ((hit && Date.now() - hit.at < VIEW_TTL_MS) || inflight.has(id)) return;
-    // Only a first answer can resize the chip; a background refresh of a shown view never holds a reveal.
-    inflight.set(id, hit ? () => {} : beginWork());
-    pending.set(id, { cwd, providerId, key });
-    if (flushQueued) return;
-    flushQueued = true;
-    queueMicrotask(flush);
-  };
-
-  /** Forget every cwd's view of one reference, so its chips ask again (the old view stays shown meanwhile). */
-  const dropViews = (providerId: string, key: string) => {
-    const suffix = `\u0000${providerId}\u0000${key}`;
-    for (const [id, entry] of views) {
-      if (id.endsWith(suffix) && !inflight.has(id)) {
-        // Stale, not gone: the badge keeps painting until the fresh answer lands.
-        views.set(id, { ...entry, at: 0 });
-        changed(viewKey(id));
-      }
-    }
-  };
-
-  hydrate();
-
-  const offChanges = references.onChanged?.((change) => {
-    if (change.kind === 'reference') return dropViews(change.providerId, change.key);
-    providers.clear();
-    providersAsked.clear();
-    views.clear();
-    for (const id of [...inflight.keys()]) settle(id);
-    scheduleSave();
-    changed();
-  });
-
-  return {
-    providers: (cwd) => providers.get(cwd) ?? NO_PROVIDERS,
-    loadProviders,
-    view: (cwd, providerId, key) => views.get(viewId(cwd, providerId, key)),
-    requestView,
-    subscribeProviders: (cwd, listener) => subscribeKey(providersKey(cwd), listener),
-    subscribeView: (cwd, providerId, key, listener) => subscribeKey(viewKey(viewId(cwd, providerId, key)), listener),
-    dispose() {
-      offChanges?.();
-      if (saveTimer !== undefined) clearTimeout(saveTimer);
-      saveTimer = undefined;
-      for (const id of [...inflight.keys()]) settle(id);
-    },
-  };
-}