zidane-ui 9.0.4 → 9.1.3

package/src/chat/transcript/TurnMenu.tsx

@@ -1,217 +0,0 @@
-/**
- * The transcript's per-turn actions (copy, fork, edit / rewind, delete) as a right-click
- * menu on a prompt bubble or a reply. A hover strip under every message
- * would reserve space that doubles the gap between rows, so there is one
- * menu per transcript, opened at the cursor.
- *
- * What each action does is the container's (`TurnMenuActions`): reading a
- * turn's send time, copying, forking, editing, rewinding, deleting, and
- * reloading the events after a history edit. Leaving one out hides its item.
- */
-import { useCallback, useMemo, useRef, useState } from 'react';
-import { ageString } from 'zidane/chat/pure';
-
-import { reportRendererError } from '../../components/report-error';
-import { RowActionsMenu, type RowActionItem } from '../../components/RowActionsMenu';
-import type { TurnMenuTarget } from '../Transcript';
-import { useChatLabels } from '../useChatLabels';
-
-/** What the turn menu's items do, for one transcript. Memoize it: the items rebuild when it changes. */
-export interface TurnMenuActions<K extends string = string> {
-  /** A run is in progress: history edits are refused (the item says to stop it first). */
-  running: boolean;
-  /** A stored turn's send time; `null` when not stored yet. Absent: no "Sent …" line. */
-  sentAt?(sessionId: K, turnId: string): Promise<number | null>;
-  /** Copies a turn's text (`fallback`: the row's own text). */
-  copy(sessionId: K, turnId: string, fallback: string): Promise<unknown>;
-  /** Forks the session from a turn and shows the fork. Absent: no Fork item. */
-  fork?(sessionId: K, turnId: string): Promise<void>;
-  /** Puts a prompt back in the composer and cuts history before it. Absent: no Edit item. */
-  editPrompt?(sessionId: K, turnId: string, fallback: string): Promise<void>;
-  /** Cuts history after a reply. Absent: no Rewind item. */
-  rewind?(sessionId: K, turnId: string): Promise<void>;
-  /** Deletes a turn. Absent: no Delete item. */
-  deleteTurn?(sessionId: K, turnId: string): Promise<void>;
-  /** Reloads the session's events after a history edit, so cut rows drop out at once. */
-  reload(sessionId: K): Promise<void>;
-  /** Shows a failed action where the user acted (an error row in the transcript). */
-  showError(sessionId: K, message: string): void;
-  /** The sentence for a failure (the host's refusals are written for the user). */
-  errorMessage(error: unknown): string;
-}
-
-interface OpenTurnMenu extends TurnMenuTarget {
-  /** Text selected inside the row when it was right-clicked. */
-  selection: string | null;
-  /** When the turn was sent, if already known at open (the menu never grows while shown). */
-  sentAt: number | null;
-  at: { x: number; y: number };
-}
-
-/** The selection's text when it lies inside `row`, else null. */
-function selectionWithin(row: HTMLElement): string | null {
-  const sel = window.getSelection();
-  if (!sel || sel.isCollapsed || !sel.anchorNode || !sel.focusNode) return null;
-  if (!row.contains(sel.anchorNode) || !row.contains(sel.focusNode)) return null;
-  const text = sel.toString();
-  return text.trim() ? text : null;
-}
-
-/**
- * The transcript's turn menu: `onContextMenu` for a row, `prefetch` on hover (the send time), and the
- * `menu` element to render once (memoized).
- *
- * @param sessionId - The transcript's session.
- * @param actions - The {@link TurnMenuActions}.
- */
-export function useTurnMenu<K extends string>(sessionId: K | null | undefined, actions: TurnMenuActions<K>) {
-  const labels = useChatLabels();
-  const [target, setTarget] = useState<OpenTurnMenu | null>(null);
-  /*
-   * Send times, fetched on hover so they are there by the time the menu
-   * opens. A turn's `createdAt` never changes; a miss (not persisted yet)
-   * is not cached, so it is retried on the next hover.
-   */
-  const sentAt = useRef(new Map<string, number>());
-  const pending = useRef(new Set<string>());
-  const [busy, setBusy] = useState(false);
-  const readSentAt = actions.sentAt;
-
-  const prefetch = useCallback(
-    (turnId: string) => {
-      if (!sessionId || !readSentAt) return;
-      const key = `${sessionId}:${turnId}`;
-      if (sentAt.current.has(key) || pending.current.has(key)) return;
-      pending.current.add(key);
-      void readSentAt(sessionId, turnId)
-        .then((at) => {
-          if (at !== null) sentAt.current.set(key, at);
-        })
-        .catch(() => {})
-        .finally(() => pending.current.delete(key));
-    },
-    [sessionId, readSentAt],
-  );
-
-  const onContextMenu = useCallback(
-    (event: React.MouseEvent<HTMLElement>, clicked: TurnMenuTarget) => {
-      if (!sessionId) return;
-      event.preventDefault();
-      const { turnId } = clicked;
-      const selection = selectionWithin(event.currentTarget);
-      const sent = sentAt.current.get(`${sessionId}:${turnId}`) ?? null;
-      const at = { x: event.clientX, y: event.clientY };
-      setTarget({ ...clicked, selection, sentAt: sent, at });
-      // Opened before hovering (keyboard menu key, a fast flick): known next time.
-      if (sent === null) prefetch(turnId);
-    },
-    [sessionId, prefetch],
-  );
-
-  const close = useCallback(() => setTarget(null), []);
-
-  const items = useMemo<RowActionItem[]>(() => {
-    if (!target || !sessionId) return [];
-    const { turnId, text, selection, sentAt, kind } = target;
-    const { running, copy, fork, editPrompt, rewind, deleteTurn, reload, showError, errorMessage } = actions;
-    const list: RowActionItem[] = [];
-    // Shown where the user acted (an error row in this transcript) and logged. The host's
-    // refusals are sentences written for the user ("Cannot …. Stop it first."), so they
-    // show alone; `action` only names the log source.
-    const failed =
-      (action: string, message = errorMessage) =>
-      (err: unknown) => {
-        reportRendererError(err, { source: `turn menu: ${action}` });
-        showError(sessionId, message(err));
-      };
-    // A history edit, then the events reload so the cut rows drop out immediately.
-    const editHistory = (action: string, edit: () => Promise<void>) => {
-      setBusy(true);
-      void edit()
-        .then(() => reload(sessionId))
-        .catch(failed(action))
-        .finally(() => setBusy(false));
-    };
-    const withStop = (label: string) => (running ? labels.turnMenuStopFirst(label) : label);
-    if (selection) {
-      list.push({
-        id: 'copy-selection',
-        label: labels.turnMenuCopySelection,
-        onSelect: () =>
-          void navigator.clipboard
-            .writeText(selection)
-            .catch(failed('copy the selection', () => labels.turnMenuCopySelectionFailed)),
-      });
-    }
-    list.push(
-      {
-        id: 'copy',
-        label: labels.turnMenuCopy,
-        shortcut: 'C',
-        onSelect: () => void copy(sessionId, turnId, text),
-      },
-      ...(fork
-        ? [
-            {
-              id: 'fork',
-              label: labels.turnMenuFork,
-              shortcut: 'F',
-              disabled: busy,
-              onSelect: () => {
-                setBusy(true);
-                void fork(sessionId, turnId)
-                  .catch(failed('fork'))
-                  .finally(() => setBusy(false));
-              },
-            },
-          ]
-        : []),
-    );
-    if (kind === 'prompt') {
-      if (editPrompt)
-        list.push({
-          id: 'edit',
-          label: withStop(labels.turnMenuEdit),
-          shortcut: 'E',
-          disabled: busy || running,
-          onSelect: () => editHistory('edit the message', () => editPrompt(sessionId, turnId, text)),
-        });
-    } else if (rewind) {
-      list.push({
-        id: 'rewind',
-        label: withStop(labels.turnMenuRewind),
-        shortcut: 'R',
-        disabled: busy || running,
-        onSelect: () => editHistory('rewind', () => rewind(sessionId, turnId)),
-      });
-    }
-    if (deleteTurn)
-      list.push({
-        id: 'delete',
-        label: withStop(labels.turnMenuDelete),
-        shortcut: 'D',
-        destructive: true,
-        disabled: busy || running,
-        onSelect: () => editHistory('delete the turn', () => deleteTurn(sessionId, turnId)),
-      });
-    if (sentAt !== null) {
-      list.push({
-        id: 'sent',
-        // eslint-disable-next-line react-hooks/purity -- the age is read when the menu opens; it never ticks while shown
-        label: labels.turnMenuSent(ageString(sentAt, Date.now())),
-        disabled: true,
-        onSelect: () => {},
-      });
-    }
-    return list;
-  }, [target, sessionId, busy, actions, labels]);
-
-  // Memoized: it is `Transcript`'s children, and a new element each render defeated its memo.
-  const at = target?.at ?? null;
-  const menu = useMemo(
-    () => <RowActionsMenu open={at !== null} position={at} onClose={close} items={items} />,
-    [at, close, items],
-  );
-
-  return { onContextMenu, prefetch, menu };
-}

