zidane-ui 9.1.1 → 9.1.4

package/src/files/headless/host.ts

@@ -1,387 +0,0 @@
-/**
- * The files host: a folder's listing, its files (read, write, search), its
- * git status and working-tree diff, when its files may have moved, the
- * editor preferences, and what only some platforms do (project-tool
- * diagnostics, language servers, opening a path in another app, media
- * addresses). An app implements it once (the desktop app over IPC, a web
- * app over zidane-server) and hands it to `FilesProvider` (or
- * `AppHost.files`).
- *
- * Every member is optional: a host that leaves one out hides what needs it
- * (no `write`: the editor is read-only; no `workingTreeDiff`: the Diffs tab
- * has no working-tree source and changed files open plain; no `search`:
- * search in files matches names only; no `entries`: the tree creates, moves
- * and removes nothing). Paths are relative to the folder (`cwd`), which is
- * the files root of a scope (`filesRootOf`).
- */
-import type { EntryImportResult, EntryRefusal, EntryResult } from 'zidane/chat/pure';
-
-import type { EditorPrefs } from './editor-prefs';
-
-/** One entry of a folder listing. */
-export interface WorkspaceEntry {
-  /** Relative to the folder; directories end with `/` (only listed when empty). */
-  path: string;
-  /** A file or a folder. */
-  kind: 'file' | 'dir';
-  /** Gitignored (only present when listed with `showIgnored`). */
-  ignored?: boolean;
-}
-
-/** The media kinds a browser plays on its own. */
-export type MediaKind = 'image' | 'video' | 'audio' | 'pdf';
-
-/** A file the page shows as media, with its MIME type. */
-export interface MediaType {
-  /** How it is shown. */
-  kind: MediaKind;
-  /** Its MIME type. */
-  mime: string;
-}
-
-/** A file as read. */
-export interface WorkspaceFile {
-  /** Relative to the folder. */
-  path: string;
-  /** The text (empty for a binary or media file). */
-  contents: string;
-  /** Too large: `contents` is cut. */
-  truncated: boolean;
-  /** Size in bytes. */
-  size: number;
-  /** Not text. */
-  binary: boolean;
-  /** Version at read (a modification time, or any number that changes with the bytes); `write` refuses when it moved. */
-  mtimeMs: number;
-  /** A binary the page plays (an image, a video, audio), shown through `FilesHost.mediaUrl`. */
-  media?: MediaType;
-}
-
-/** What a guarded write did. */
-export type WorkspaceWriteResult =
-  | { ok: true; mtimeMs: number }
-  /** `changed`: the file moved since `expectedMtimeMs`; `missing`: it is gone; `denied`: outside the folder or unwritable. */
-  | { ok: false; reason: 'changed' | 'missing' | 'denied' };
-
-/** One path's git status. */
-export interface GitStatusEntry {
-  /** Relative to the folder. */
-  path: string;
-  /** What changed. */
-  status: 'added' | 'deleted' | 'ignored' | 'modified' | 'renamed' | 'untracked';
-}
-
-/** How text matches. */
-export interface TextMatchOptions {
-  /** Match case. */
-  caseSensitive: boolean;
-}
-
-/** One matching line of a search in files. */
-export interface ContentMatch {
-  /** Relative to the folder. */
-  path: string;
-  /** 1-based. */
-  line: number;
-  /** The line. */
-  text: string;
-  /** The matches in it, as UTF-16 offsets. */
-  ranges: { start: number; end: number }[];
-}
-
-/** A search in files. */
-export interface ContentSearchResult {
-  /** The matching lines. */
-  matches: ContentMatch[];
-  /** Stopped at the cap: there are more. */
-  capped: boolean;
-  /** What ran: ripgrep, `git grep`, a walk of the files, or nothing (empty query, superseded). */
-  engine: 'rg' | 'git' | 'walk' | 'none';
-  /** File contents can't be searched here (a sandboxed session); names still can. */
-  unsupported?: 'sandbox';
-}
-
-/** Options of {@link FilesHost.search}. */
-export interface ContentSearchOptions extends TextMatchOptions {
-  /** A later search with the same id cancels this one (one per search box). */
-  searchId: string;
-}
-
-/** What a view works from: a folder, optionally bound to a session (or the new-chat draft). */
-export interface FilesScope {
-  /** The project root. */
-  root: string;
-  /** Where things open. */
-  cwd: string;
-  /** Bound to this session. */
-  session?: string;
-  /** The new-chat draft's id. */
-  draft?: string;
-  /** Where a bound session's files live when they are not on this machine (`zidane-env://…`). */
-  workspace?: string;
-}
-
-/** Why a folder may have changed: a tool result in it, or the repository moving. */
-export type FolderChange = 'tool-result' | 'git';
-
-/** The severity of a finding. */
-export type DiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
-
-/** One finding from a project tool or a language server, positions 1-based like editors show them. */
-export interface Diagnostic {
-  /** Relative to the folder. */
-  path: string;
-  /** 1-based line. */
-  line: number;
-  /** 1-based column. */
-  column: number;
-  /** Last line. */
-  endLine?: number;
-  /** Last column. */
-  endColumn?: number;
-  /** How bad. */
-  severity: DiagnosticSeverity;
-  /** What it says. */
-  message: string;
-  /** Tool id (`tsc`, `eslint`, …). */
-  source: string;
-  /** Rule / error code (`TS2322`, `no-unused-vars`). */
-  code?: string;
-}
-
-/** A diagnostics run. */
-export interface DiagnosticsResult {
-  /** The findings. */
-  diagnostics: Diagnostic[];
-  /** Tools that ran (ids), for the "checked by" line. */
-  ran: string[];
-  /** Tools that failed or timed out, with a short reason. */
-  failed: { id: string; reason: string }[];
-}
-
-/** Options of {@link FilesDiagnostics.run}. */
-export interface DiagnosticsRunOptions {
-  /** Tool ids switched off. */
-  disabled: string[];
-  /** Per-command timeout. */
-  timeoutMs: number;
-  /** The files are open in a language server, which reports what the project-wide checks would: skip those. */
-  lsp: boolean;
-  /** Aborted when the caller no longer reads the answer (the file moved on, the view went): the backend may stop the run. */
-  signal?: AbortSignal;
-}
-
-/** The project's own linters and typecheckers. */
-export interface FilesDiagnostics {
-  /** Runs the tools on `paths` (cached by the backend until the files move). */
-  run(cwd: string, paths: string[], options: DiagnosticsRunOptions): Promise<DiagnosticsResult>;
-  /** Drops the cached results for the folder (the next run checks again). */
-  invalidate(cwd: string): Promise<void>;
-}
-
-/** A position in a file, 1-based. */
-export interface LspLocation {
-  /** Relative to the folder. */
-  path: string;
-  /** 1-based line. */
-  line: number;
-  /** 1-based column. */
-  column: number;
-}
-
-/** A definition target, and the symbol it was asked from when the server says. */
-export interface LspDefinition extends LspLocation {
-  /** The symbol in the asking file, 1-based, `endColumn` exclusive: what Cmd-hover underlines. */
-  origin?: { line: number; column: number; endLine: number; endColumn: number };
-}
-
-/** 0-based LSP range. */
-export interface LspRange {
-  /** Start. */
-  start: { line: number; character: number };
-  /** End. */
-  end: { line: number; character: number };
-}
-
-/** One incremental document change, LSP shape (0-based positions in the document before the change). */
-export interface LspTextChange {
-  /** What it replaces. */
-  range: LspRange;
-  /** The new text. */
-  text: string;
-}
-
-/** A hover answer; `busy` says why `text` may be missing (the server is still loading the project). */
-export interface LspHover {
-  /** The hover text (Markdown). */
-  text: string | null;
-  /** What the server is still doing. */
-  busy?: string;
-}
-
-/** One completion candidate, ready to insert. */
-export interface LspCompletionItem {
-  /** What the menu shows. */
-  label: string;
-  /** LSP kind as a word (`function`, `field`, `module`, …). */
-  kind?: string;
-  /** Shown after the label (signature, type, module). */
-  detail?: string;
-  /** Text that replaces `range` (snippet syntax already flattened). */
-  insertText: string;
-  /** 0-based range the item replaces; absent: the word before the caret. */
-  range?: LspRange;
-  /** What typing filters on (defaults to `label`). */
-  filterText?: string;
-  /** Sort key. */
-  sortText?: string;
-  /** Selected first. */
-  preselect?: boolean;
-  /** Where the caret lands inside `insertText`, as offsets; absent: its end. */
-  cursor?: { start: number; end: number };
-}
-
-/** A completion answer; `id` names it for {@link FilesLsp.resolveCompletion}. */
-export interface LspCompletionList {
-  /** The answer's id. */
-  id: number;
-  /** The candidates. */
-  items: LspCompletionItem[];
-  /** Typing on must ask again instead of filtering these. */
-  incomplete: boolean;
-  /** What the server is still doing. */
-  busy?: string;
-}
-
-/** The rest of a completion item, fetched when it is selected or accepted. */
-export interface LspCompletionDetail {
-  /** The item's detail. */
-  detail?: string;
-  /** Its documentation (Markdown). */
-  documentation?: string;
-  /** Edits elsewhere in the file applied with the item (an auto-import). */
-  additionalEdits?: { range: LspRange; newText: string }[];
-}
-
-/** Language servers: live findings while typing, hovers, completion and go to definition. */
-export interface FilesLsp {
-  /** The idle timeout and the per-server command overrides (the editor preferences). */
-  configure(options: { idleMs: number; overrides: Record<string, string> }): Promise<void>;
-  /** Opens the document (or sends a change: `changes` incremental, else the full text); resolves to the findings known now. */
-  open(cwd: string, path: string, text: string, changes?: LspTextChange[]): Promise<Diagnostic[]>;
-  /** Closes the document. */
-  close(cwd: string, path: string): Promise<void>;
-  /** Findings the server pushes for an open document. Returns the unsubscribe. */
-  onDiagnostics(listener: (cwd: string, path: string, diagnostics: Diagnostic[]) => void): () => void;
-  /** Where the symbol at a 1-based position is defined (several places for an overload; empty: nowhere known). */
-  definition(cwd: string, path: string, line: number, column: number): Promise<LspDefinition[]>;
-  /** The hover at a 1-based position. */
-  hover(cwd: string, path: string, line: number, column: number): Promise<LspHover>;
-  /** Completion at a 1-based position, sending the document's pending change with it. */
-  completion(
-    cwd: string,
-    path: string,
-    text: string,
-    changes: LspTextChange[] | undefined,
-    line: number,
-    column: number,
-    trigger?: string,
-  ): Promise<LspCompletionList>;
-  /** The rest of item `index` of answer `id`. */
-  resolveCompletion(cwd: string, path: string, id: number, index: number): Promise<LspCompletionDetail | null>;
-}
-
-/** What the platform does with a path outside the page. */
-export interface FilesSystem {
-  /** Whether files of `cwd` are on this machine (not a sandbox's or a server's): only those can be opened elsewhere. */
-  isLocal(cwd: string): boolean;
-  /** Opens an absolute path in the default editor. Resolves false when it could not. */
-  openPath(path: string): Promise<boolean>;
-  /** Shows an absolute path in the file manager. Resolves false when it could not. */
-  revealPath(path: string): Promise<boolean>;
-}
-
-/** A media file's address: as it is now, or one side of a working-tree change. */
-export type MediaSource =
-  | { kind: 'file'; cwd: string; path: string; version: number }
-  /** `path` as git diff names it; `old`: the last commit's, `new`: now; `version`: the side's blob id. */
-  | { kind: 'diff'; cwd: string; path: string; side: 'old' | 'new'; version?: string };
-
-/** Why an entry action was refused: a taken name, a source gone, an invalid name, no access, over the import limits. */
-export type FilesEntryRefusal = EntryRefusal;
-
-/** What an entry action did: the path it ended at, or why it was refused (`message`: the backend's own words). */
-export type FilesEntryResult = EntryResult;
-
-/** What an import did: the top-level paths it made, and why it stopped when it did. */
-export type FilesImportResult = EntryImportResult;
-
-/** One thing dropped from outside the page, taken while the drop lasts (a `DataTransfer` is emptied after it). */
-export interface DroppedItem {
-  /** The dropped file (a dropped folder too, where the platform hands folders as files). */
-  file: File;
-  /** Its entry, to walk a dropped folder (`webkitGetAsEntry`); `null` when the platform gives none. */
-  entry: FileSystemEntry | null;
-}
-
-/** How a folder's removals end: in the system trash (recoverable), or gone for good. */
-export type FilesRemoval = 'trash' | 'permanent';
-
-/**
- * Entry actions on a folder's files: what the tree's new file and folder,
- * rename, move, copy, delete and drops from outside run. Paths are relative
- * to the folder, never `..` or absolute. Nothing is overwritten: a create,
- * move or rename onto a taken name is refused (`exists`); a copy or an
- * import takes the next free name (`a copy.ts`). A refusal resolves; it
- * does not throw.
- */
-export interface FilesEntries {
-  /** Creates a file (empty) or a folder at `path`, making the folders on the way. */
-  create(cwd: string, path: string, kind: 'file' | 'dir'): Promise<FilesEntryResult>;
-  /** Moves (renames) `from` to `to`, making the folders on the way. */
-  move(cwd: string, from: string, to: string): Promise<FilesEntryResult>;
-  /** Copies `from` into folder `toDir` (`''`: the root) under its name, or the next free one. */
-  copy(cwd: string, from: string, toDir: string): Promise<FilesEntryResult>;
-  /** Removes `path` (a folder whole), where {@link removal} says. */
-  remove(cwd: string, path: string): Promise<FilesEntryResult>;
-  /** Brings what was dropped from outside the page into folder `dir`, each top-level item under a free name. */
-  importFiles(cwd: string, dir: string, items: readonly DroppedItem[]): Promise<FilesImportResult>;
-  /** Where {@link remove} sends `cwd`'s entries: the confirmation says so. */
-  removal(cwd: string): FilesRemoval;
-}
-
-/** The files host. Every member is optional. */
-export interface FilesHost {
-  /** The folder's entries (files, and empty folders). Rejects when the folder can't be read. */
-  list?(cwd: string, options?: { showIgnored?: boolean }): Promise<WorkspaceEntry[]>;
-  /** A file, or `null` when it is gone (moved, deleted, outside the folder). */
-  read?(cwd: string, path: string): Promise<WorkspaceFile | null>;
-  /** Writes a file, refused when its version moved past `expectedMtimeMs`. Absent: files are read-only. */
-  write?(cwd: string, path: string, contents: string, expectedMtimeMs: number): Promise<WorkspaceWriteResult>;
-  /** Creates, moves, copies, removes and imports entries. Absent: the tree only browses. */
-  entries?: FilesEntries;
-  /** Searches the folder's file contents. Absent: search in files matches names only. */
-  search?(cwd: string, query: string, options: ContentSearchOptions): Promise<ContentSearchResult>;
-  /** The folder's git status. Absent: no changed marks, no "changed only". */
-  gitStatus?(cwd: string): Promise<GitStatusEntry[]>;
-  /**
-   * The working tree against HEAD as a unified patch (untracked files included), the whole folder or one
-   * `path`, with `context` lines (`Infinity`: the whole file). Absent: no working-tree diffs.
-   */
-  workingTreeDiff?(cwd: string, options?: { path?: string; context?: number }): Promise<string>;
-  /**
-   * Calls `onChange` when files of the scope's folder may have moved (a tool result from a session working there,
-   * the repository moving), raw: callers settle bursts. Returns the unsubscribe. Absent: views refresh by hand.
-   */
-  watch?(scope: FilesScope, onChange: (why: FolderChange) => void): () => void;
-  /** The editor preferences. Absent: the defaults, unchangeable. */
-  editorPrefs?: EditorPrefs;
-  /** Project-tool diagnostics. Absent: no findings, no chip. */
-  diagnostics?: FilesDiagnostics;
-  /** Language servers. Absent: the `lsp` diagnostics mode runs project tools only. */
-  lsp?: FilesLsp;
-  /** Opening paths in other apps. Absent: no "Open in editor" / "Reveal" actions. */
-  system?: FilesSystem;
-  /** The address a media file plays from. Absent: media files show as binary. */
-  mediaUrl?(source: MediaSource): string;
-}

