zidane-ui 9.1.1 → 9.1.4

package/src/files/useFilesDiagnostics.ts

@@ -1,51 +0,0 @@
-/**
- * Diagnostics for a set of files at once (the Diffs tab's file list): one
- * runner call, counts per path. Re-runs when the list changes, and when
- * `version` does once a burst of new versions settles. Off when the Editor
- * setting is off.
- */
-import { useMemo, useRef } from 'react';
-
-import { countBySeverity } from '../code/editor/diagnostics';
-import type { Diagnostic } from './headless/host';
-import { useDiagnosticsRun } from './useDiagnosticsRun';
-
-export type SeverityCounts = ReturnType<typeof countBySeverity>;
-
-/**
- * `version` is a number or string. Arrays (and other objects) are accepted
- * for robustness: each new identity counts as a new version, so an array
- * never stringifies to "[object Object]" and pins the key.
- */
-export type DiagnosticsVersion = number | string | null | undefined | readonly unknown[] | object;
-
-export function useFilesDiagnostics(
-  cwd: string | null,
-  paths: readonly string[],
-  version: DiagnosticsVersion,
-): ReadonlyMap<string, SeverityCounts> | null {
-  const { result } = useDiagnosticsRun(cwd, paths, {
-    version: useVersionKey(version),
-    settle: true,
-    // These files are not open in a language server: the project-wide checks run for them.
-    lsp: false,
-  });
-
-  return useMemo(() => {
-    if (!result) return null;
-    const byPath = new Map<string, Diagnostic[]>();
-    for (const d of result.diagnostics) byPath.set(d.path, [...(byPath.get(d.path) ?? []), d]);
-    return new Map([...byPath].map(([p, items]) => [p, countBySeverity(items)]));
-  }, [result]);
-}
-
-/** Primitive versions pass through; an object version becomes `length:counter`, bumped per new identity. */
-export function useVersionKey(version: DiagnosticsVersion): string {
-  const last = useRef<{ value: unknown; counter: number }>({ value: version, counter: 0 });
-  if (version === null || version === undefined || typeof version !== 'object') return String(version);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  if (last.current.value !== version) last.current = { value: version, counter: last.current.counter + 1 };
-  const length = Array.isArray(version) ? version.length : 0;
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  return `${length}:${last.current.counter}`;
-}

package/src/files/useFilesLabels.ts

@@ -1,14 +0,0 @@
-/**
- * The Files and Diffs tabs' labels: the defaults, overridable through
- * `<LabelsProvider>` or `FilesProvider`'s `labels`.
- */
-import { useMemo } from 'react';
-
-import { useLabels } from '../labels';
-import { DEFAULT_FILES_LABELS, type FilesLabels } from './headless/labels';
-
-/** Returns the Files and Diffs tabs' strings: the defaults merged with any overrides given to `FilesProvider` or `LabelsProvider`. */
-export function useFilesLabels(): FilesLabels {
-  const overrides = useLabels() as Partial<FilesLabels>;
-  return useMemo(() => ({ ...DEFAULT_FILES_LABELS, ...overrides }), [overrides]);
-}

package/src/files/useFolderChanges.ts

@@ -1,38 +0,0 @@
-/**
- * When a folder's files may have moved, for views that work from a folder
- * rather than a session (Files, Diffs): the host's `watch` (a tool result
- * from any session working in that folder, the repository moving). The
- * subscription fires raw; callers settle bursts themselves.
- */
-import { useCallback, useRef } from 'react';
-
-import { useFilesHost } from './FilesProvider';
-import type { FilesScope, FolderChange } from './headless/host';
-import { filesRootOf } from './headless/view';
-
-export type OnFolderChange = (handler: (why: FolderChange) => void) => () => void;
-
-const NOTHING = () => {};
-
-/** Subscribe to `scope`'s folder changing. Stable per folder. */
-export function useFolderChanges(scope: FilesScope | null): OnFolderChange {
-  const watch = useFilesHost().watch;
-  const scopeRef = useRef(scope);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  scopeRef.current = scope;
-  const root = scope ? filesRootOf(scope) : '';
-  const cwd = scope?.cwd ?? '';
-  const project = scope?.root ?? '';
-  const bound = scope?.session ?? null;
-
-  return useCallback<OnFolderChange>(
-    (handler) => {
-      const current = scopeRef.current;
-      if (!root || !current || !watch) return NOTHING;
-      return watch(current, handler);
-    },
-    // The scope's identity, not its object (callers rebuild it per render).
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [watch, root, cwd, project, bound],
-  );
-}