package/src/chat/transcript/actions.tsx

@@ -1,77 +0,0 @@
-/**
- * The transcript's actions: what a row can ask of the app that hosts it
- * (fetch a clipped tool output in full, stop a running `!` command, open
- * another session, send a prompt). Rows read them with
- * `useTranscriptActions()`; an app provides them once with a
- * `<TranscriptActionsProvider>` around its transcript instead of threading
- * props through every level. Each action is optional, and its control is
- * hidden when the app leaves it out: no "Load full output" without
- * `toolOutput`, no stop button without `cancelTool`.
- *
- * Two rows take their action as a prop (`FailureRow`'s `onResume`,
- * `SessionEventRow`'s `onOpenSession`), which `TranscriptRow` fills from
- * this context. The other rows read the context themselves.
- */
-import { createContext, useContext, type ReactNode } from 'react';
-import { nameFromModelId, type ModelNamer } from 'zidane/chat/pure';
-
-/** What a transcript row can ask of the app that hosts it. Every action but `sessionId` is optional, and its control is hidden when the app leaves it out. */
-export interface TranscriptActions {
-  /** The session on screen; actions that address a call need it. */
-  sessionId: string | null;
-  /** The whole text of a tool result that was clipped for transport (`ChatHost.toolOutput`). `turnId`: the call's turn, a hint where to look first. */
-  toolOutput?(callId: string, turnId?: string): Promise<string | null>;
-  /** Stops a running call (`ChatHost.cancelTool`). */
-  cancelTool?(callId: string): void;
-  /** Shows another session, named by its id (a worker a tool call addresses). */
-  openSession?(sessionId: string): void;
-  /** Sends a prompt as the user's next message. */
-  resume?(prompt: string): void;
-  /**
-   * The address of a tool result's `index`-th image, video or audio block
-   * (its order among the result's media). With it, results show their media
-   * inline instead of `[image: …]` stand-ins.
-   */
-  toolMediaUrl?(callId: string, index: number): string;
-  /**
-   * Opens a file the session wrote, by its path relative to the session's
-   * folder (a `generate_image` result). Without it the path is plain text.
-   */
-  openFile?(path: string, event?: { metaKey?: boolean; ctrlKey?: boolean }): void;
-  /**
-   * Names a model as the app's model picker does (`Opus 4.5`), from its
-   * catalogs. Without it, rows name a model from its id alone.
-   */
-  modelName?: ModelNamer;
-}
-
-const NO_ACTIONS: TranscriptActions = { sessionId: null };
-
-const TranscriptActionsContext = createContext<TranscriptActions>(NO_ACTIONS);
-
-/** Props for {@link TranscriptActionsProvider}. */
-export interface TranscriptActionsProviderProps {
-  /** The actions to provide. Memoize it: every row reading the context re-renders when it changes. */
-  value: TranscriptActions;
-  /** The transcript that reads the actions. */
-  children: ReactNode;
-}
-
-/**
- * Provides the transcript's actions to every row below it.
- *
- * @param props - Provider props: the `value` actions and the `children` that read them.
- */
-export function TranscriptActionsProvider({ value, children }: TranscriptActionsProviderProps) {
-  return <TranscriptActionsContext.Provider value={value}>{children}</TranscriptActionsContext.Provider>;
-}
-
-/** Returns the {@link TranscriptActions} from the nearest {@link TranscriptActionsProvider}. Without one it returns an object with no session and no actions. */
-export function useTranscriptActions(): TranscriptActions {
-  return useContext(TranscriptActionsContext);
-}
-
-/** How the transcript names a model: the app's `modelName`, else from the id. */
-export function useModelName(): ModelNamer {
-  return useContext(TranscriptActionsContext).modelName ?? nameFromModelId;
-}