package/src/files/headless/index.ts

@@ -1,14 +0,0 @@
-/**
- * `zidane-ui/files/headless`: the Files and Diffs tabs' React-free half. The
- * `FilesHost` an app implements (listing, reading, writing, searching, git
- * status and the working-tree diff, folder changes, diagnostics, language
- * servers), the editor preferences model and its `Storage`-backed store,
- * the per-scope view state and the labels.
- */
-export * from './host';
-export * from './editor-prefs';
-export * from './view';
-export * from './labels';
-export * from './entries';
-export { matchRanges } from './search';
-export { mediaTypeOfPath } from './media';

package/src/files/headless/labels.ts

@@ -1,123 +0,0 @@
-/**
- * The Files and Diffs tabs' strings (the desktop app's wording). One flat
- * dictionary an app overrides with `<LabelsProvider>` or the `labels` prop of
- * `FilesProvider`. Keys you leave out keep the default English label.
- */
-
-const plural = (n: number, one: string, many: string) => (n === 1 ? one : many);
-
-/** The default English strings of the Files and Diffs tabs. Override any of them through `FilesProvider`. */
-export const DEFAULT_FILES_LABELS = {
-  // Folders
-  filesNoFolder: 'No folder',
-  filesSessionNoFolder: 'This session has no folder',
-  // The tree
-  filesShowTree: 'Show tree',
-  filesHideTree: 'Hide tree',
-  filesSearchFiles: 'Search files',
-  filesClearSearch: 'Clear search',
-  filesAllFiles: 'All files',
-  filesChangedOnly: 'Changed only',
-  filesShowIgnored: 'Show ignored',
-  filesHideIgnored: 'Hide ignored',
-  filesRefresh: 'Refresh',
-  filesNoChanged: 'No changed files',
-  filesEmptyFolder: 'Empty folder',
-  // Open files
-  filesOpenFiles: 'Open files',
-  filesPickFile: 'Pick a file to view it',
-  filesNotFound: 'File not found at this path',
-  filesBinary: 'Binary file',
-  filesTooLarge: (kb: number) => `Too large to preview (${kb} KB)`,
-  filesPlainView: 'Plain view',
-  filesShowChanges: 'Show changes',
-  filesShowChangesLarge: 'Show changes (large file)',
-  filesOpenEditor: 'Editor',
-  filesRevealFinder: 'Finder',
-  filesFindInDiff: 'Find in diff',
-  filesGoToDefinition: 'Go to definition (⌘-click)',
-  filesMediaFailed: (name: string) => `${name} could not be shown.`,
-  filesImageSize: (name: string, width: number, height: number) => `${name} (${width}×${height})`,
-  // Path actions
-  filesAddToChat: 'Add to chat',
-  filesCopyPath: 'Copy path',
-  filesCopyRelativePath: 'Copy relative path',
-  filesOpenInEditor: 'Open in editor',
-  filesOpenFolderInEditor: 'Open folder in editor',
-  filesRevealInFinder: 'Reveal in Finder',
-  filesNoChat: 'No chat to add to here',
-  // Entries
-  filesNewFile: 'New file',
-  filesNewFolder: 'New folder',
-  filesRename: 'Rename',
-  filesDuplicate: 'Duplicate',
-  filesCut: 'Cut',
-  filesCopy: 'Copy',
-  filesPaste: 'Paste',
-  filesDelete: 'Delete',
-  filesDeleteTitle: (name: string, count: number) => (count > 1 ? `Delete ${count} items?` : `Delete ${name}?`),
-  filesDeleteToTrash: 'You can restore it from the Trash.',
-  filesDeletePermanent: "It is deleted for good: this can't be undone.",
-  filesDeleteConfirm: 'Delete',
-  filesMoveToTrash: 'Move to Trash',
-  filesEntryExists: 'That name is already taken here.',
-  filesEntryMissing: "It isn't there anymore.",
-  filesEntryInvalid: "That name can't be used.",
-  filesEntryDenied: "That can't be done here.",
-  filesEntryTooLarge: 'Too much to bring in at once (50 MB, 20 MB per file).',
-  filesDropHere: 'Drop to copy here',
-  filesDismiss: 'Dismiss',
-  // Review
-  filesSelection: 'selection',
-  filesAddWhatToChat: (what: string) => `Add ${what} to chat`,
-  filesCommentOn: (what: string) => `Comment on ${what}`,
-  filesCopyWhat: (what: string) => `Copy ${what}`,
-  filesToAdd: 'to add',
-  filesSelectedLines: 'Selected lines',
-  filesBlankLines: '(blank lines)',
-  filesMoreLines: (count: number) => `… ${count} more`,
-  filesCommentPlaceholder: 'What should change here?',
-  filesCancel: 'Cancel',
-  filesAddToPrompt: 'Add to prompt',
-  // Diagnostics
-  filesChecking: 'Checking…',
-  filesCheckFailed: (tools: readonly string[]) => `Check failed: ${tools.join(', ')}`,
-  filesNoTool: 'No tool for this file',
-  filesCheckedBy: (ran: readonly string[], failed: readonly string[]) =>
-    `Checked by ${ran.join(', ')}.${failed.length ? ` Failed: ${failed.join(', ')}.` : ''} Click to re-run.`,
-  filesLanguageServer: 'language server',
-  // Search
-  filesSearchInFiles: 'Search in files',
-  filesSearchInChanges: 'Search in changes',
-  filesSearching: 'Searching…',
-  filesSearchNamesOnly: 'Only file names can be searched in a sandboxed session.',
-  filesNoResults: 'No results',
-  filesNameHits: (count: number, more: boolean) => `${count}${more ? '+' : ''} ${plural(count, 'name', 'names')}`,
-  filesLineHits: (count: number, more: boolean, files: number) =>
-    `${count}${more ? '+' : ''} ${plural(count, 'match', 'matches')} in ${files} ${plural(files, 'file', 'files')}`,
-  filesMatchCase: 'Match case',
-  filesCloseSearch: 'Close search',
-  filesCloseSearchHint: 'Close (Esc)',
-  filesFileNames: 'File names',
-  filesMatchingLines: 'Matching lines',
-  filesMatchLine: (path: string, line: number, text: string) => `${path} line ${line}: ${text}`,
-  // Diffs
-  filesDiffsToolbar: 'Diffs',
-  filesDiffSource: 'Diff source',
-  filesSourceSession: 'Session',
-  filesSourceWorking: 'Working tree',
-  filesShowFileList: 'Show file list',
-  filesHideFileList: 'Hide file list',
-  filesSplit: 'Split',
-  filesWrap: 'Wrap',
-  filesNoChangesYet: 'No changes yet',
-  filesNoChangesHint: "The agent's edits in this session show up here.",
-  filesWorkingTreeClean: 'Working tree clean',
-  filesNoWorkingTree: 'No working-tree changes here',
-  filesFindInDiffs: 'Find in diffs',
-  filesBefore: 'Before',
-  filesAfter: 'After',
-};
-
-/** The shape of the files label dictionary. Some values are functions that build a string. */
-export type FilesLabels = typeof DEFAULT_FILES_LABELS;

