@cursor/july 0.1.103 → 0.1.105

package/src/filesystem.ts

@@ -0,0 +1,2074 @@
+import { Buffer } from "node:buffer";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import path from "node:path";
+import type { ToolName } from "@cursor/sdk";
+import { minimatch } from "minimatch";
+import { FileConflictError } from "./files.js";
+import {
+  EditError,
+  FileNotFoundError,
+  InvalidGrepPatternError,
+  isFileNotFoundError,
+  isInvalidGrepPatternError,
+  NoMountError,
+  PathError,
+  ReadOnlyMountError,
+  remapPathError,
+  WriteFailedError,
+} from "./internal/filesystem/errors.js";
+import { MEMORY_DIR_NAME } from "./memory.js";
+
+export {
+  DeleteNotSupportedError,
+  EditError,
+  FileNotFoundError,
+  InvalidGrepPatternError,
+  isFileNotFoundError,
+  isInvalidGrepPatternError,
+  NoMountError,
+  PathError,
+  ReadOnlyMountError,
+  WriteFailedError,
+} from "./internal/filesystem/errors.js";
+
+import { mergeSorted } from "./internal/filesystem/merge.js";
+import {
+  listFilesFromPaths,
+  mergeSortedByPath,
+  statFromFilePaths,
+} from "./internal/filesystem/walk.js";
+import type { HostFilesApi, HostFilesScope } from "./types.js";
+
+/**
+ * Status envelope used by walk helpers such as `lsFromList`.
+ * FileSystem methods throw; they do not return this.
+ * `@cursor/july` does not export it.
+ */
+export type FileSystemResult<T> =
+  | { status: "success"; value: T }
+  | { status: "error"; error: { message: string } };
+
+/**
+ * One file in a `list` / `glob` stream.
+ *
+ * `path` is an absolute posix path (`/src/a.ts`). No trailing slash
+ * except `/`. `size` is optional byte length of the file contents.
+ */
+export interface DirEntry {
+  path: string;
+  size?: number;
+}
+
+/**
+ * Existence probe. `directory` means this path is a prefix of at
+ * least one file (virtual trees infer directories) or a real
+ * directory on disk. `missing` is a value, not an error.
+ */
+export type FileInfo =
+  | { kind: "file" }
+  | { kind: "directory" }
+  | { kind: "missing" };
+
+/**
+ * Native Grep `output_mode` envelope. Not a FileSystem method
+ * result. The `grep` verb yields {@link GrepResult}; synthesis
+ * shapes this union after draining the stream.
+ */
+export type GrepUnionResult =
+  | {
+      type: "content";
+      output: {
+        matches: Array<{
+          file: string;
+          lineNumber?: number;
+          line: string;
+          beforeContext?: string[];
+          afterContext?: string[];
+        }>;
+        totalMatches: number;
+      };
+    }
+  | { type: "files"; output: { files: string[]; count: number } }
+  | {
+      type: "count";
+      output: {
+        counts: Array<{ file: string; count: number }>;
+        total: number;
+      };
+    };
+
+/**
+ * One content hit from `grep`. `path` is absolute posix.
+ * `lineNumber` is 1-indexed. `line` is the full matching line,
+ * without the trailing newline.
+ */
+export interface GrepResult {
+  path: string;
+  lineNumber: number;
+  line: string;
+}
+
+/**
+ * Content-search query. No `output_mode` or `offset` (those
+ * belong to the native Grep tool).
+ *
+ * `pattern` is a JavaScript regular expression source. Invalid
+ * source must throw {@link InvalidGrepPatternError} with message
+ * `invalid grep pattern: ${pattern}`. `path` omitted / `""` /
+ * `"/"` searches the whole tree; a file path searches that file
+ * only. A slash-free `glob` (`*.ts`) matches the basename at any
+ * depth under `path`.
+ *
+ * `maxResults` is optional predicate pushdown: stop after this
+ * many hits so a remote or large tree does not materialize a
+ * full scan. Native Grep still applies `head_limit` / `offset`
+ * after the merge. Omitted means no FileSystem-level cap.
+ */
+export interface GrepQuery {
+  pattern: string;
+  path?: string;
+  glob?: string;
+  caseInsensitive?: boolean;
+  maxResults?: number;
+}
+
+/**
+ * One semantic hit from `search`. `path` is absolute posix.
+ * `score` is higher-is-better. Trees without an index yield
+ * nothing; they do not invent lexical stand-ins.
+ */
+export interface SearchResult {
+  path: string;
+  snippet: string;
+  score: number;
+}
+
+/**
+ * Semantic-search query. `targetDirectories` limits the scan
+ * when an index exists; omitted means the whole tree.
+ *
+ * `maxResults` is optional predicate pushdown: stop after this
+ * many hits so an index does not retrieve a large recall set.
+ * Native SemanticSearch still applies `numResults` after the
+ * merge. Omitted means no FileSystem-level cap.
+ */
+export interface SearchQuery {
+  query: string;
+  targetDirectories?: string[];
+  maxResults?: number;
+}
+
+/**
+ * Exact, non-overlapping str-replace. `oldText` / `newText` are
+ * literal strings, not regex. Splice must keep `$`, `$&`, `$1`
+ * in `newText` as written (`String.prototype.replace` must not
+ * be used).
+ */
+export interface EditQuery {
+  path: string;
+  oldText: string;
+  newText: string;
+  replaceAll?: boolean;
+}
+
+/**
+ * StrReplace success. `occurrencesModified` is the number of
+ * non-overlapping replacements (1 unless `replaceAll`).
+ */
+export interface EditResult {
+  occurrencesModified: number;
+}
+
+/**
+ * Path verbs for the tree the agent runs on.
+ *
+ * Every method is required. Trees without an index implement
+ * `search` as an empty iterator. Methods do not fall back to the
+ * host tree. Diagnostics are not a FileSystem concern.
+ *
+ * Paths are a single posix namespace rooted at `/`. Query paths
+ * and yielded paths are absolute (`/src/a.ts`). No trailing
+ * slash except `/`. `""`, `"/"`, and an omitted `prefix` / `dir`
+ * / `path` (where optional) mean the root. Prefix tests are
+ * path-segment: `/agent` matches `/agent/skills`, not
+ * `/agent-tools`.
+ *
+ * Async iterators are already sorted. `unionFs` k-way merges
+ * them and does not re-sort a source.
+ *
+ * - `list` / `glob`: lexicographic by `path`. Paths are unique.
+ * - `grep`: by `path`, then `lineNumber` ascending. Keep every hit.
+ * - `search`: by `score` descending, then `path` ascending.
+ *
+ * Native-tool pagination (`head_limit`, `offset`, `output_mode`,
+ * `numResults`) stays on the synthesized tools. `grep` /
+ * `search` take optional `maxResults` as predicate pushdown so
+ * a tree can stop retrieving once the tool's cap is known.
+ * Native `LS` is built from `list` + `stat`; there is no `ls`
+ * method.
+ *
+ * Errors (authors must follow these, not invent parallel
+ * spellings):
+ *
+ * - `list` / `stat` / `glob` must not throw for a missing path.
+ *   Missing is an empty iterator or `{ kind: "missing" }`.
+ * - `read` / `write` / `delete` throw {@link PathError}
+ *   for recoverable failures. `error.message` is the string the
+ *   synthesized native tool shows the model. `error.path` is the
+ *   absolute posix path the composer remaps.
+ * - `grep` throws for an invalid regex (and a missing host
+ *   search root). A missing virtual path yields nothing.
+ * - `search` yields nothing when there is no index. An index
+ *   failure may throw.
+ * - Missing-file message on `read` / `delete` is
+ *   `not found: ${path}` (normalized absolute posix).
+ */
+export interface FileSystem {
+  /**
+   * Recursive file scan under `prefix`. Files only; directories
+   * are inferred from path prefixes. A file is not under itself,
+   * so listing a file path is empty. Empty is not "missing"
+   * (`stat` answers that). Yields lexicographic unique
+   * {@link DirEntry} rows. Omitted / `""` / `"/"` means the root.
+   *
+   * Errors: none. A missing or file-path prefix yields an empty
+   * iterator. Do not throw.
+   */
+  list(prefix?: string): AsyncIterable<DirEntry>;
+  /**
+   * Existence probe: exact file, a prefix that has files, or
+   * missing. Does not throw. Native LS lists first and calls
+   * this only when the iterator is empty.
+   *
+   * Errors: none. Unknown paths are `{ kind: "missing" }`.
+   */
+  stat(path: string): Promise<FileInfo>;
+  /**
+   * Same scan as `list`, filtered by `pattern` relative to
+   * `dir`. Yields lexicographic unique {@link DirEntry} rows.
+   * `dir` omitted / `""` / `"/"` means the tree root. Matching
+   * is relative to `dir`, not basename-anywhere (`*.ts` under
+   * `/src` is `/src/a.ts`, not `/src/nested/c.ts`).
+   *
+   * Errors: none. A missing `dir` or a pattern that matches
+   * nothing yields an empty iterator. Do not throw for a bad
+   * glob (it matches nothing).
+   */
+  glob(pattern: string, dir?: string): AsyncIterable<DirEntry>;
+  /**
+   * Read the whole file. Text files return a string. Image
+   * bytes (`jpeg` / `png` / `gif` / `webp`) return a
+   * `Uint8Array` so native Read can base64 them into an image
+   * content part. Native Read applies `offset` / `limit` and
+   * numbers lines on text only.
+   *
+   * Errors (throw `Error`):
+   * - Missing file, or a virtual directory with no file inode:
+   *   `not found: ${path}`.
+   * - Host I/O (EISDIR, EACCES, …): the OS message, or the same
+   *   `not found: ${path}` fallback.
+   * - `unionFs` with no mount: `no mount for path: ${path}`.
+   */
+  read(path: string): Promise<string | Uint8Array>;
+  /**
+   * Content matches. No output-mode or offset. Honor
+   * `maxResults` when set. Yields {@link GrepResult} ordered
+   * by path, then line number.
+   *
+   * Errors (throw `Error`):
+   * - Invalid `pattern`: `invalid grep pattern: ${pattern}`.
+   * - Host search root does not exist: the OS message, or
+   *   `not found: ${searchRoot}`. Native Grep turns the throw
+   *   into `{ status: "error" }`.
+   *
+   * A missing virtual `path` yields nothing (not an error).
+   */
+  grep(query: GrepQuery): AsyncIterable<GrepResult>;
+  /**
+   * Create or overwrite a file. Parents are created as needed.
+   * Native Write formats `Wrote contents to ${path}` from the
+   * path. The Write tool maps native `fileText` onto `contents`.
+   *
+   * Errors (throw `Error`):
+   * - Host I/O: the OS message, or `write failed: ${path}`.
+   * - `unionFs` with no mount: `no mount for path: ${path}`.
+   * - A read-only mount may use `read-only mount` or
+   *   `read-only mount: ${path}`.
+   *
+   * Missing parents are not an error; create them. There is no
+   * `not found` for `write`.
+   */
+  write(path: string, contents: string): Promise<void>;
+  /**
+   * Remove one file. Directories are not deleted; listing them
+   * is empty and they have no inode of their own on a virtual
+   * tree.
+   *
+   * Errors (throw `Error`):
+   * - Missing file, or a virtual directory: `not found: ${path}`.
+   * - Host I/O: the OS message, or `not found: ${path}`.
+   * - `unionFs` with no mount: `no mount for path: ${path}`.
+   */
+  delete(path: string): Promise<void>;
+  /**
+   * Semantic hits. Trees without an index yield nothing (do
+   * not register the host index). Honor `maxResults` when set.
+   * Ordered by score descending, then path.
+   *
+   * Errors: none for a tree without an index (empty iterator).
+   * An index that fails mid-scan may throw; native
+   * SemanticSearch turns that into `{ status: "error" }` with
+   * the thrown message or `search failed`.
+   */
+  search(query: SearchQuery): AsyncIterable<SearchResult>;
+}
+
+export const FILE_SYSTEM_TOOL_NAMES = [
+  "Read",
+  "LS",
+  "Glob",
+  "Grep",
+  "Write",
+  "StrReplace",
+  "Delete",
+  "SemanticSearch",
+] as const;
+
+export type FileSystemToolName = (typeof FILE_SYSTEM_TOOL_NAMES)[number];
+
+const FILE_SYSTEM_TOOL_NAME_SET = new Set<string>(FILE_SYSTEM_TOOL_NAMES);
+
+const FILE_SYSTEM_TOOL_ALIASES: Readonly<Record<string, FileSystemToolName>> = {
+  read: "Read",
+  Read: "Read",
+  ls: "LS",
+  LS: "LS",
+  glob: "Glob",
+  Glob: "Glob",
+  grep: "Grep",
+  Grep: "Grep",
+  write: "Write",
+  Write: "Write",
+  edit: "StrReplace",
+  StrReplace: "StrReplace",
+  delete: "Delete",
+  Delete: "Delete",
+  semSearch: "SemanticSearch",
+  SemanticSearch: "SemanticSearch",
+};
+
+export function canonicalizeFileSystemToolName(
+  name: string
+): FileSystemToolName | undefined {
+  return FILE_SYSTEM_TOOL_ALIASES[name];
+}
+
+export function isFileSystemToolName(name: string): name is FileSystemToolName {
+  return FILE_SYSTEM_TOOL_NAME_SET.has(name);
+}
+
+export function isFileSystemToolAlias(name: string): boolean {
+  return canonicalizeFileSystemToolName(name) !== undefined;
+}
+
+/** Direct `callTool` names that mutate the tree and must wait on a busy turn. */
+export function isMutatingFileSystemTool(name: string): boolean {
+  const canonical = canonicalizeFileSystemToolName(name);
+  return (
+    canonical === "Write" ||
+    canonical === "StrReplace" ||
+    canonical === "Delete"
+  );
+}
+
+export function isFileSystemMethodPresent(
+  root: FileSystem,
+  method: keyof FileSystem
+): boolean {
+  return typeof root[method] === "function";
+}
+
+const ADVERTISED_FILE_SYSTEM_TOOL_NAMES: FileSystemToolName[] = [
+  "Read",
+  "LS",
+  "Glob",
+  "Grep",
+  "Write",
+  "StrReplace",
+  "Delete",
+  "SemanticSearch",
+];
+
+export function fileSystemToolNames(_root?: FileSystem): FileSystemToolName[] {
+  return [...ADVERTISED_FILE_SYSTEM_TOOL_NAMES];
+}
+
+function fileSystemMethodForTool(
+  name: FileSystemToolName
+): keyof FileSystem | undefined {
+  switch (name) {
+    case "Read":
+      return "read";
+    case "LS":
+      return "list";
+    case "Glob":
+      return "glob";
+    case "Grep":
+      return "grep";
+    case "Write":
+    case "StrReplace":
+      return "write";
+    case "Delete":
+      return "delete";
+    case "SemanticSearch":
+      return "search";
+  }
+}
+
+function fileSystemSatisfiesFileTool(root: FileSystem, name: string): boolean {
+  const canonical = canonicalizeFileSystemToolName(name);
+  if (canonical === undefined) {
+    return true;
+  }
+  const method = fileSystemMethodForTool(canonical);
+  return method !== undefined && isFileSystemMethodPresent(root, method);
+}
+
+export class FileSystemConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "FileSystemConfigError";
+  }
+}
+
+function allowlistHas(tools: readonly ToolName[], ...names: string[]): boolean {
+  return tools.some((name) => names.includes(name));
+}
+
+export function resolveRootHarnessAllowlist(
+  tools?: readonly ToolName[]
+): ToolName[] {
+  if (tools === undefined) {
+    // File verbs are synthesized, including SemanticSearch from
+    // `search`. Web tools are safe under the `/tmp` scratch
+    // overlay. Todos are harness conversation state. Do not
+    // unlock shell or task.
+    return ["webSearch", "webFetch", "updateTodos", "readTodos", "mcp"];
+  }
+  if (allowlistHas(tools, "shell", "Shell")) {
+    throw new FileSystemConfigError(
+      '`root` cannot be combined with `tools` containing `"shell"`. ' +
+        "Shell is not a FileSystem method and must not bind the host shell onto a virtual tree."
+    );
+  }
+  if (allowlistHas(tools, "task", "Task")) {
+    throw new FileSystemConfigError(
+      "`root` cannot list `task`: a child keeps the host toolset and " +
+        "would read the real workspace. Sharing `root` with subagents " +
+        "needs a Cursor SDK inherit, not an overridden Task tool."
+    );
+  }
+  if (allowlistHas(tools, "readLints", "ReadLints")) {
+    throw new FileSystemConfigError(
+      "`root` cannot list `readLints`: FileSystem has no diagnostics " +
+        "verb, so the host language service would run against the real workspace."
+    );
+  }
+  const extras = tools.filter((name) => !isFileSystemToolAlias(name));
+  return withMcpGrant(extras);
+}
+
+export function resolveFileSystemTools(options: {
+  root: FileSystem;
+  tools?: readonly ToolName[];
+}): ToolName[] {
+  const harness = resolveRootHarnessAllowlist(options.tools);
+  if (options.tools === undefined) {
+    return harness;
+  }
+  const implemented = fileSystemToolNames(options.root);
+  const missing: string[] = [];
+  for (const name of options.tools) {
+    if (!fileSystemSatisfiesFileTool(options.root, name)) {
+      missing.push(name);
+    }
+  }
+  if (missing.length > 0) {
+    throw new FileSystemConfigError(
+      `\`tools\` names FileSystem method(s) that are not implemented: ${missing.join(", ")}. ` +
+        `Implemented file tools: ${implemented.length > 0 ? implemented.join(", ") : "(none)"}.`
+    );
+  }
+  return harness;
+}
+
+export function withMcpGrant(tools: readonly ToolName[]): ToolName[] {
+  return tools.includes("mcp") ? [...tools] : [...tools, "mcp"];
+}
+
+/**
+ * Native Cursor SDK file tools replaced by synthesized FileSystem tools
+ * on every local turn. SDK allowlist names (`edit`, not `Write`).
+ */
+export const REPLACED_NATIVE_FILE_TOOLS: ToolName[] = [
+  "read",
+  "ls",
+  "grep",
+  "glob",
+  "edit",
+  "delete",
+];
+
+/**
+ * Host-default harness options: keep shell / webSearch / sandbox, but
+ * hide the native file tools the synthesized FileSystem now owns.
+ *
+ * Omitted `tools` leaves the SDK default set and only excludes the
+ * replaced natives. `[]` stays empty. A non-empty allowlist drops file
+ * aliases (those ride synthesized tools) and grants `mcp`.
+ */
+export function resolveHostHarnessToolOptions(tools?: readonly ToolName[]): {
+  tools?: ToolName[];
+  disallowedTools?: ToolName[];
+} {
+  if (tools === undefined) {
+    return { disallowedTools: [...REPLACED_NATIVE_FILE_TOOLS] };
+  }
+  if (tools.length === 0) {
+    return { tools: [] };
+  }
+  return {
+    tools: withMcpGrant(tools.filter((name) => !isReplacedHostFileAlias(name))),
+  };
+}
+
+/** File aliases host-default synthesizes. Native `semSearch` stays. */
+function isReplacedHostFileAlias(name: string): boolean {
+  const canonical = canonicalizeFileSystemToolName(name);
+  return canonical !== undefined && canonical !== "SemanticSearch";
+}
+
+export type GrepOutputMode = "content" | "files_with_matches" | "count";
+
+/** Decode a {@link FileSystem.read} result as UTF-8 text. */
+export function fileSystemText(content: string | Uint8Array): string {
+  return typeof content === "string"
+    ? content
+    : Buffer.from(content).toString("utf8");
+}
+
+/**
+ * Native Read image formats. Magic bytes first, then extension.
+ * Returns undefined for text (and for any other binary).
+ */
+export function detectImageMimeType(
+  bytes: Uint8Array,
+  filePath?: string
+): string | undefined {
+  if (
+    bytes.length >= 3 &&
+    bytes[0] === 0xff &&
+    bytes[1] === 0xd8 &&
+    bytes[2] === 0xff
+  ) {
+    return "image/jpeg";
+  }
+  if (
+    bytes.length >= 8 &&
+    bytes[0] === 0x89 &&
+    bytes[1] === 0x50 &&
+    bytes[2] === 0x4e &&
+    bytes[3] === 0x47
+  ) {
+    return "image/png";
+  }
+  if (
+    bytes.length >= 6 &&
+    bytes[0] === 0x47 &&
+    bytes[1] === 0x49 &&
+    bytes[2] === 0x46
+  ) {
+    return "image/gif";
+  }
+  if (
+    bytes.length >= 12 &&
+    bytes[0] === 0x52 &&
+    bytes[1] === 0x49 &&
+    bytes[2] === 0x46 &&
+    bytes[3] === 0x46 &&
+    bytes[8] === 0x57 &&
+    bytes[9] === 0x45 &&
+    bytes[10] === 0x42 &&
+    bytes[11] === 0x50
+  ) {
+    return "image/webp";
+  }
+  if (filePath === undefined) {
+    return undefined;
+  }
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) {
+    return "image/jpeg";
+  }
+  if (lower.endsWith(".png")) {
+    return "image/png";
+  }
+  if (lower.endsWith(".gif")) {
+    return "image/gif";
+  }
+  if (lower.endsWith(".webp")) {
+    return "image/webp";
+  }
+  return undefined;
+}
+
+export function fileSystemImage(
+  content: string | Uint8Array,
+  path: string
+): { mimeType: string; bytes: Uint8Array } | undefined {
+  if (!(content instanceof Uint8Array)) {
+    return undefined;
+  }
+  const mimeType = detectImageMimeType(content, path);
+  if (mimeType === undefined) {
+    return undefined;
+  }
+  return { mimeType, bytes: content };
+}
+
+function compileGrepPattern(
+  pattern: string,
+  caseInsensitive?: boolean,
+  path = "/"
+): RegExp {
+  try {
+    return new RegExp(pattern, caseInsensitive === true ? "i" : undefined);
+  } catch {
+    throw new InvalidGrepPatternError(pattern, path);
+  }
+}
+
+function* grepFileContent(args: {
+  path: string;
+  content: string;
+  regex: RegExp;
+}): Generator<GrepResult> {
+  const lines = args.content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (args.regex.test(line)) {
+      yield { path: args.path, lineNumber: i + 1, line };
+    }
+  }
+}
+
+function normalizeMaxResults(
+  maxResults: number | undefined
+): number | undefined {
+  if (maxResults === undefined || !Number.isFinite(maxResults)) {
+    return undefined;
+  }
+  return Math.max(0, Math.floor(maxResults));
+}
+
+async function* limitResults<T>(
+  source: AsyncIterable<T>,
+  maxResults: number | undefined
+): AsyncGenerator<T> {
+  const cap = normalizeMaxResults(maxResults);
+  if (cap === 0) {
+    return;
+  }
+  let n = 0;
+  for await (const item of source) {
+    yield item;
+    n++;
+    if (cap !== undefined && n >= cap) {
+      return;
+    }
+  }
+}
+
+function grepPushdownLimit(
+  query: GrepQuery,
+  opts: { outputMode: GrepOutputMode; headLimit?: number; offset: number }
+): number | undefined {
+  // Count and files_with_matches paginate after grouping by file.
+  // A line-level cap would hide later files once one file fills the window.
+  if (opts.outputMode === "count" || opts.outputMode === "files_with_matches") {
+    return query.maxResults;
+  }
+  const headLimit =
+    opts.headLimit !== undefined && opts.headLimit > 0
+      ? opts.headLimit
+      : undefined;
+  if (headLimit === undefined) {
+    return query.maxResults;
+  }
+  const toolCap = opts.offset + headLimit;
+  return query.maxResults === undefined
+    ? toolCap
+    : Math.min(query.maxResults, toolCap);
+}
+
+function compareGrepResult(left: GrepResult, right: GrepResult): number {
+  return left.path < right.path
+    ? -1
+    : left.path > right.path
+      ? 1
+      : left.lineNumber - right.lineNumber;
+}
+
+function compareSearchResult(left: SearchResult, right: SearchResult): number {
+  if (right.score !== left.score) {
+    return right.score - left.score;
+  }
+  return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
+}
+
+export async function collectGrepMatches(
+  root: FileSystem,
+  query: GrepQuery,
+  opts: { outputMode: GrepOutputMode; headLimit?: number; offset?: number }
+): Promise<GrepResult[]> {
+  const matches: GrepResult[] = [];
+  const offset = opts.offset !== undefined && opts.offset > 0 ? opts.offset : 0;
+  const headLimit =
+    opts.headLimit !== undefined && opts.headLimit > 0
+      ? opts.headLimit
+      : undefined;
+  const skippedFiles = new Set<string>();
+  const acceptedFiles = new Set<string>();
+  let skippedItems = 0;
+  let takenItems = 0;
+  const pushdown = grepPushdownLimit(query, {
+    outputMode: opts.outputMode,
+    offset,
+    ...(opts.headLimit === undefined ? {} : { headLimit: opts.headLimit }),
+  });
+  const grepQuery =
+    pushdown === undefined ? query : { ...query, maxResults: pushdown };
+  for await (const match of root.grep(grepQuery)) {
+    if (opts.outputMode === "content") {
+      if (skippedItems < offset) {
+        skippedItems++;
+        continue;
+      }
+      matches.push(match);
+      takenItems++;
+      if (headLimit !== undefined && takenItems >= headLimit) {
+        break;
+      }
+      continue;
+    }
+    if (skippedFiles.has(match.path)) {
+      continue;
+    }
+    if (!acceptedFiles.has(match.path)) {
+      if (skippedItems < offset) {
+        skippedFiles.add(match.path);
+        skippedItems++;
+        continue;
+      }
+      if (headLimit !== undefined && takenItems >= headLimit) {
+        break;
+      }
+      acceptedFiles.add(match.path);
+      takenItems++;
+    }
+    matches.push(match);
+  }
+  return matches;
+}
+
+export type GrepContentHit = GrepResult & {
+  beforeContext?: string[];
+  afterContext?: string[];
+};
+
+export function shapeGrepUnion(
+  matches: GrepContentHit[],
+  outputMode: GrepOutputMode
+): GrepUnionResult {
+  if (outputMode === "files_with_matches") {
+    const files = [...new Set(matches.map((match) => match.path))];
+    return { type: "files", output: { files, count: files.length } };
+  }
+  if (outputMode === "count") {
+    const counts = new Map<string, number>();
+    for (const match of matches) {
+      counts.set(match.path, (counts.get(match.path) ?? 0) + 1);
+    }
+    return {
+      type: "count",
+      output: {
+        counts: [...counts].map(([file, count]) => ({ file, count })),
+        total: matches.length,
+      },
+    };
+  }
+  return {
+    type: "content",
+    output: {
+      matches: matches.map((match) => ({
+        file: match.path,
+        lineNumber: match.lineNumber,
+        line: match.line,
+        ...(match.beforeContext === undefined
+          ? {}
+          : { beforeContext: match.beforeContext }),
+        ...(match.afterContext === undefined
+          ? {}
+          : { afterContext: match.afterContext }),
+      })),
+      totalMatches: matches.length,
+    },
+  };
+}
+
+export function normalizeFsPath(input: string): string {
+  const slashes = input.replace(/\\/g, "/");
+  if (slashes === "") {
+    return "/";
+  }
+  const withSlash = slashes.startsWith("/") ? slashes : `/${slashes}`;
+  const resolved = path.posix.normalize(withSlash);
+  if (resolved.length > 1 && resolved.endsWith("/")) {
+    return resolved.slice(0, -1);
+  }
+  return resolved === "." || resolved === "" ? "/" : resolved;
+}
+
+/** Path-segment prefix: `/agent` matches `/agent/skills`, not `/agent-tools`. */
+export function pathHasSegmentPrefix(args: {
+  path: string;
+  prefix: string;
+}): boolean {
+  const p = normalizeFsPath(args.path);
+  const pre = normalizeFsPath(args.prefix);
+  if (pre === "/") {
+    return true;
+  }
+  return p === pre || p.startsWith(`${pre}/`);
+}
+
+function matchGlob(relativePath: string, globPattern: string): boolean {
+  return minimatch(relativePath, globPattern, { dot: true, nocase: false });
+}
+
+function pathMatchesGlob(
+  filePath: string,
+  dir: string,
+  globPattern: string,
+  options: { matchBasename?: boolean } = {}
+): boolean {
+  const posixFile = filePath.replace(/\\/g, "/");
+  const posixDir = dir.replace(/\\/g, "/");
+  const relative =
+    posixDir === "/" || posixFile.startsWith(`${posixDir}/`)
+      ? posixDir === "/"
+        ? posixFile.replace(/^\//, "")
+        : posixFile.slice(posixDir.length + 1)
+      : posixFile.replace(/^\//, "");
+  if (
+    matchGlob(relative, globPattern) ||
+    matchGlob(posixFile.replace(/^\//, ""), globPattern)
+  ) {
+    return true;
+  }
+  // Native grep `--glob '*.ts'` matches the basename at any depth.
+  // Glob `*.ts` stays relative to `targetDirectory` and does not.
+  if (options.matchBasename === true && !globPattern.includes("/")) {
+    const slash = relative.lastIndexOf("/");
+    const base = slash === -1 ? relative : relative.slice(slash + 1);
+    return matchGlob(base, globPattern);
+  }
+  return false;
+}
+
+/**
+ * Resolve a per-send `workspaceFiles` key onto the virtual `/` namespace.
+ * Refuses paths that escape the root, and the reserved `memory` name.
+ * Host-default workspaces symlink `memory/` to durable agent state, so a
+ * seed under that name would write through the link.
+ */
+export function virtualWorkspaceWritePath(relativePath: string): string {
+  if (relativePath.includes("\0")) {
+    throw new FileSystemConfigError(
+      `Refusing to write outside the virtual root: ${relativePath}`
+    );
+  }
+  const posix = relativePath.replaceAll("\\", "/");
+  const base = "/virtual-root";
+  const target = path.posix.normalize(path.posix.join(base, posix));
+  if (target !== base && !target.startsWith(`${base}/`)) {
+    throw new FileSystemConfigError(
+      `Refusing to write outside the virtual root: ${relativePath}`
+    );
+  }
+  const sliced = target.slice(base.length);
+  const dest = sliced === "" ? "/" : sliced;
+  if (
+    pathHasSegmentPrefix({
+      path: dest,
+      prefix: `/${MEMORY_DIR_NAME}`,
+    })
+  ) {
+    throw new FileSystemConfigError(
+      `"${MEMORY_DIR_NAME}" is reserved for shared session memory; refusing to write ${relativePath}`
+    );
+  }
+  return dest;
+}
+
+export async function writeWorkspaceFilesToRoot(
+  root: FileSystem,
+  files: Record<
+    string,
+    string | { encoding: "base64"; data: string; mimeType?: string }
+  >
+): Promise<void> {
+  for (const [relativePath, contents] of Object.entries(files)) {
+    // Refuse escapes, then write the sanitized relative dest so
+    // `localFileSystem` joins against cwd and `tempFs` still normalizes
+    // `a.txt` → `/a.txt`. Never forward an absolute host path.
+    const dest = virtualWorkspaceWritePath(relativePath);
+    const relativeDest = dest.replace(/^\//, "");
+    if (relativeDest === "") {
+      throw new FileSystemConfigError(
+        `Refusing to write the virtual root: ${relativePath}`
+      );
+    }
+    const fileText =
+      typeof contents === "string"
+        ? contents
+        : Buffer.from(contents.data, "base64").toString("utf8");
+    try {
+      await root.write(relativeDest, fileText);
+    } catch (error) {
+      throw new FileSystemConfigError(
+        `workspaceFiles failed to write ${relativePath}: ${
+          error instanceof Error ? error.message : "write failed"
+        }`
+      );
+    }
+  }
+}
+
+function replaceLiteral(args: {
+  existing: string;
+  oldText: string;
+  newText: string;
+  replaceAll: boolean;
+}): string {
+  if (args.replaceAll) {
+    return args.existing.split(args.oldText).join(args.newText);
+  }
+  const index = args.existing.indexOf(args.oldText);
+  if (index === -1) {
+    return args.existing;
+  }
+  return (
+    args.existing.slice(0, index) +
+    args.newText +
+    args.existing.slice(index + args.oldText.length)
+  );
+}
+
+function countNonOverlapping(haystack: string, needle: string): number {
+  let count = 0;
+  let from = 0;
+  while (from <= haystack.length - needle.length) {
+    const index = haystack.indexOf(needle, from);
+    if (index === -1) {
+      break;
+    }
+    count++;
+    from = index + needle.length;
+  }
+  return count;
+}
+
+/**
+ * Exact, non-overlapping str-replace. Uniqueness is the FileSystem
+ * contract: more than one match fails unless `replaceAll`.
+ */
+function applyExactEdit(args: {
+  existing: string;
+  oldText: string;
+  newText: string;
+  replaceAll: boolean;
+  path: string;
+}): { contents: string; occurrencesModified: number } {
+  if (args.oldText === "") {
+    throw new EditError(args.path, "oldText is empty");
+  }
+  if (args.oldText === args.newText) {
+    throw new EditError(args.path, "oldText and newText are exactly the same");
+  }
+  const occurrences = countNonOverlapping(args.existing, args.oldText);
+  if (occurrences === 0) {
+    throw new EditError(
+      args.path,
+      "The string to replace was not found in the file"
+    );
+  }
+  if (occurrences > 1 && !args.replaceAll) {
+    throw new EditError(
+      args.path,
+      "The string to replace was found multiple times in the file. Use replace_all to replace all occurrences, or include more context to only edit one occurrence."
+    );
+  }
+  return {
+    contents: replaceLiteral({
+      existing: args.existing,
+      oldText: args.oldText,
+      newText: args.newText,
+      replaceAll: args.replaceAll,
+    }),
+    occurrencesModified: occurrences,
+  };
+}
+
+/**
+ * Exact str-replace as `read` + apply + `write`. Uniqueness is
+ * this helper's contract; FileSystem implementations do not
+ * implement edit. Native StrReplace calls this.
+ */
+export async function strReplaceOnFileSystem(
+  root: Pick<FileSystem, "read" | "write">,
+  query: EditQuery
+): Promise<EditResult> {
+  const existing = await root.read(query.path);
+  if (typeof existing !== "string") {
+    throw new EditError(query.path, `${query.path} is not text`);
+  }
+  const applied = applyExactEdit({
+    existing,
+    oldText: query.oldText,
+    newText: query.newText,
+    replaceAll: query.replaceAll === true,
+    path: query.path,
+  });
+  await root.write(query.path, applied.contents);
+  return { occurrencesModified: applied.occurrencesModified };
+}
+
+/** Native Read offset/limit: 1-indexed, negative offset counts from the end. */
+export function sliceReadContent(
+  content: string,
+  offset?: number,
+  limit?: number
+): string {
+  if (offset === undefined && limit === undefined) {
+    return content;
+  }
+  const lines = content === "" ? [] : content.split("\n");
+  const total = lines.length;
+  const effectiveOffset = offset ?? 1;
+  const effectiveLimit =
+    limit ?? (effectiveOffset < 0 ? Math.abs(effectiveOffset) : total);
+  const startIndex =
+    effectiveOffset < 0
+      ? Math.max(0, total + effectiveOffset)
+      : Math.max(0, effectiveOffset - 1);
+  const endIndex = Math.min(total, startIndex + effectiveLimit);
+  return lines.slice(startIndex, endIndex).join("\n");
+}
+
+async function* emptySearch(
+  _query: SearchQuery
+): AsyncGenerator<SearchResult> {}
+
+async function* emptyStream(): AsyncGenerator<never> {}
+
+/**
+ * A FileSystem with no files. Use as an overlay leaf or a missing
+ * catalog so a miss stays {@link FileNotFoundError} instead of
+ * {@link NoMountError}. Writes and deletes throw
+ * {@link ReadOnlyMountError} — an empty tree is never a sink.
+ */
+export function emptyFs(): FileSystem {
+  return {
+    list: () => emptyStream(),
+    glob: () => emptyStream(),
+    async *grep(query) {
+      compileGrepPattern(
+        query.pattern,
+        query.caseInsensitive,
+        query.path === undefined || query.path === ""
+          ? "/"
+          : normalizeFsPath(query.path)
+      );
+      yield* emptyStream();
+    },
+    search: emptySearch,
+    async stat(path) {
+      return statFromFilePaths([], path);
+    },
+    async read(path) {
+      throw new FileNotFoundError(normalizeFsPath(path));
+    },
+    async write(path) {
+      throw new ReadOnlyMountError(normalizeFsPath(path));
+    },
+    async delete(path) {
+      throw new ReadOnlyMountError(normalizeFsPath(path));
+    },
+  };
+}
+
+/**
+ * In-memory FileSystem for tests and fixtures. Keys are absolute
+ * posix paths (`/a.txt`) and are normalized on ingest. Honors the
+ * {@link FileSystem} order and path contracts.
+ * `search` is empty. Creates `/agent-tools` on first scratch
+ * write the same way any other path is created.
+ */
+export function tempFs(
+  files: Record<string, string | Uint8Array> = {}
+): FileSystem {
+  const store = new Map<string, string | Uint8Array>();
+  for (const [path, content] of Object.entries(files)) {
+    store.set(normalizeFsPath(path), content);
+  }
+
+  const listed = {
+    list(prefix?: string) {
+      return listFilesFromPaths(
+        [...store.entries()].map(([filePath, content]) => ({
+          path: filePath,
+          size:
+            typeof content === "string" ? content.length : content.byteLength,
+        })),
+        prefix
+      );
+    },
+    async stat(path: string) {
+      return statFromFilePaths(store.keys(), path);
+    },
+  };
+
+  return {
+    list(prefix) {
+      return listed.list(prefix);
+    },
+    async stat(path) {
+      return listed.stat(path);
+    },
+    async read(inputPath) {
+      const path = normalizeFsPath(inputPath);
+      const content = store.get(path);
+      if (content === undefined) {
+        throw new FileNotFoundError(path);
+      }
+      return content;
+    },
+    async *grep(query) {
+      yield* limitResults(uncapped(), query.maxResults);
+      async function* uncapped() {
+        const regex = compileGrepPattern(
+          query.pattern,
+          query.caseInsensitive,
+          query.path === undefined || query.path === ""
+            ? "/"
+            : normalizeFsPath(query.path)
+        );
+        const scope =
+          query.path === undefined || query.path === ""
+            ? "/"
+            : normalizeFsPath(query.path);
+        const exact = store.get(scope);
+        if (scope !== "/" && exact !== undefined) {
+          if (
+            query.glob !== undefined &&
+            !pathMatchesGlob(scope, scope, query.glob, {
+              matchBasename: true,
+            })
+          ) {
+            return;
+          }
+          yield* grepFileContent({
+            path: scope,
+            content: fileSystemText(exact),
+            regex,
+          });
+          return;
+        }
+        for await (const entry of listed.list(
+          scope === "/" ? undefined : scope
+        )) {
+          if (
+            query.glob !== undefined &&
+            !pathMatchesGlob(entry.path, scope, query.glob, {
+              matchBasename: true,
+            })
+          ) {
+            continue;
+          }
+          const content = store.get(entry.path);
+          if (content === undefined) {
+            continue;
+          }
+          yield* grepFileContent({
+            path: entry.path,
+            content: fileSystemText(content),
+            regex,
+          });
+        }
+      }
+    },
+    async *glob(pattern, dir) {
+      const scope =
+        dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
+      yield* globFromList(listed.list(scope === "/" ? undefined : scope), {
+        pattern,
+        dir: scope,
+      });
+    },
+    async write(inputPath, contents) {
+      store.set(normalizeFsPath(inputPath), contents);
+    },
+    async delete(inputPath) {
+      const path = normalizeFsPath(inputPath);
+      if (!store.has(path)) {
+        throw new FileNotFoundError(path);
+      }
+      store.delete(path);
+    },
+    search: emptySearch,
+  };
+}
+
+function fsErrorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error ? error.message : fallback;
+}
+
+function throwLocalReadError(error: unknown, filePath: string): never {
+  throw new FileNotFoundError(
+    filePath,
+    fsErrorMessage(error, `not found: ${filePath}`)
+  );
+}
+
+function skipWalkDir(name: string): boolean {
+  return name === ".git" || name === "node_modules";
+}
+
+async function walkLocalFiles(rootDir: string): Promise<string[]> {
+  const found: string[] = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === undefined) {
+      break;
+    }
+    let entries: Array<{
+      name: string;
+      isDirectory(): boolean;
+      isFile(): boolean;
+    }>;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      // Same as the pre-root host walk and native LS/Glob/Grep: Dirent
+      // isDirectory/isFile do not follow links, so workspace `memory/`
+      // and other symlinks are not enumerated. Exact-path read/stat still
+      // follow.
+      if (entry.isDirectory()) {
+        if (!skipWalkDir(entry.name)) {
+          stack.push(full);
+        }
+      } else if (entry.isFile()) {
+        found.push(full);
+      }
+    }
+  }
+  found.sort((left, right) => left.localeCompare(right));
+  return found;
+}
+
+async function* listLocalFiles(rootDir: string): AsyncGenerator<DirEntry> {
+  for (const filePath of await walkLocalFiles(rootDir)) {
+    yield { path: filePath };
+  }
+}
+
+/**
+ * Host-disk FileSystem. Relative paths resolve against `cwd`; absolute
+ * paths are used as-is — the same contract as Cursor SDK native file
+ * tools. `search` yields empty results (no host index).
+ *
+ * Internal. Not part of the public Agent SDK surface.
+ */
+export function localFileSystem(options: { cwd: string }): FileSystem {
+  const cwd = path.resolve(options.cwd);
+
+  const resolvePath = (input: string): string =>
+    path.isAbsolute(input) ? path.resolve(input) : path.resolve(cwd, input);
+
+  return {
+    async *list(prefix) {
+      const dirPath =
+        prefix === undefined || prefix === "" || prefix === "."
+          ? cwd
+          : resolvePath(prefix);
+      yield* listLocalFiles(dirPath);
+    },
+    async stat(probePath) {
+      const filePath = resolvePath(probePath);
+      try {
+        const info = await stat(filePath);
+        return { kind: info.isDirectory() ? "directory" : "file" } as const;
+      } catch {
+        return { kind: "missing" } as const;
+      }
+    },
+    async read(inputPath) {
+      const filePath = resolvePath(inputPath);
+      try {
+        const bytes = await readFile(filePath);
+        if (detectImageMimeType(bytes, filePath) !== undefined) {
+          return new Uint8Array(bytes);
+        }
+        return bytes.toString("utf8");
+      } catch (error) {
+        throwLocalReadError(error, filePath);
+      }
+    },
+    async *grep(query) {
+      yield* limitResults(uncapped(), query.maxResults);
+      async function* uncapped() {
+        const searchRoot = resolvePath(query.path ?? cwd);
+        const regex = compileGrepPattern(
+          query.pattern,
+          query.caseInsensitive,
+          searchRoot
+        );
+        let filesToSearch: string[];
+        try {
+          const info = await stat(searchRoot);
+          filesToSearch = info.isFile()
+            ? [searchRoot]
+            : await walkLocalFiles(searchRoot);
+        } catch (error) {
+          throwLocalReadError(error, searchRoot);
+        }
+        for (const filePath of filesToSearch) {
+          if (
+            query.glob !== undefined &&
+            !pathMatchesGlob(filePath, searchRoot, query.glob, {
+              matchBasename: true,
+            })
+          ) {
+            continue;
+          }
+          let content: string;
+          try {
+            content = await readFile(filePath, "utf8");
+          } catch {
+            continue;
+          }
+          yield* grepFileContent({ path: filePath, content, regex });
+        }
+      }
+    },
+    async *glob(pattern, dir) {
+      const dirPath =
+        dir === undefined || dir === "" || dir === "." ? cwd : resolvePath(dir);
+      yield* globFromList(listLocalFiles(dirPath), {
+        pattern,
+        dir: dirPath,
+      });
+    },
+    async write(inputPath, contents) {
+      const filePath = resolvePath(inputPath);
+      try {
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(filePath, contents, "utf8");
+      } catch (error) {
+        throw new WriteFailedError(
+          filePath,
+          fsErrorMessage(error, `write failed: ${filePath}`)
+        );
+      }
+    },
+    async delete(inputPath) {
+      const filePath = resolvePath(inputPath);
+      try {
+        await rm(filePath);
+      } catch (error) {
+        throwLocalReadError(error, filePath);
+      }
+    },
+    search: emptySearch,
+  };
+}
+
+interface MountEntry {
+  prefix: string;
+  fs: FileSystem;
+}
+
+function longestMount(
+  path: string,
+  mounts: MountEntry[]
+): MountEntry | undefined {
+  let best: MountEntry | undefined;
+  for (const mount of mounts) {
+    if (!pathHasSegmentPrefix({ path, prefix: mount.prefix })) {
+      continue;
+    }
+    if (best === undefined || mount.prefix.length > best.prefix.length) {
+      best = mount;
+    }
+  }
+  return best;
+}
+
+/** Namespace path → child path. `/host/a.md` on `/host` is `/a.md`. */
+function toChildPath(path: string, prefix: string): string {
+  if (prefix === "/") {
+    return path;
+  }
+  if (path === prefix) {
+    return "/";
+  }
+  if (path.startsWith(`${prefix}/`)) {
+    return path.slice(prefix.length);
+  }
+  return path;
+}
+
+/** Child path → namespace path. `/a.md` on `/host` is `/host/a.md`. */
+function toParentPath(path: string, prefix: string): string {
+  if (prefix === "/") {
+    return path;
+  }
+  if (path === "/" || path === "") {
+    return prefix;
+  }
+  return path.startsWith("/") ? `${prefix}${path}` : `${prefix}/${path}`;
+}
+
+async function* mapMountEntries(
+  source: AsyncIterable<DirEntry>,
+  prefix: string
+): AsyncIterable<DirEntry> {
+  try {
+    for await (const entry of source) {
+      yield { ...entry, path: toParentPath(entry.path, prefix) };
+    }
+  } catch (error) {
+    throw remapPathError(error, prefix);
+  }
+}
+
+async function* mapMountGrep(
+  source: AsyncIterable<GrepResult>,
+  prefix: string
+): AsyncIterable<GrepResult> {
+  try {
+    for await (const hit of source) {
+      yield { ...hit, path: toParentPath(hit.path, prefix) };
+    }
+  } catch (error) {
+    throw remapPathError(error, prefix);
+  }
+}
+
+async function* mapMountSearch(
+  source: AsyncIterable<SearchResult>,
+  prefix: string
+): AsyncIterable<SearchResult> {
+  try {
+    for await (const hit of source) {
+      yield { ...hit, path: toParentPath(hit.path, prefix) };
+    }
+  } catch (error) {
+    throw remapPathError(error, prefix);
+  }
+}
+
+function childSearchQuery(
+  query: SearchQuery,
+  prefix: string
+): SearchQuery | undefined {
+  if (
+    query.targetDirectories === undefined ||
+    query.targetDirectories.length === 0
+  ) {
+    return query;
+  }
+  const dirs: string[] = [];
+  for (const dir of query.targetDirectories) {
+    const normalized = normalizeFsPath(dir);
+    // `/` is every mount, the same way grep at `/` fans out.
+    if (normalized === "/") {
+      return { ...query, targetDirectories: undefined };
+    }
+    if (!pathHasSegmentPrefix({ path: normalized, prefix })) {
+      continue;
+    }
+    const child = toChildPath(normalized, prefix);
+    if (child === "/") {
+      return { ...query, targetDirectories: undefined };
+    }
+    dirs.push(child);
+  }
+  if (dirs.length === 0) {
+    return undefined;
+  }
+  return { ...query, targetDirectories: dirs };
+}
+
+/**
+ * Longest-prefix compose, path-segment match. Every verb is
+ * defined. Does not synthesize `shell`. `/agent` is not a
+ * prefix of `/agent-tools`.
+ *
+ * The record keys are mount points. Each child is a FileSystem
+ * rooted at `/`. `unionFs` strips the prefix on the way in and
+ * re-prefixes yields (and error paths) on the way out:
+ * `unionFs({ "/host": hostFs(...) })` — the child never sees
+ * `/host`.
+ *
+ * A path with no mount:
+ * - `read` / `write` / `delete`: throw
+ *   `no mount for path: ${path}`
+ * - `list` / `glob` / `grep`: empty iterator
+ * - `stat`: `{ kind: "missing" }` (`/` and exact mount prefixes
+ *   are `{ kind: "directory" }`)
+ *
+ * Root `list` / `glob` / `grep` / `search` k-way merge already
+ * sorted sources. List and glob use `unique` so an earlier
+ * mount shadows a later one; grep and search keep every hit.
+ */
+export function unionFs(mounts: Record<string, FileSystem>): FileSystem {
+  const entries: MountEntry[] = Object.entries(mounts).map(([prefix, fs]) => ({
+    prefix: normalizeFsPath(prefix),
+    fs,
+  }));
+  entries.sort((a, b) => b.prefix.length - a.prefix.length);
+
+  const noMount = (path: string): never => {
+    throw new NoMountError(path);
+  };
+
+  const forward = async <T>(
+    path: string,
+    run: (fs: FileSystem, childPath: string) => Promise<T>
+  ): Promise<T> => {
+    const mount = longestMount(path, entries);
+    if (mount === undefined) {
+      return noMount(path);
+    }
+    const childPath = toChildPath(path, mount.prefix);
+    try {
+      return await run(mount.fs, childPath);
+    } catch (error) {
+      throw remapPathError(error, mount.prefix);
+    }
+  };
+
+  const isRootPath = (value: string | undefined): boolean =>
+    value === undefined || value === "" || value === "/";
+
+  return {
+    async *list(prefix) {
+      if (isRootPath(prefix)) {
+        yield* mergeSortedByPath(
+          entries.map((mount) =>
+            mapMountEntries(mount.fs.list(), mount.prefix)
+          ),
+          { unique: true }
+        );
+        return;
+      }
+      const path = normalizeFsPath(prefix ?? "/");
+      const mount = longestMount(path, entries);
+      if (mount === undefined) {
+        return;
+      }
+      const childPath = toChildPath(path, mount.prefix);
+      yield* mapMountEntries(
+        mount.fs.list(childPath === "/" ? undefined : childPath),
+        mount.prefix
+      );
+    },
+    async stat(path) {
+      const normalized = normalizeFsPath(path);
+      if (normalized === "/") {
+        return { kind: "directory" } as const;
+      }
+      if (entries.some((entry) => entry.prefix === normalized)) {
+        return { kind: "directory" } as const;
+      }
+      const mount = longestMount(normalized, entries);
+      if (mount === undefined) {
+        return { kind: "missing" } as const;
+      }
+      return mount.fs.stat(toChildPath(normalized, mount.prefix));
+    },
+    async read(path) {
+      const normalized = normalizeFsPath(path);
+      return forward(normalized, (fs, childPath) => fs.read(childPath));
+    },
+    async write(path, contents) {
+      const normalized = normalizeFsPath(path);
+      return forward(normalized, (fs, childPath) =>
+        fs.write(childPath, contents)
+      );
+    },
+    async delete(path) {
+      const normalized = normalizeFsPath(path);
+      return forward(normalized, (fs, childPath) => fs.delete(childPath));
+    },
+    async *grep(query) {
+      yield* limitResults(uncapped(), query.maxResults);
+      async function* uncapped() {
+        const scope =
+          query.path === undefined || query.path === ""
+            ? "/"
+            : normalizeFsPath(query.path);
+        if (scope === "/") {
+          yield* mergeSorted(
+            entries.map((mount) =>
+              mapMountGrep(
+                mount.fs.grep({ ...query, path: undefined }),
+                mount.prefix
+              )
+            ),
+            { compare: compareGrepResult }
+          );
+          return;
+        }
+        const mount = longestMount(scope, entries);
+        if (mount === undefined) {
+          return;
+        }
+        const childPath = toChildPath(scope, mount.prefix);
+        yield* mapMountGrep(
+          mount.fs.grep({
+            ...query,
+            path: childPath === "/" ? undefined : childPath,
+          }),
+          mount.prefix
+        );
+      }
+    },
+    async *search(query) {
+      yield* limitResults(uncapped(), query.maxResults);
+      async function* uncapped() {
+        const sources: AsyncIterable<SearchResult>[] = [];
+        for (const mount of entries) {
+          const childQuery = childSearchQuery(query, mount.prefix);
+          if (childQuery === undefined) {
+            continue;
+          }
+          sources.push(
+            mapMountSearch(mount.fs.search(childQuery), mount.prefix)
+          );
+        }
+        yield* mergeSorted(sources, { compare: compareSearchResult });
+      }
+    },
+    async *glob(pattern, dir) {
+      const scope =
+        dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
+      if (scope === "/") {
+        yield* mergeSortedByPath(
+          entries.map((mount) =>
+            mapMountEntries(mount.fs.glob(pattern), mount.prefix)
+          ),
+          { unique: true }
+        );
+        return;
+      }
+      const mount = longestMount(scope, entries);
+      if (mount === undefined) {
+        return;
+      }
+      const childPath = toChildPath(scope, mount.prefix);
+      yield* mapMountEntries(
+        mount.fs.glob(pattern, childPath === "/" ? undefined : childPath),
+        mount.prefix
+      );
+    },
+  };
+}
+
+async function collectLayerPaths(layer: FileSystem): Promise<string[]> {
+  const paths: string[] = [];
+  try {
+    for await (const entry of layer.list()) {
+      paths.push(entry.path);
+    }
+  } catch {
+    // A layer that cannot list also cannot own paths.
+  }
+  return paths;
+}
+
+/**
+ * Same-root overlay: earlier layers win. Read-only.
+ *
+ * A downed layer costs its own files, not the overlay. Mutations
+ * throw `read-only mount` / `read-only mount: ${path}`. Empty
+ * `layers` throws `overlayFs needs at least one layer.`
+ */
+export function overlayFs(layers: readonly FileSystem[]): FileSystem {
+  if (layers.length === 0) {
+    throw new Error("overlayFs needs at least one layer.");
+  }
+
+  const walkLayers = async <T>(
+    collect: (layer: FileSystem) => AsyncIterable<T> | Promise<AsyncIterable<T>>
+  ): Promise<{ streams: T[][]; failure: unknown; served: boolean }> => {
+    const streams: T[][] = [];
+    let failure: unknown;
+    let served = false;
+    for (const layer of layers) {
+      const collected: T[] = [];
+      try {
+        for await (const entry of await collect(layer)) {
+          collected.push(entry);
+        }
+      } catch (error) {
+        failure ??= error;
+        continue;
+      }
+      served = true;
+      streams.push(collected);
+    }
+    return { streams, failure, served };
+  };
+
+  const collectOverlayHits = async <T extends { path: string }>(
+    queryFn: (layer: FileSystem) => AsyncIterable<T>,
+    rethrow?: (error: unknown) => boolean
+  ): Promise<T[][]> => {
+    const streams: T[][] = [];
+    const shadowed = new Set<string>();
+    let failure: unknown;
+    let served = false;
+    for (const layer of layers) {
+      const collected: T[] = [];
+      try {
+        for await (const hit of queryFn(layer)) {
+          if (!shadowed.has(hit.path)) {
+            collected.push(hit);
+          }
+        }
+        served = true;
+      } catch (error) {
+        if (rethrow?.(error) === true) {
+          throw error;
+        }
+        failure ??= error;
+        continue;
+      }
+      streams.push(collected);
+      for (const path of await collectLayerPaths(layer)) {
+        shadowed.add(path);
+      }
+    }
+    if (!served && failure !== undefined) {
+      throw failure;
+    }
+    return streams;
+  };
+
+  return {
+    async *list(prefix) {
+      const { streams, failure, served } = await walkLayers((layer) =>
+        layer.list(prefix)
+      );
+      if (!served && failure !== undefined) {
+        throw failure;
+      }
+      yield* mergeSortedByPath(streams, { unique: true });
+    },
+    async stat(path) {
+      let failure: unknown;
+      let sawMissing = false;
+      for (const layer of layers) {
+        try {
+          const info = await layer.stat(path);
+          if (info.kind !== "missing") {
+            return info;
+          }
+          sawMissing = true;
+        } catch (error) {
+          failure ??= error;
+        }
+      }
+      if (!sawMissing && failure !== undefined) {
+        throw failure;
+      }
+      return { kind: "missing" } as const;
+    },
+    async *glob(pattern, dir) {
+      const { streams, failure, served } = await walkLayers((layer) =>
+        layer.glob(pattern, dir)
+      );
+      if (!served && failure !== undefined) {
+        throw failure;
+      }
+      yield* mergeSortedByPath(streams, { unique: true });
+    },
+    async read(path) {
+      let failure: unknown;
+      for (const layer of layers) {
+        try {
+          return await layer.read(path);
+        } catch (error) {
+          if (isFileNotFoundError(error)) {
+            continue;
+          }
+          failure ??= error;
+        }
+      }
+      if (failure !== undefined) {
+        throw failure;
+      }
+      throw new FileNotFoundError(path);
+    },
+    async *grep(query) {
+      const { maxResults, ...uncappedQuery } = query;
+      yield* limitResults(
+        mergeSorted(
+          await collectOverlayHits(
+            (layer) => layer.grep(uncappedQuery),
+            (error) => isInvalidGrepPatternError(error)
+          ),
+          { compare: compareGrepResult }
+        ),
+        maxResults
+      );
+    },
+    async write(path) {
+      throw new ReadOnlyMountError(path);
+    },
+    async delete(path) {
+      throw new ReadOnlyMountError(path);
+    },
+    async *search(query) {
+      const { maxResults, ...uncappedQuery } = query;
+      yield* limitResults(
+        mergeSorted(
+          await collectOverlayHits((layer) => layer.search(uncappedQuery)),
+          { compare: compareSearchResult }
+        ),
+        maxResults
+      );
+    },
+  };
+}
+
+function hostKey(path: string): string {
+  const normalized = normalizeFsPath(path);
+  return normalized === "/" ? "" : normalized.slice(1);
+}
+
+function isHostConflict(error: unknown): boolean {
+  return (
+    error instanceof FileConflictError ||
+    (error instanceof Error &&
+      (error.name === "FileConflictError" ||
+        error.message.includes("lost a race")))
+  );
+}
+
+/**
+ * `HostFilesApi` as a FileSystem rooted at `/`.
+ *
+ * Mount it with `unionFs({ "/host": hostFs(files, scope) })`. The
+ * child never sees `/host` — `unionFs` owns the prefix. `scope` is
+ * the HostFiles partition, not a path prefix. `search` is empty
+ * (HostFiles is not an index).
+ */
+export function hostFs(files: HostFilesApi, scope: HostFilesScope): FileSystem {
+  const callOptions = { scope };
+  const readEtags = new Map<string, string>();
+
+  const listed = {
+    async *list(prefix?: string) {
+      const entries = await files.list(undefined, callOptions);
+      yield* listFilesFromPaths(
+        entries.map((entry) => ({
+          path: normalizeFsPath(entry.path),
+          size: entry.size,
+        })),
+        prefix
+      );
+    },
+    async stat(path: string) {
+      const entries = await files.list(undefined, callOptions);
+      return statFromFilePaths(
+        entries.map((entry) => normalizeFsPath(entry.path)),
+        path
+      );
+    },
+  };
+
+  const readText = async (inputPath: string): Promise<string> => {
+    const path = normalizeFsPath(inputPath);
+    const key = hostKey(path);
+    if (key === "") {
+      throw new FileNotFoundError(path);
+    }
+    const [content, stat] = await Promise.all([
+      files.read(key, callOptions),
+      files.stat(key, callOptions),
+    ]);
+    if (content === undefined) {
+      throw new FileNotFoundError(path);
+    }
+    if (stat?.etag !== undefined) {
+      readEtags.set(key, stat.etag);
+    }
+    return content;
+  };
+
+  const writeHost = async (
+    inputPath: string,
+    contents: string
+  ): Promise<void> => {
+    const path = normalizeFsPath(inputPath);
+    const key = hostKey(path);
+    if (key === "") {
+      throw new FileNotFoundError(path);
+    }
+    try {
+      if (files.capabilities.conflictDetection) {
+        const etag = readEtags.get(key);
+        await files.write(key, contents, {
+          ...callOptions,
+          // No cached etag: unconditional create/overwrite. After a
+          // successful read or write, CAS on that etag.
+          ...(etag === undefined ? {} : { ifMatch: etag }),
+        });
+      } else {
+        await files.write(key, contents, callOptions);
+      }
+    } catch (error) {
+      if (isHostConflict(error)) {
+        throw new PathError(
+          path,
+          `${path} changed since you read it — read it again and rewrite.`
+        );
+      }
+      throw error;
+    }
+    const stat = await files.stat(key, callOptions);
+    if (stat?.etag !== undefined) {
+      readEtags.set(key, stat.etag);
+    } else {
+      readEtags.delete(key);
+    }
+  };
+
+  return {
+    list(prefix) {
+      return listed.list(prefix);
+    },
+    async stat(path) {
+      return listed.stat(path);
+    },
+    async read(path) {
+      return readText(path);
+    },
+    async *grep(query) {
+      yield* limitResults(uncapped(), query.maxResults);
+      async function* uncapped() {
+        const scopePath =
+          query.path === undefined || query.path === ""
+            ? "/"
+            : normalizeFsPath(query.path);
+        const regex = compileGrepPattern(
+          query.pattern,
+          query.caseInsensitive,
+          scopePath
+        );
+        const info = await listed.stat(scopePath);
+        if (scopePath !== "/" && info.kind === "file") {
+          if (
+            query.glob !== undefined &&
+            !pathMatchesGlob(scopePath, scopePath, query.glob, {
+              matchBasename: true,
+            })
+          ) {
+            return;
+          }
+          yield* grepFileContent({
+            path: scopePath,
+            content: await readText(scopePath),
+            regex,
+          });
+          return;
+        }
+        for await (const entry of listed.list(
+          scopePath === "/" ? undefined : scopePath
+        )) {
+          if (
+            query.glob !== undefined &&
+            !pathMatchesGlob(entry.path, scopePath, query.glob, {
+              matchBasename: true,
+            })
+          ) {
+            continue;
+          }
+          yield* grepFileContent({
+            path: entry.path,
+            content: await readText(entry.path),
+            regex,
+          });
+        }
+      }
+    },
+    async *glob(pattern, dir) {
+      const dirPath =
+        dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
+      yield* globFromList(listed.list(dirPath === "/" ? undefined : dirPath), {
+        pattern,
+        dir: dirPath,
+      });
+    },
+    async write(inputPath, contents) {
+      await writeHost(inputPath, contents);
+    },
+    async delete(inputPath) {
+      const path = normalizeFsPath(inputPath);
+      const key = hostKey(path);
+      if (key === "" || !(await files.exists(key, callOptions))) {
+        throw new FileNotFoundError(path);
+      }
+      await files.remove(key, callOptions);
+      readEtags.delete(key);
+    },
+    search: emptySearch,
+  };
+}
+
+async function* globFromList(
+  source: AsyncIterable<DirEntry>,
+  options: { pattern: string; dir: string }
+): AsyncGenerator<DirEntry> {
+  for await (const entry of source) {
+    if (pathMatchesGlob(entry.path, options.dir, options.pattern)) {
+      yield entry;
+    }
+  }
+}