package/src/chat/transcript/badges.tsx

@@ -1,152 +0,0 @@
-/**
- * Inline badges: a file, skill, command, link or reference set into text.
- * One look in the composer, in sent prompts and in replies (`.zg-badge`): an
- * icon, then the name, never split across lines and never taller than the
- * line it sits on.
- *
- * The icon is either a glyph drawn by the badge's own `::before` (the
- * `BADGE_GLYPH` classes, which also work on decorated editor text that has
- * no child elements) or a child `.zg-badge-icon` (a file's type icon, which
- * varies per file). Both are sized and aligned by the same rule.
- */
-import type { DOMOutputSpec } from '@tiptap/pm/model';
-import type { CSSProperties } from 'react';
-
-import { shortUrl } from '../headless/badge-refs';
-import { chipForPath, type FileChip } from '../headless/file-chip';
-import { useBadgeMenu } from './BadgeMenu';
-import { useSiteIcon } from './site-icons';
-
-/** Literal classes (UnoCSS scans this file): the `::before` glyph of each badge kind. */
-export const BADGE_GLYPH = {
-  skill: 'zg-badge-glyph before:i-ph-book-bookmark',
-  command: 'zg-badge-glyph before:i-ph-terminal-window',
-  chat: 'zg-badge-glyph before:i-ph-chats',
-  extension: 'zg-badge-glyph before:i-ph-puzzle-piece',
-  link: 'zg-badge-glyph before:i-ph-globe',
-} as const;
-
-/**
- * A link badge's glyph: the site's icon once loaded (set `--zg-site-icon`), the globe until then or without one.
- *
- * @param icon - The site's icon once loaded (`null`: none yet).
- */
-export function linkGlyph(icon: string | null): string {
-  return icon ? 'zg-badge-glyph zg-badge-site' : BADGE_GLYPH.link;
-}
-
-/**
- * The `--zg-site-icon` value for a loaded icon's data URL.
- *
- * @param icon - The icon's data URL.
- */
-export function siteIconValue(icon: string): string {
-  return `url("${icon}")`;
-}
-
-/**
- * A file badge's name: long names end in an ellipsis rather than crowding the line.
- *
- * @param chip - The file.
- */
-export function fileBadgeName(chip: FileChip): string {
-  return chip.name.length > 32 ? `${chip.name.slice(0, 31)}…` : chip.name;
-}
-
-/**
- * A file badge as an editor node renders it (the composer has no React inside its nodes).
- *
- * @param path - The file's path.
- * @param attrs - The node's own attributes (merged on the badge).
- */
-export function fileBadgeSpec(path: string, attrs: Record<string, string>): DOMOutputSpec {
-  const chip = chipForPath(path);
-  const tone = chip.tone ? { style: `color: ${chip.tone}` } : {};
-  const icon: DOMOutputSpec = chip.badge
-    ? ['span', { class: 'zg-badge-icon zg-badge-letters', 'data-letters': chip.badge, ...tone, 'aria-hidden': 'true' }]
-    : ['span', { class: `zg-badge-icon ${chip.icon}`, ...tone, 'aria-hidden': 'true' }];
-  return [
-    'span',
-    { ...attrs, class: `${attrs.class ?? ''} zg-badge`, title: path },
-    icon,
-    ['span', { class: 'zg-badge-code' }, fileBadgeName(chip)],
-  ];
-}
-
-/** Props for {@link FileBadgeIcon}. */
-export interface FileBadgeIconProps {
-  /** The file the icon is for. */
-  chip: FileChip;
-}
-
-/**
- * A file's type icon (or its language's two letters), as the badge's leading
- * icon. The letters are drawn by CSS, so the badge's text is the name alone
- * (what a copy or a screen reader gets).
- *
- * @param props - The {@link FileBadgeIconProps}.
- */
-export function FileBadgeIcon({ chip }: FileBadgeIconProps) {
-  const style = chip.tone ? { color: chip.tone } : undefined;
-  return chip.badge ? (
-    <span aria-hidden className="zg-badge-icon zg-badge-letters" data-letters={chip.badge} style={style} />
-  ) : (
-    <span aria-hidden className={`zg-badge-icon ${chip.icon}`} style={style} />
-  );
-}
-
-/** Props for {@link LinkBadge}. */
-export interface LinkBadgeProps {
-  /** The address. */
-  url: string;
-  /** The chat's folder, for the badge menu. */
-  cwd?: string | null;
-  /** Extra classes on the link. */
-  className?: string;
-  /** Inline style on the link. */
-  style?: CSSProperties;
-}
-
-/**
- * A link as a badge: the site's icon and the short address; the whole URL on hover. Opens externally.
- *
- * @param props - The {@link LinkBadgeProps}.
- */
-export function LinkBadge({ url, cwd, className, style }: LinkBadgeProps) {
-  const icon = useSiteIcon(url);
-  const openMenu = useBadgeMenu();
-  return (
-    <a
-      href={url}
-      target="_blank"
-      rel="noreferrer"
-      onContextMenu={openMenu ? (e) => openMenu(e, { kind: 'link', text: shortUrl(url), href: url }, cwd) : undefined}
-      title={url}
-      data-kind="link"
-      className={`zg-badge ${linkGlyph(icon)}${className ? ` ${className}` : ''}`}
-      style={icon || style ? { ...(icon ? siteIconVar(icon) : {}), ...style } : undefined}
-    >
-      {shortUrl(url)}
-    </a>
-  );
-}
-
-/** Props for {@link LinkIcon}. */
-export interface LinkIconProps {
-  /** The link's address. */
-  href: string;
-}
-
-/**
- * The site's icon before a link in prose; nothing until (or unless) the site has one.
- *
- * @param props - The {@link LinkIconProps}.
- */
-export function LinkIcon({ href }: LinkIconProps) {
-  const icon = useSiteIcon(href);
-  return icon ? <span aria-hidden className="zg-link-icon" style={siteIconVar(icon)} /> : null;
-}
-
-function siteIconVar(icon: string): CSSProperties {
-  return { '--zg-site-icon': siteIconValue(icon) } as CSSProperties;
-}