package/src/files/useLsp.ts

@@ -1,181 +0,0 @@
-/**
- * Language-server diagnostics for the viewed file. The document is opened
- * on the server while a view shows it and closed when the last one goes;
- * `text` updates (typing) are pushed after a short debounce so findings
- * track the draft. Results arrive through the host's `lsp.onDiagnostics`.
- *
- * Documents are counted per (cwd, path) in this window ({@link attachLspDoc}):
- * the first view sends the open, the last one the close, and the text is
- * synced once per document, not per view. Every view of a folder reads the
- * same draft (`folderBuffers`), so they all push the same text: a second
- * view adds nothing to send, and never replays the open with a text the
- * server has moved past. The desktop app's main process counts windows the
- * same way (`DocOwners`).
- */
-import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from 'react';
-
-import { useEditorPrefs, useFilesHost } from './FilesProvider';
-import type { Diagnostic, FilesLsp, LspTextChange } from './headless/host';
-import { forgetEdits, resetEdits, takeEdits } from './headless/lsp-edits';
-
-const CHANGE_DEBOUNCE_MS = 300;
-
-/** One document open on the language server for this window. */
-export interface LspDoc {
-  /** The language servers it is open on. */
-  readonly lsp: FilesLsp;
-  readonly cwd: string;
-  readonly path: string;
-  /** Latest findings (null until the open answers). */
-  items: Diagnostic[] | null;
-  /** Views showing it. */
-  views: number;
-  /** The text the server has, or will have once the pending change goes out. */
-  synced: string;
-  timer: ReturnType<typeof setTimeout> | null;
-  listeners: Set<() => void>;
-  off: () => void;
-}
-
-const docs = new Map<string, LspDoc>();
-const docKey = (cwd: string, path: string) => `${cwd}\0${path}`;
-
-function setItems(doc: LspDoc, items: Diagnostic[]): void {
-  doc.items = items;
-  for (const l of doc.listeners) l();
-}
-
-/** A view starts showing `path`: open it on the server, or join the open document. */
-export function attachLspDoc(lsp: FilesLsp, cwd: string, path: string, text: string): LspDoc {
-  const key = docKey(cwd, path);
-  const existing = docs.get(key);
-  if (existing) {
-    existing.views++;
-    // Same draft as the other views: if it moved meanwhile, the next change syncs it.
-    if (text !== existing.synced) updateLspDoc(existing, text);
-    return existing;
-  }
-  const doc: LspDoc = {
-    lsp,
-    cwd,
-    path,
-    items: null,
-    views: 1,
-    synced: text,
-    timer: null,
-    listeners: new Set(),
-    off: () => {},
-  };
-  docs.set(key, doc);
-  // A fresh open establishes the baseline: whatever was buffered before is stale.
-  resetEdits(cwd, path);
-  takeEdits(cwd, path);
-  void lsp
-    .open(cwd, path, text)
-    .then((known) => docs.get(key) === doc && doc.items === null && setItems(doc, known))
-    .catch(() => undefined);
-  doc.off = lsp.onDiagnostics((atCwd, atPath, diagnostics) => {
-    if (atCwd === cwd && atPath === path) setItems(doc, diagnostics);
-  });
-  return doc;
-}
-
-/** The text moved (typing, a reload): one debounced `didChange` per document. */
-export function updateLspDoc(doc: LspDoc, text: string): void {
-  if (text === doc.synced) return;
-  doc.synced = text;
-  if (doc.timer) clearTimeout(doc.timer);
-  doc.timer = setTimeout(() => {
-    doc.timer = null;
-    if (docs.get(docKey(doc.cwd, doc.path)) !== doc) return;
-    // Incremental when the editor recorded every edit since the last sync; full text otherwise.
-    doc.lsp.open(doc.cwd, doc.path, doc.synced, takeEdits(doc.cwd, doc.path)).catch(() => undefined);
-  }, CHANGE_DEBOUNCE_MS);
-}
-
-/**
- * Completion is about to ask: the server must have `text` first, so the
- * pending debounced change goes now, inside the completion request. Returns
- * the edits to send with it (`undefined`: send the full text), or `null`
- * when no view has the document open here.
- */
-export function syncLspDocNow(
-  cwd: string,
-  path: string,
-  text: string,
-): { changes: LspTextChange[] | undefined } | null {
-  const doc = docs.get(docKey(cwd, path));
-  if (!doc) return null;
-  if (doc.timer) clearTimeout(doc.timer);
-  doc.timer = null;
-  doc.synced = text;
-  return { changes: takeEdits(cwd, path) };
-}
-
-/** A view stops showing the document; the last one closes it on the server. */
-export function detachLspDoc(doc: LspDoc): void {
-  if (--doc.views > 0) return;
-  if (doc.timer) clearTimeout(doc.timer);
-  doc.timer = null;
-  doc.off();
-  const key = docKey(doc.cwd, doc.path);
-  if (docs.get(key) === doc) {
-    docs.delete(key);
-    forgetEdits(doc.cwd, doc.path);
-  }
-  doc.lsp.close(doc.cwd, doc.path).catch(() => undefined);
-}
-
-export function __lspDocsForTests(): ReadonlyMap<string, LspDoc> {
-  return docs;
-}
-
-const noSubscribe = () => () => {};
-
-export function useLsp(cwd: string | null, path: string | null, text: string | null): Diagnostic[] | null {
-  const ed = useEditorPrefs();
-  const lsp = useFilesHost().lsp;
-  const enabled = ed.diagnostics === 'lsp' && lsp !== undefined && cwd !== null && path !== null && text !== null;
-  const [doc, setDoc] = useState<LspDoc | null>(null);
-
-  // Attach / detach follows the (cwd, path) identity; the text at that moment is the opening one.
-  const opening = useRef(text);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  opening.current = text;
-  useEffect(() => {
-    if (!enabled || !lsp || !cwd || !path) return;
-    const d = attachLspDoc(lsp, cwd, path, opening.current ?? '');
-    setDoc(d);
-    return () => {
-      setDoc((cur) => (cur === d ? null : cur));
-      detachLspDoc(d);
-    };
-  }, [enabled, lsp, cwd, path]);
-
-  // Text changes: debounced didChange (deduplicated across views).
-  useEffect(() => {
-    if (doc && text !== null) updateLspDoc(doc, text);
-  }, [doc, text]);
-
-  const subscribe = useCallback(
-    (fn: () => void) => {
-      if (!doc) return noSubscribe();
-      doc.listeners.add(fn);
-      return () => doc.listeners.delete(fn);
-    },
-    [doc],
-  );
-  const read = () => doc?.items ?? null;
-  const items = useSyncExternalStore(subscribe, read, read);
-  const live = doc && doc.cwd === cwd && doc.path === path;
-  return enabled && live ? items : null;
-}
-
-/** Push the LSP settings to the host whenever they change. Mount once (FilesTab). */
-export function useLspConfigSync(): void {
-  const ed = useEditorPrefs();
-  const lsp = useFilesHost().lsp;
-  useEffect(() => {
-    lsp?.configure({ idleMs: ed.lspIdleMin * 60_000, overrides: { ...ed.lspOverrides } }).catch(() => undefined);
-  }, [lsp, ed.lspIdleMin, ed.lspOverrides]);
-}