package/src/files/headless/lsp-edits.ts

@@ -1,58 +0,0 @@
-/**
- * Edits made in the panel editor since the language server last saw the
- * document, per (cwd, path). `CodeViewer` records them as pierre reports
- * them; `useLsp` takes the batch when its debounce fires and sends it as an
- * incremental `didChange`. Anything that reseeds the document (discard,
- * external reload) calls `resetEdits` so the next sync ships the full text.
- * Nothing takes the edits of a document no language server has open, so a
- * batch past `MAX_CHANGES` gives up and the next sync ships the full text,
- * and a document's buffer goes when the server closes it (`forgetEdits`).
- */
-import type { LspTextChange } from './host';
-
-const MAX_CHANGES = 1000;
-
-const buffers = new Map<string, { changes: LspTextChange[]; complete: boolean }>();
-
-const key = (cwd: string, path: string) => `${cwd}\0${path}`;
-
-export function recordEdits(cwd: string, path: string, changes: readonly LspTextChange[]): void {
-  const k = key(cwd, path);
-  const buf = buffers.get(k) ?? { changes: [], complete: true };
-  if (buf.complete) buf.changes.push(...changes);
-  if (buf.changes.length > MAX_CHANGES) {
-    buf.changes = [];
-    buf.complete = false;
-  }
-  buffers.set(k, buf);
-}
-
-/** The document was replaced wholesale: whatever was buffered no longer describes it. */
-export function resetEdits(cwd: string, path: string): void {
-  buffers.set(key(cwd, path), { changes: [], complete: false });
-}
-
-/**
- * Edits since the last take, or `undefined` when the caller must send the
- * full text (no complete history for this document).
- */
-export function takeEdits(cwd: string, path: string): LspTextChange[] | undefined {
-  const k = key(cwd, path);
-  const buf = buffers.get(k);
-  buffers.set(k, { changes: [], complete: true });
-  if (!buf || !buf.complete) return undefined;
-  return buf.changes;
-}
-
-/** The server closed the document: its next open starts from the full text. */
-export function forgetEdits(cwd: string, path: string): void {
-  buffers.delete(key(cwd, path));
-}
-
-export function __resetLspEditsForTests(): void {
-  buffers.clear();
-}
-
-export function __lspEditBuffersForTests(): number {
-  return buffers.size;
-}