package/src/chat/transcript/chip-details.ts

@@ -1,169 +0,0 @@
-/**
- * What the chip hover cards read beyond the chip's own text, from the host's
- * `chips` (`ChatHost.chips`): a commit's subject and size, a referenced
- * chat's row and its context gauge, the skill and command catalogs. Read only
- * when a card opens (the card mounts on open), kept per key: commits for good
- * (a sha names one commit), the rest for a short while, so hovering the same
- * chip again paints at once. A member the host leaves out reads nothing.
- */
-import { useEffect, useState } from 'react';
-
-import { useOptionalChatHost } from '../ChatProvider';
-import { commandName, sessionForToken, skillName } from '../headless/chip-views';
-import { findCommand } from '../headless/composer/commands';
-import type { CommandSummary } from '../headless/composer/host';
-import type {
-  ChatChipDetails,
-  ChatCommandFacts,
-  ChatCommit,
-  ChatContextFacts,
-  ChatSessionFacts,
-  ChatSkillFacts,
-} from '../headless/transcript-host';
-
-interface Entry {
-  at: number;
-  promise: Promise<unknown>;
-  done: boolean;
-  value: unknown;
-}
-
-/** One cache per host's `chips`. */
-const caches = new WeakMap<ChatChipDetails, Map<string, Entry>>();
-const NO_CHIPS: ChatChipDetails = {};
-
-function cacheOf(chips: ChatChipDetails): Map<string, Entry> {
-  let cache = caches.get(chips);
-  if (!cache) {
-    cache = new Map();
-    caches.set(chips, cache);
-  }
-  return cache;
-}
-
-function read<T>(cache: Map<string, Entry>, key: string, fetch: () => Promise<T>, ttlMs: number): Entry {
-  const hit = cache.get(key);
-  if (hit && Date.now() - hit.at < ttlMs) return hit;
-  const entry: Entry = { at: Date.now(), done: false, value: undefined, promise: Promise.resolve() };
-  entry.promise = Promise.resolve()
-    .then(fetch)
-    .catch(() => null)
-    .then((value) => {
-      entry.value = value;
-      entry.done = true;
-    });
-  cache.set(key, entry);
-  return entry;
-}
-
-function useChips(): ChatChipDetails {
-  return useOptionalChatHost()?.chips ?? NO_CHIPS;
-}
-
-/**
- * `fetch`'s answer for `key` (`null` key: nothing to read). `loading` until
- * it lands; a failed read answers `null`.
- */
-function useChipDetail<T>(
-  chips: ChatChipDetails,
-  key: string | null,
-  fetch: () => Promise<T | null>,
-  ttlMs = 30_000,
-): { value: T | null | undefined; loading: boolean } {
-  const [, rerender] = useState(0);
-  const entry = key ? read(cacheOf(chips), key, fetch, ttlMs) : null;
-  const renderedDone = entry?.done ?? true;
-  useEffect(() => {
-    if (!entry || renderedDone) return undefined;
-    // Landed between this render and the effect: paint it now.
-    if (entry.done) {
-      // eslint-disable-next-line react-hooks/set-state-in-effect -- the read landed between render and effect: paint it
-      rerender((n) => n + 1);
-      return undefined;
-    }
-    let live = true;
-    void entry.promise.then(() => live && rerender((n) => n + 1));
-    return () => {
-      live = false;
-    };
-  }, [entry, renderedDone]);
-  if (!entry) return { value: undefined, loading: false };
-  return { value: entry.done ? (entry.value as T | null) : undefined, loading: !entry.done };
-}
-
-/**
- * A sha's commit in `cwd`'s repository.
- *
- * @param cwd - The repository's folder (`null`: nothing to read).
- * @param sha - The commit.
- */
-export function useCommitInfo(cwd: string | null, sha: string) {
-  const chips = useChips();
-  const commit = chips.commit;
-  return useChipDetail<ChatCommit>(
-    chips,
-    cwd && commit ? `commit\0${cwd}\0${sha.toLowerCase()}` : null,
-    () => commit!(cwd!, sha),
-    Number.POSITIVE_INFINITY,
-  );
-}
-
-/**
- * The chat a `#token` names, and its context gauge.
- *
- * @param token - The chip's text (`#3f2a`).
- */
-export function useReferencedSession(token: string) {
-  const chips = useChips();
-  const { sessions, context } = chips;
-  const list = useChipDetail<readonly ChatSessionFacts[]>(
-    chips,
-    sessions ? 'sessions' : null,
-    () => sessions!(),
-    10_000,
-  );
-  const session = list.value ? sessionForToken(list.value, token) : null;
-  const gauge = useChipDetail<ChatContextFacts>(
-    chips,
-    session && context ? `context\0${session.id}` : null,
-    () => context!(session!.id),
-    10_000,
-  );
-  return { session, context: gauge.value ?? null, loading: list.loading || gauge.loading };
-}
-
-/**
- * The skill a chip's text names in `cwd`.
- *
- * @param cwd - The folder whose skills are read (`null`: none).
- * @param text - The chip's text.
- */
-export function useSkill(cwd: string | null, text: string) {
-  const chips = useChips();
-  const skills = chips.skills;
-  const list = useChipDetail<readonly ChatSkillFacts[]>(chips, cwd !== null && skills ? `skills\0${cwd}` : null, () =>
-    skills!(cwd!),
-  );
-  const name = skillName(text).toLowerCase();
-  return { skill: list.value?.find((s) => s.name.toLowerCase() === name) ?? null, loading: list.loading };
-}
-
-/**
- * The command a chip's text names, in a folder on a host (`hostId` `null`: this one).
- *
- * @param scope - The folder and host whose commands are read (`null`: none).
- * @param text - The chip's text.
- */
-export function useCommand(scope: { cwd: string; hostId: string | null } | null, text: string) {
-  const chips = useChips();
-  const commands = chips.commands;
-  const list = useChipDetail<readonly ChatCommandFacts[]>(
-    chips,
-    scope && commands ? `commands\0${scope.hostId ?? ''}\0${scope.cwd}` : null,
-    () => commands!(scope!.cwd, scope!.hostId),
-  );
-  const name = commandName(text);
-  // Facts carry what the composer's catalog lookup reads (name, aliases).
-  const found = list.value && name ? findCommand(list.value as readonly CommandSummary[], name) : undefined;
-  return { command: (found as ChatCommandFacts | undefined) ?? null, loading: list.loading };
-}