package/src/files/useOpenFiles.ts

@@ -1,402 +0,0 @@
-/**
- * The editor side of the Files tab: which files are open as tabs, which is
- * active, their contents, plus the per-scope persistence of all of it
- * (open tabs, active file, tree toggles). Restored tabs start unloaded and
- * are read once the cwd is known.
- *
- * The tab list is this view's; the unsaved text is the folder's
- * (`folderBuffers`): every view of the same files root shares it, so a
- * draft survives a remount (session switch, the new-chat draft becoming a
- * session) and two views of a file show the same dirty state.
- *
- * After a tool burst only files that may have moved are re-read: the
- * active one, the ones the new edit events touched, and (when git status
- * lands) the ones whose status changed. Every other open tab is marked
- * stale and re-read when it becomes active, so a change made behind the
- * agent's edit tool (a shell `sed`) still shows before anyone looks at it.
- */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-
-import type { SessionEditEvent } from '../session/headless/session-diffs';
-import { DraftStore, folderBuffers, type EditSlot, type FolderBuffers } from './drafts-store';
-import { useFilesHost } from './FilesProvider';
-import type { FilesScope, GitStatusEntry, WorkspaceFile } from './headless/host';
-import { filesRootOf, type FilesLayout, type FilesLayoutStore } from './headless/view';
-import { isUnder, movedPath } from './headless/entries';
-import { editedPath, sameFile, statusDelta } from './headless/workspace-diff';
-
-export interface OpenFile {
-  path: string;
-  /** null while loading; 'missing' when the read failed (moved, deleted, outside cwd). */
-  file: WorkspaceFile | null | 'missing';
-}
-
-export interface OpenFiles {
-  open: OpenFile[];
-  /** Unsaved editor contents per path (panel editing); subscribe per path with `useDraft` / `useIsDirty`. */
-  drafts: DraftStore;
-  /** `base`: the file the draft was typed against (kept with it for the save-conflict check). */
-  setDraft: (path: string, contents: string | null, base?: WorkspaceFile) => void;
-  /** pierre edit-session key for `path`; changes when the draft is reset. */
-  editKey: (path: string) => string;
-  /** Adopt `file` as the on-disk truth (after a save or a reload) and drop the draft. */
-  adoptFile: (path: string, file: WorkspaceFile, resetEditor?: boolean) => void;
-  /** Timestamp of our last save per path (diagnostics `save` trigger). */
-  savedAt: ReadonlyMap<string, number>;
-  activePath: string | null;
-  active: OpenFile | null;
-  setActivePath: (path: string | null) => void;
-  /** Open (or focus) `path` as a tab and load it. */
-  show: (path: string) => void;
-  /**
-   * Show `to` in `from`'s tab, in its place (stepping through a folder's media):
-   * no new tab piles up. When `to` is open already its tab is focused and
-   * `from`'s closes. A `from` with unsaved text keeps its tab: `to` opens as `show` does.
-   */
-  replace: (from: string, to: string) => void;
-  close: (path: string) => void;
-  /** Re-read every open file (the explicit Refresh). */
-  reloadAll: () => void;
-  /** `from` moved to `to` (a rename, a folder moved): its tabs follow, unsaved text included. */
-  moved: (from: string, to: string) => void;
-  /** `path` was removed (a folder whole): clean tabs close; a tab with unsaved text stays, shown missing. */
-  removed: (path: string) => void;
-}
-
-type TreePrefs = Pick<FilesLayout, 'filesShowIgnored' | 'filesTreeOpen' | 'filesChangedOnly'>;
-
-/** What the workspace hook knows about the latest changes. */
-export interface OpenFilesSource {
-  onToolResult: (handler: () => void) => () => void;
-  edits: readonly SessionEditEvent[];
-  status: readonly GitStatusEntry[];
-  /** The tab is on screen; while hidden a burst only marks files stale. */
-  visible: boolean;
-}
-
-/** A view with no folder: nothing to share, nothing to keep. */
-const NO_FOLDER = folderBuffers('');
-
-/**
- * The open files of a Files tab view.
- *
- * @param scope - The view's scope.
- * @param layout - The scope's layout as read now (only the mount reads it).
- * @param layoutStore - Where the open tabs, the active file and `prefs` are written back.
- * @param prefs - The tree toggles, written with the tabs.
- * @param source - What the workspace hook knows about the latest changes.
- */
-export function useOpenFiles(
-  scope: FilesScope,
-  layout: FilesLayout,
-  layoutStore: FilesLayoutStore,
-  prefs: TreePrefs,
-  source: OpenFilesSource,
-): OpenFiles {
-  const read = useFilesHost().read;
-  const cwd = filesRootOf(scope) || null;
-  const [open, setOpen] = useState<OpenFile[]>(() => layout.filesOpen.map((path) => ({ path, file: null })));
-  const [activePath, setActivePath] = useState<string | null>(layout.filesActive);
-  const buffers = cwd ? folderBuffers(cwd) : NO_FOLDER;
-  const drafts = buffers.drafts;
-  // Paths moved away from (`moved`): their viewer's unmount flush lands here after the move,
-  // whenever React commits it, and is dropped. A path leaves the set once a tab shows it again.
-  const retired = useRef(new Set<string>());
-  const setDraft = useCallback(
-    (path: string, contents: string | null, base?: WorkspaceFile) => {
-      if (contents !== null && retired.current.has(path)) return;
-      drafts.set(path, contents, base);
-    },
-    [drafts],
-  );
-  useEffect(() => {
-    for (const f of open) retired.current.delete(f.path);
-  }, [open]);
-  // The editor slots this view holds, per path (`FolderBuffers.claim`). Taken
-  // on first render of a path's key, given back when the tab closes or the view goes.
-  const holding = useRef<{ buffers: FolderBuffers; slots: Map<string, EditSlot> }>({ buffers, slots: new Map() });
-  // Another folder: start a new set (the old one is given back by the effect below).
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  if (holding.current.buffers !== buffers) holding.current = { buffers, slots: new Map() };
-  const slots = holding.current.slots;
-  const editKey = useCallback(
-    (path: string) => {
-      let held = slots.get(path);
-      if (!held) slots.set(path, (held = buffers.claim(path)));
-      return buffers.key(path, held);
-    },
-    [buffers, slots],
-  );
-  useEffect(() => {
-    const h = holding.current;
-    return () => {
-      for (const [p, s] of h.slots) h.buffers.release(p, s);
-      h.slots.clear();
-    };
-  }, [buffers]);
-  const resetEditSession = useCallback(
-    (path: string) => {
-      const held = slots.get(path);
-      if (held) slots.set(path, buffers.reset(path, held));
-    },
-    [buffers, slots],
-  );
-  const [savedAt, setSavedAt] = useState<ReadonlyMap<string, number>>(new Map());
-  const adoptFile = useCallback(
-    // eslint-disable-next-line react-hooks/preserve-manual-memoization -- the deps are the hook's stable inputs (setters, refs' owners)
-    (path: string, file: WorkspaceFile, resetEditor = false) => {
-      if (resetEditor) resetEditSession(path);
-      else setSavedAt((m) => new Map(m).set(path, Date.now()));
-      setOpen((current) => current.map((f) => (f.path === path && f.file !== file ? { path, file } : f)));
-      setDraft(path, null);
-    },
-    [setDraft, resetEditSession],
-  );
-
-  // Written on change only: a remount (the scope rebinding) must not re-stamp the layout.
-  const layoutRef = useRef(layoutStore);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  layoutRef.current = layoutStore;
-  useEffect(() => {
-    layoutRef.current.update({ filesOpen: open.map((f) => f.path), filesActive: activePath, ...prefs });
-  }, [open, activePath, prefs]);
-
-  // Open files that may be out of date (a burst passed while they were in the background).
-  const stale = useRef(new Set<string>());
-  const openRef = useRef(open);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  openRef.current = open;
-  const activeRef = useRef(activePath);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  activeRef.current = activePath;
-
-  // Newest read per path wins: a burst, a status move and a pick can each
-  // re-read the same file, and the answers may land out of order.
-  const reads = useRef(new Map<string, number>());
-  const reload = useCallback(
-    // eslint-disable-next-line react-hooks/preserve-manual-memoization -- the deps are the hook's stable inputs (setters, refs' owners)
-    async (path: string) => {
-      if (!cwd) return;
-      stale.current.delete(path);
-      const mine = (reads.current.get(path) ?? 0) + 1;
-      reads.current.set(path, mine);
-      const file = (read ? await read(cwd, path).catch(() => null) : null) ?? 'missing';
-      if (reads.current.get(path) !== mine) return;
-      reads.current.delete(path);
-      setOpen((current) => {
-        const idx = current.findIndex((f) => f.path === path);
-        // Same bytes at the same mtime: keep the object so the viewer and its diff skip the update.
-        if (idx === -1 || sameFile(current[idx].file, file)) return current;
-        const next = current.slice();
-        next[idx] = { path, file };
-        return next;
-      });
-    },
-    [read, cwd],
-  );
-
-  const reloadAll = useCallback(() => {
-    for (const f of openRef.current) void reload(f.path);
-  }, [reload]);
-
-  // A stale file is re-read when it comes on screen (picked, or the tab shown again).
-  const { visible } = source;
-  const visibleRef = useRef(visible);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  visibleRef.current = visible;
-  useEffect(() => {
-    if (visible && activePath && stale.current.has(activePath)) void reload(activePath);
-  }, [visible, activePath, reload]);
-
-  // Restored tabs start unloaded; fetch them once cwd is known.
-  useEffect(() => {
-    for (const f of openRef.current) if (f.file === null) void reload(f.path);
-  }, [cwd, reload]);
-
-  // Tool burst: re-read the active file and what the new edit events touched; the rest goes stale.
-  const seenEdits = useRef(new WeakSet<SessionEditEvent>());
-  const editsRef = useRef(source.edits);
-  // eslint-disable-next-line react-hooks/refs -- a latest-value ref: written in render, read by callbacks and effects
-  editsRef.current = source.edits;
-  const { onToolResult } = source;
-  useEffect(
-    () =>
-      onToolResult(() => {
-        const touched = new Set<string>();
-        for (const ev of editsRef.current) {
-          if (seenEdits.current.has(ev)) continue;
-          seenEdits.current.add(ev);
-          const p = editedPath(ev);
-          if (p !== null) touched.add(p);
-        }
-        for (const f of openRef.current) {
-          if (visibleRef.current && (f.path === activeRef.current || touched.has(f.path))) void reload(f.path);
-          else stale.current.add(f.path);
-        }
-      }),
-    [onToolResult, reload],
-  );
-  // Edits that landed before this tab mounted are already reflected in the first read.
-  useEffect(() => {
-    for (const ev of editsRef.current) seenEdits.current.add(ev);
-  }, []);
-
-  // Git status moved (after a burst, or a checkout): re-read open files whose status changed.
-  const lastStatus = useRef(source.status);
-  useEffect(() => {
-    const prev = lastStatus.current;
-    lastStatus.current = source.status;
-    if (prev === source.status) return;
-    const moved = statusDelta(prev, source.status);
-    if (moved.size === 0) return;
-    for (const f of openRef.current) if (moved.has(f.path) && f.path !== activeRef.current) void reload(f.path);
-  }, [source.status, reload]);
-
-  const show = useCallback(
-    // eslint-disable-next-line react-hooks/preserve-manual-memoization -- the deps are the hook's stable inputs (setters, refs' owners)
-    (path: string) => {
-      setOpen((current) => (current.some((f) => f.path === path) ? current : [...current, { path, file: null }]));
-      setActivePath(path);
-      void reload(path);
-    },
-    [reload],
-  );
-
-  const close = useCallback(
-    // eslint-disable-next-line react-hooks/preserve-manual-memoization -- the deps are the hook's stable inputs (setters, refs' owners)
-    (path: string) => {
-      const held = slots.get(path);
-      slots.delete(path);
-      // The last view of the file: closing discards its draft. Another
-      // view still showing it keeps the shared text.
-      const shared = buffers.holders(path) > (held ? 1 : 0);
-      if (held) buffers.release(path, held);
-      if (!shared) {
-        if (held) buffers.reset(path, held);
-        setDraft(path, null);
-        // The closing viewer flushes its draft as it unmounts (after this): drop that too,
-        // unless a view took the file again meanwhile.
-        setTimeout(() => {
-          if (buffers.holders(path) === 0) setDraft(path, null);
-        }, 0);
-      }
-      stale.current.delete(path);
-      setOpen((current) => {
-        const idx = current.findIndex((f) => f.path === path);
-        const next = current.filter((f) => f.path !== path);
-        setActivePath((active) =>
-          active === path ? (next[Math.max(0, Math.min(idx, next.length - 1))]?.path ?? null) : active,
-        );
-        return next;
-      });
-    },
-    [setDraft, buffers, slots],
-  );
-
-  const moved = useCallback(
-    // eslint-disable-next-line react-hooks/preserve-manual-memoization -- the deps are the hook's stable inputs (setters, refs' owners)
-    (from: string, to: string) => {
-      if (from === to) return;
-      const renames = openRef.current.flatMap((f) => {
-        const next = movedPath(f.path, from, to);
-        return next === null || next === f.path ? [] : [{ old: f.path, next }];
-      });
-      if (renames.length === 0) return;
-      for (const { old, next } of renames) {
-        // The unsaved text goes with the file; the old path's editor slot is given back.
-        const text = drafts.get(old);
-        const base = drafts.baseOf(old);
-        if (text !== undefined) drafts.set(next, text, base ? { ...base, path: next } : undefined);
-        const held = slots.get(old);
-        slots.delete(old);
-        if (held) buffers.release(old, held);
-        drafts.set(old, null);
-        // The old path's viewer flushes its draft as it unmounts (after this): `setDraft` drops it.
-        retired.current.add(old);
-        stale.current.delete(old);
-      }
-      const map = new Map(renames.map((r) => [r.old, r.next]));
-      setOpen((current) => current.map((f) => (map.has(f.path) ? { path: map.get(f.path)!, file: null } : f)));
-      setActivePath((current) => (current && map.has(current) ? map.get(current)! : current));
-      for (const { next } of renames) void reload(next);
-    },
-    [drafts, buffers, slots, reload],
-  );
-
-  const replace = useCallback(
-    // eslint-disable-next-line react-hooks/preserve-manual-memoization -- the deps are the hook's stable inputs (setters, refs' owners)
-    (from: string, to: string) => {
-      if (from === to) return;
-      if (drafts.has(from)) {
-        show(to);
-        return;
-      }
-      // `from`'s editor slot goes back, as on close.
-      const held = slots.get(from);
-      slots.delete(from);
-      if (held) buffers.release(from, held);
-      stale.current.delete(from);
-      setOpen((current) => {
-        if (current.some((f) => f.path === to)) return current.filter((f) => f.path !== from);
-        const at = current.findIndex((f) => f.path === from);
-        if (at === -1) return [...current, { path: to, file: null }];
-        return current.map((f, i) => (i === at ? { path: to, file: null } : f));
-      });
-      setActivePath(to);
-      void reload(to);
-    },
-    [drafts, show, slots, buffers, reload],
-  );
-
-  const removed = useCallback(
-    // eslint-disable-next-line react-hooks/preserve-manual-memoization -- the deps are the hook's stable inputs (setters, refs' owners)
-    (path: string) => {
-      for (const f of openRef.current) {
-        if (!isUnder(f.path, path)) continue;
-        if (drafts.has(f.path)) {
-          // Unsaved text is never dropped silently: the tab stays, its file shown gone.
-          setOpen((current) => current.map((o) => (o.path === f.path ? { path: o.path, file: 'missing' } : o)));
-        } else close(f.path);
-      }
-    },
-    [drafts, close],
-  );
-
-  const active = useMemo(() => open.find((f) => f.path === activePath) ?? null, [open, activePath]);
-  return useMemo(
-    () => ({
-      open,
-      drafts,
-      setDraft,
-      editKey,
-      adoptFile,
-      savedAt,
-      activePath,
-      active,
-      setActivePath,
-      show,
-      replace,
-      close,
-      reloadAll,
-      moved,
-      removed,
-    }),
-    [
-      open,
-      drafts,
-      setDraft,
-      editKey,
-      adoptFile,
-      savedAt,
-      activePath,
-      active,
-      setActivePath,
-      show,
-      replace,
-      close,
-      reloadAll,
-      moved,
-      removed,
-    ],
-  );
-}