package/src/files/headless/media.ts

@@ -1,57 +0,0 @@
-/**
- * Media a page shows in place of "Binary file": the formats a browser
- * decodes on its own, by file extension. Anything else stays binary.
- */
-import type { MediaType } from './host';
-
-const BY_EXTENSION: Readonly<Record<string, MediaType>> = {
-  png: { kind: 'image', mime: 'image/png' },
-  jpg: { kind: 'image', mime: 'image/jpeg' },
-  jpeg: { kind: 'image', mime: 'image/jpeg' },
-  gif: { kind: 'image', mime: 'image/gif' },
-  webp: { kind: 'image', mime: 'image/webp' },
-  avif: { kind: 'image', mime: 'image/avif' },
-  svg: { kind: 'image', mime: 'image/svg+xml' },
-  bmp: { kind: 'image', mime: 'image/bmp' },
-  ico: { kind: 'image', mime: 'image/x-icon' },
-  mp4: { kind: 'video', mime: 'video/mp4' },
-  m4v: { kind: 'video', mime: 'video/mp4' },
-  webm: { kind: 'video', mime: 'video/webm' },
-  ogv: { kind: 'video', mime: 'video/ogg' },
-  mov: { kind: 'video', mime: 'video/quicktime' },
-  mp3: { kind: 'audio', mime: 'audio/mpeg' },
-  wav: { kind: 'audio', mime: 'audio/wav' },
-  ogg: { kind: 'audio', mime: 'audio/ogg' },
-  oga: { kind: 'audio', mime: 'audio/ogg' },
-  m4a: { kind: 'audio', mime: 'audio/mp4' },
-  flac: { kind: 'audio', mime: 'audio/flac' },
-  pdf: { kind: 'pdf', mime: 'application/pdf' },
-};
-
-/**
- * The media a path names, by its extension; `null` for everything else.
- *
- * @param path - A file path.
- */
-export function mediaTypeOfPath(path: string): MediaType | null {
-  const name = path.slice(path.lastIndexOf('/') + 1).toLowerCase();
-  const dot = name.lastIndexOf('.');
-  return dot > 0 ? (BY_EXTENSION[name.slice(dot + 1)] ?? null) : null;
-}
-
-/**
- * The media files in a path's folder (not its subfolders), sorted by name,
- * and where the path is among them: what the Files editor steps through.
- * `null` when the path is not one of them.
- *
- * @param paths - Every listed file path, relative to the workspace.
- * @param path - The file on show.
- */
-export function mediaSiblings(paths: readonly string[], path: string): { paths: string[]; index: number } | null {
-  const folder = path.slice(0, path.lastIndexOf('/') + 1);
-  const siblings = paths
-    .filter((p) => p.startsWith(folder) && !p.includes('/', folder.length) && mediaTypeOfPath(p) !== null)
-    .sort((a, b) => a.localeCompare(b));
-  const index = siblings.indexOf(path);
-  return index === -1 ? null : { paths: siblings, index };
-}