package/src/chat/transcript/chip-resolve.ts

@@ -1,56 +0,0 @@
-/**
- * What a prose chip's text names, read from the host's `paths`
- * (`ChatHost.paths`) through one batched cache per host
- * (`createPathResolver`). Without a host, or a host without paths, every
- * answer is `null` and a chip opens the path as written.
- */
-import { useCallback, useEffect, useState } from 'react';
-
-import { useOptionalChatHost } from '../ChatProvider';
-import { beginChipWork } from '../headless/chip-settle';
-import { createPathResolver, type ChipResolution, type PathResolver } from '../headless/path-resolver';
-import type { ChatPaths } from '../headless/transcript-host';
-
-const resolvers = new WeakMap<ChatPaths, PathResolver>();
-
-/** The one chip cache of a host's paths (created on first use, kept with the host). */
-function pathResolverFor(paths: ChatPaths): PathResolver {
-  let resolver = resolvers.get(paths);
-  if (!resolver) {
-    resolver = createPathResolver(paths, { beginWork: beginChipWork });
-    resolvers.set(paths, resolver);
-  }
-  return resolver;
-}
-
-function usePathResolver(): PathResolver | null {
-  const paths = useOptionalChatHost()?.paths;
-  return paths ? pathResolverFor(paths) : null;
-}
-
-/**
- * Current answer for `text` in `cwd`, refreshed when stale.
- *
- * @param cwd - The session's folder (`null`: nothing resolves).
- * @param text - The chip's text.
- */
-export function useChipResolution(cwd: string | null, text: string): ChipResolution {
-  const resolver = usePathResolver();
-  const [, bump] = useState(0);
-  useEffect(() => {
-    if (!cwd || !resolver) return;
-    const off = resolver.subscribe(cwd, text, () => bump((n) => n + 1));
-    resolver.request(cwd, text);
-    return off;
-  }, [resolver, cwd, text]);
-  return cwd && resolver ? resolver.get(cwd, text) : null;
-}
-
-/** Asks again now, bypassing the cache (a click: the file may exist since). `null` without a host's paths. */
-export function useResolveChipNow(): (cwd: string, text: string) => Promise<ChipResolution> {
-  const resolver = usePathResolver();
-  return useCallback(
-    (cwd: string, text: string) => (resolver ? resolver.resolveNow(cwd, text) : Promise.resolve(null)),
-    [resolver],
-  );
-}