package/src/files/headless/name-match.ts

@@ -1,38 +0,0 @@
-/**
- * File names matching a query, best first: the query in the file name
- * before the query only in its folders, then an earlier hit, then the
- * shorter file name (the tighter match), then the shorter path.
- */
-import type { TextMatchOptions } from './host';
-import { matchRanges } from './search';
-
-function basename(path: string): string {
-  const trimmed = path.replace(/[/\\]+$/, '');
-  return trimmed.slice(Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\')) + 1);
-}
-
-/**
- * The paths whose file name (or, ranked after, folders) contain `query`, best first, at most `limit`.
- *
- * @param paths - The folder's file paths.
- * @param query - What to find.
- * @param opts - Whether case matters.
- * @param limit - How many to return.
- */
-export function nameMatches(paths: readonly string[], query: string, opts: TextMatchOptions, limit = 50): string[] {
-  if (!query) return [];
-  const scored: { path: string; rank: number; base: number }[] = [];
-  for (const path of paths) {
-    const base = basename(path);
-    const inBase = matchRanges(base, query, opts)[0];
-    if (inBase) {
-      scored.push({ path, rank: inBase.start, base: base.length });
-      continue;
-    }
-    if (matchRanges(path, query, opts).length > 0) scored.push({ path, rank: 10_000, base: base.length });
-  }
-  scored.sort(
-    (a, b) => a.rank - b.rank || a.base - b.base || a.path.length - b.path.length || a.path.localeCompare(b.path),
-  );
-  return scored.slice(0, limit).map((s) => s.path);
-}