@youtyan/code-viewer 0.8.5 → 0.8.7

package/dist/code-viewer.js

@@ -996,11 +996,13 @@ function setTimedCacheEntry(cache, key, value, now = Date.now(), maxEntries = MA
     cache.delete(oldest);
   }
 }
+function fileSignatureFromStats(stats) {
+  const inode = stats.ino ?? 0;
+  return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
+}
 function worktreeFileSignature(path, cwd) {
   try {
-    const stats = lstatSync(join3(cwd, path));
-    const inode = "ino" in stats ? stats.ino : 0;
-    return `state:file|size:${stats.size}|mtime:${stats.mtimeMs}|ctime:${stats.ctimeMs}|ino:${inode}`;
+    return fileSignatureFromStats(lstatSync(join3(cwd, path)));
   } catch {
     return "state:missing";
   }
@@ -1407,17 +1409,15 @@ var init_runtime = () => {};
 
 // web-src/server/git.ts
 import {
-  closeSync,
   existsSync,
   lstatSync as lstatSync2,
-  openSync,
   readdirSync,
   readFileSync,
   readlinkSync,
-  readSync,
   realpathSync as realpathSync2,
   statSync as statSync2
 } from "node:fs";
+import { open, stat } from "node:fs/promises";
 import { dirname as dirname3, join as join4, posix, relative as relative2 } from "node:path";
 function normalizeBlameRef(ref, base) {
   const rawRef = ref || "worktree";
@@ -1449,18 +1449,13 @@ function resolveGitArgs(args) {
   return [commandForExternal("git"), ...args.slice(1)];
 }
 function gitFailureMessage(res, fallback) {
-  if (isCommandNotFoundResult("git", res))
-    return commandNotFoundDetail("git");
-  return res.stderr?.trim() || fallback;
+  const message = isCommandNotFoundResult("git", res) ? commandNotFoundDetail("git") : res.stderr?.trim() || fallback;
+  console.error(`[code-viewer] ${fallback} (git exit ${res.code}): ${message}`);
+  return message;
 }
 function gitFailureResult(res, fallback) {
-  if (!isCommandNotFoundResult("git", res)) {
-    return { error: fallback };
-  }
-  return {
-    error: commandNotFoundDetail("git"),
-    status: 503
-  };
+  const error = gitFailureMessage(res, fallback);
+  return isCommandNotFoundResult("git", res) ? { error, status: 503 } : { error };
 }
 function runGitRefLookup(args, cwd) {
   const res = run(args, cwd);
@@ -1485,9 +1480,6 @@ function repoRootResult(cwd) {
     return { kind: "outside" };
   return { kind: "error", error: stderr || "git rev-parse failed" };
 }
-function currentBranch(cwd) {
-  return runGitRefLookup(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd);
-}
 function currentBranchAsync(cwd) {
   return runGitRefLookupAsync(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd);
 }
@@ -1555,9 +1547,6 @@ async function repoStatusMapAsync(cwd, now = Date.now()) {
   setTimedCacheEntry(repoStatusMapCache, cwd, { map }, now);
   return map;
 }
-function show(ref, path, cwd) {
-  return run(["git", "show", `${ref}:${path}`], cwd);
-}
 function showAsync(ref, path, cwd) {
   return runGitAsync(["git", "show", `${ref}:${path}`], cwd);
 }
@@ -1849,12 +1838,6 @@ function parseRemoteWebUrl(remote) {
     return `https://${httpUrl[1]}/${httpUrl[2]}`;
   return null;
 }
-function remoteWebUrl(cwd) {
-  const res = run(["git", "remote", "get-url", "origin"], cwd);
-  if (res.code !== 0)
-    return null;
-  return parseRemoteWebUrl(res.stdout.trim());
-}
 async function remoteWebUrlAsync(cwd) {
   const res = await runGitAsync(["git", "remote", "get-url", "origin"], cwd);
   if (res.code !== 0)
@@ -1923,60 +1906,6 @@ function historyQueryArgs(query) {
     shaTerm: /^[0-9a-f]{4,40}$/i.test(trimmed) ? trimmed : ""
   };
 }
-function commitHistory(cwd, options) {
-  const ref = (options.ref || "HEAD").trim();
-  if (!ref || ref.startsWith("-") || ref.includes("\x00"))
-    return { commits: [], hasMore: false, error: "invalid ref" };
-  const verified = run(["git", "rev-parse", "--verify", `${ref}^{commit}`], cwd);
-  if (verified.code !== 0)
-    return {
-      commits: [],
-      hasMore: false,
-      ...gitFailureResult(verified, "unknown ref")
-    };
-  const skip = Math.max(0, Math.floor(options.skip) || 0);
-  const limit = Math.max(1, Math.min(Math.floor(options.limit) || 1, MAX_HISTORY_LIMIT));
-  const { filterArgs, pathspec, shaTerm } = historyQueryArgs(options.query || "");
-  const pathFilter = (options.path || "").trim();
-  const pathArgs = [];
-  if (pathFilter && !pathFilter.includes("\x00") && !pathFilter.startsWith("-")) {
-    if (!pathFilter.endsWith("/"))
-      pathArgs.push("--follow");
-    pathArgs.push("--", pathFilter);
-  }
-  const res = run([
-    "git",
-    "log",
-    "-z",
-    `--skip=${skip}`,
-    `--max-count=${limit + 1}`,
-    `--format=${HISTORY_FORMAT}`,
-    ...filterArgs,
-    verified.stdout.trim(),
-    ...pathspec,
-    ...pathArgs
-  ], cwd);
-  if (res.code !== 0)
-    return {
-      commits: [],
-      hasMore: false,
-      ...gitFailureResult(res, "git log failed")
-    };
-  let parsed = parseHistoryLog(res.stdout);
-  if (shaTerm && skip === 0) {
-    const bySha = run(["git", "rev-parse", "--verify", `${shaTerm}^{commit}`], cwd);
-    const sha = bySha.code === 0 ? bySha.stdout.trim() : "";
-    if (sha) {
-      const single = run(["git", "log", "-z", "-1", `--format=${HISTORY_FORMAT}`, sha], cwd);
-      if (single.code === 0) {
-        const hit = parseHistoryLog(single.stdout);
-        parsed = [...hit, ...parsed.filter((c) => c.sha !== sha)];
-      }
-    }
-  }
-  const hasMore = parsed.length > limit;
-  return { commits: hasMore ? parsed.slice(0, limit) : parsed, hasMore };
-}
 async function commitHistoryAsync(cwd, options) {
   const ref = (options.ref || "HEAD").trim();
   if (!ref || ref.startsWith("-") || ref.includes("\x00"))
@@ -2031,50 +1960,6 @@ async function commitHistoryAsync(cwd, options) {
   const hasMore = parsed.length > limit;
   return { commits: hasMore ? parsed.slice(0, limit) : parsed, hasMore };
 }
-function nameStatusResult(args, cwd) {
-  const res = run([
-    "git",
-    "-c",
-    "core.quotepath=false",
-    "diff",
-    "--no-color",
-    "--no-ext-diff",
-    "--find-renames",
-    "--name-status",
-    "-z",
-    ...args
-  ], cwd);
-  if (res.code !== 0) {
-    return {
-      files: [],
-      error: gitFailureMessage(res, "git diff --name-status failed")
-    };
-  }
-  const parts = res.stdout.split("\x00");
-  const files = [];
-  for (let i = 0;i < parts.length; ) {
-    const status = parts[i++];
-    if (!status)
-      break;
-    const kind = status[0];
-    if (kind === "R" || kind === "C") {
-      const oldPath = parts[i++] || "";
-      const path = parts[i++] || "";
-      if (path)
-        files.push({
-          status: kind,
-          old_path: oldPath,
-          path,
-          similarity: Number(status.slice(1)) || undefined
-        });
-    } else {
-      const path = parts[i++] || "";
-      if (path)
-        files.push({ status: kind, path });
-    }
-  }
-  return { files };
-}
 async function nameStatusResultAsync(args, cwd) {
   const res = await runGitAsync([
     "git",
@@ -2119,49 +2004,6 @@ async function nameStatusResultAsync(args, cwd) {
   }
   return { files };
 }
-function numstatZResult(args, cwd) {
-  const res = run([
-    "git",
-    "-c",
-    "core.quotepath=false",
-    "diff",
-    "--no-color",
-    "--no-ext-diff",
-    "--find-renames",
-    "--numstat",
-    "-z",
-    ...args
-  ], cwd);
-  if (res.code !== 0) {
-    return {
-      files: [],
-      error: gitFailureMessage(res, "git diff --numstat failed")
-    };
-  }
-  const parts = res.stdout.split("\x00");
-  const files = [];
-  for (let i = 0;i < parts.length; ) {
-    const rec = parts[i++];
-    if (!rec)
-      break;
-    const match = rec.match(/^(\S+)\t(\S+)\t(.*)$/);
-    if (!match)
-      break;
-    const [, add, del, rest] = match;
-    const binary = add === "-" && del === "-";
-    const additions = binary ? 0 : Number(add) || 0;
-    const deletions = binary ? 0 : Number(del) || 0;
-    if (rest === "") {
-      const oldPath = parts[i++] || "";
-      const path = parts[i++] || "";
-      if (path)
-        files.push({ old_path: oldPath, path, additions, deletions, binary });
-    } else {
-      files.push({ path: rest, additions, deletions, binary });
-    }
-  }
-  return { files };
-}
 async function numstatZResultAsync(args, cwd) {
   const res = await runGitAsync([
     "git",
@@ -2218,8 +2060,8 @@ function isGitInternalPath(path) {
 function syntheticUncommittedBlameFromWorktree(cwd, path) {
   const filePath = join4(cwd, path);
   try {
-    const stat = statSync2(filePath);
-    if (!stat.isFile())
+    const stat2 = statSync2(filePath);
+    if (!stat2.isFile())
       return { lines: [], commits: {}, error: "not a file" };
     const text = readFileSync(filePath, "utf8");
     const normalized = text.replace(/\r\n/g, `
@@ -2255,98 +2097,6 @@ function syntheticUncommittedBlameFromWorktree(cwd, path) {
     return { lines: [], commits: {}, error: "file not readable" };
   }
 }
-function blame(cwd, options) {
-  const path = options.path;
-  if (!path || path.includes("\x00") || path.startsWith("-")) {
-    return { lines: [], commits: {}, error: "invalid path" };
-  }
-  const normalized = normalizeBlameRef(options.ref, options.base);
-  const args = ["git", "blame", "--porcelain"];
-  if (normalized.base === "HEAD") {
-    if (normalized.ref.startsWith("-") || normalized.ref.includes("\x00"))
-      return { lines: [], commits: {}, error: "invalid ref" };
-    args.push(normalized.ref);
-  }
-  args.push("--", path);
-  const res = run(args, cwd);
-  if (res.code !== 0) {
-    if (isCommandNotFoundResult("git", res)) {
-      return {
-        lines: [],
-        commits: {},
-        error: commandNotFoundDetail("git"),
-        status: 503
-      };
-    }
-    if (normalized.base === "worktree") {
-      return syntheticUncommittedBlameFromWorktree(cwd, path);
-    }
-    return {
-      lines: [],
-      commits: {},
-      error: res.stderr.trim() || "blame failed"
-    };
-  }
-  const lines = [];
-  const commits = {};
-  const rawLines = res.stdout.split(`
-`);
-  let i = 0;
-  while (i < rawLines.length) {
-    const headerLine = rawLines[i];
-    if (!headerLine) {
-      i++;
-      continue;
-    }
-    const headerMatch = /^([0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/.exec(headerLine);
-    if (!headerMatch) {
-      i++;
-      continue;
-    }
-    const sha = headerMatch[1];
-    const finalLine = Number(headerMatch[3]);
-    i++;
-    let commit = commits[sha];
-    if (!commit) {
-      commit = {
-        sha,
-        author: "",
-        authorMail: "",
-        authorTime: 0,
-        summary: "",
-        isUncommitted: sha === BLAME_ZERO_SHA
-      };
-      commits[sha] = commit;
-    }
-    while (i < rawLines.length && !rawLines[i].startsWith("\t")) {
-      const metaLine = rawLines[i++];
-      if (!metaLine)
-        continue;
-      const sp = metaLine.indexOf(" ");
-      const key = sp >= 0 ? metaLine.slice(0, sp) : metaLine;
-      const val = sp >= 0 ? metaLine.slice(sp + 1) : "";
-      if (key === "author" && !commit.author)
-        commit.author = val;
-      else if (key === "author-mail" && !commit.authorMail)
-        commit.authorMail = val.replace(/^</, "").replace(/>$/, "");
-      else if (key === "author-time" && !commit.authorTime)
-        commit.authorTime = Number(val) || 0;
-      else if (key === "summary" && !commit.summary)
-        commit.summary = val;
-    }
-    if (i < rawLines.length && rawLines[i].startsWith("\t"))
-      i++;
-    if (Number.isFinite(finalLine) && finalLine > 0) {
-      lines.push({
-        lineNo: finalLine,
-        sha,
-        isUncommitted: sha === BLAME_ZERO_SHA
-      });
-    }
-  }
-  lines.sort((a, b) => a.lineNo - b.lineNo);
-  return { lines, commits };
-}
 async function blameAsync(cwd, options) {
   const path = options.path;
   if (!path || path.includes("\x00") || path.startsWith("-")) {
@@ -2439,16 +2189,6 @@ async function blameAsync(cwd, options) {
   lines.sort((a, b) => a.lineNo - b.lineNo);
   return { lines, commits };
 }
-function untracked(cwd, path = "") {
-  const args = ["git", "ls-files", "--others", "--exclude-standard"];
-  if (path)
-    args.push("--", `${path}/`);
-  const res = run(args, cwd);
-  if (res.code !== 0)
-    return [];
-  return res.stdout.split(`
-`).filter(Boolean).filter((entry) => !isToolInternalPath(entry));
-}
 async function untrackedAsync(cwd, path = "") {
   const args = ["git", "ls-files", "--others", "--exclude-standard"];
   if (path)
@@ -2474,18 +2214,6 @@ function omittedWorktreeDirectoryReason(name, omitDirNames) {
     return "internal";
   return omitDirNames.matches(name) ? "heavy" : undefined;
 }
-function worktreeSubmodulePaths(cwd) {
-  if (!existsSync(join4(cwd, ".gitmodules")))
-    return new Set;
-  const res = run(["git", "config", "--file", ".gitmodules", "--get-regexp", "\\.path$"], cwd);
-  if (res.code !== 0)
-    return new Set;
-  return new Set(res.stdout.split(`
-`).map((line) => {
-    const split = line.indexOf(" ");
-    return split >= 0 ? normalizeTreePath(line.slice(split + 1)) : "";
-  }).filter(Boolean));
-}
 async function worktreeSubmodulePathsAsync(cwd) {
   if (!existsSync(join4(cwd, ".gitmodules")))
     return new Set;
@@ -2522,8 +2250,8 @@ function resolveWorktreeSymlinkTarget(cwd, full) {
   let symlink_target_type = "missing";
   if (realpathWithinRepo(cwd, full, false) !== null) {
     try {
-      const stat = statSync2(full);
-      symlink_target_type = stat.isDirectory() ? "tree" : stat.isFile() ? "blob" : "missing";
+      const stat2 = statSync2(full);
+      symlink_target_type = stat2.isDirectory() ? "tree" : stat2.isFile() ? "blob" : "missing";
     } catch {
       symlink_target_type = "missing";
     }
@@ -2565,83 +2293,6 @@ function worktreeEntryFromDirent(cwd, base, dir, name, isDirectory, isSymlink, o
     children_omitted_reason: omittedReason
   } : baseEntry;
 }
-function worktreeFilesystemEntries(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
-  const base = normalizeTreePath(path);
-  const root = join4(cwd, base);
-  if (realpathWithinRepo(cwd, root, true) === null)
-    return [];
-  const omitDirNameSet = compileNamePatterns(omitDirNames);
-  const excludeNameSet = compileNamePatterns(excludeNames);
-  const submodulePaths = worktreeSubmodulePaths(cwd);
-  let directEntries;
-  try {
-    const dirents = readdirSync(root, { withFileTypes: true });
-    directEntries = sortTreeEntries(dirents.map((entry) => worktreeEntryFromDirent(cwd, base, root, entry.name, entry.isDirectory(), entry.isSymbolicLink(), omitDirNameSet, excludeNameSet, submodulePaths)).filter((entry) => entry.path));
-  } catch {
-    return [];
-  }
-  if (!recursive)
-    return directEntries;
-  const fileEntries = [];
-  let truncated = false;
-  const pushRecursiveEntry = (entry) => {
-    if (fileEntries.length >= WORKTREE_RECURSIVE_ENTRY_LIMIT) {
-      if (!truncated) {
-        fileEntries.push({
-          name: "more...",
-          path: "__code_viewer_truncated__",
-          type: "tree",
-          children_omitted: true,
-          children_omitted_reason: "truncated"
-        });
-        truncated = true;
-      }
-      return false;
-    }
-    fileEntries.push(entry);
-    return true;
-  };
-  const walk = (dir, prefix, depth) => {
-    if (truncated)
-      return;
-    if (depth >= WORKTREE_RECURSIVE_DEPTH_LIMIT)
-      return;
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (excludeNameSet.matches(entry.name))
-        continue;
-      const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const full = join4(dir, entry.name);
-      if (entry.isDirectory()) {
-        const omittedReason = omittedWorktreeDirectoryReason(entry.name, omitDirNameSet);
-        if (omittedReason) {
-          if (!pushRecursiveEntry({
-            name: entry.name,
-            path: entryPath,
-            type: "tree",
-            children_omitted: true,
-            children_omitted_reason: omittedReason
-          }))
-            return;
-          continue;
-        }
-        if (hasDotGitEntry(full))
-          continue;
-        walk(full, entryPath, depth + 1);
-      } else if (entry.isFile() || entry.isSymbolicLink()) {
-        if (!pushRecursiveEntry(recursiveWorktreeFileEntry(cwd, full, entry.name, entryPath, entry.isSymbolicLink())))
-          return;
-      }
-    }
-  };
-  walk(root, base, 0);
-  return combineDirectAndRecursiveFiles(directEntries, fileEntries.sort((a, b) => a.path.localeCompare(b.path)));
-}
 async function worktreeFilesystemEntriesAsync(cwd, path, recursive, omitDirNames = DEFAULT_WORKTREE_OMIT_DIR_NAMES, excludeNames = []) {
   const base = normalizeTreePath(path);
   const root = join4(cwd, base);
@@ -2747,25 +2398,6 @@ function parseLsTreeRecord(rec, allowedTypes) {
     ...mode === LS_TREE_SYMLINK_MODE ? { is_symlink: true } : {}
   };
 }
-function gitTreeEntries(ref, path, cwd, recursive) {
-  const base = normalizeTreePath(path);
-  const args = ["git", "-c", "core.quotepath=false", "ls-tree"];
-  if (recursive)
-    args.push("-r");
-  args.push("-z", "--full-tree", ref, "--");
-  if (base)
-    args.push(`${base}/`);
-  const res = run(args, cwd);
-  if (res.code !== 0)
-    return { code: res.code, entries: [], stderr: res.stderr };
-  const allowedTypes = recursive ? "blob|commit" : "tree|blob|commit";
-  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => parseLsTreeRecord(rec, allowedTypes)).filter((entry) => !!entry);
-  if (recursive)
-    entries.sort((a, b) => a.path.localeCompare(b.path));
-  else
-    entries = sortTreeEntries(entries);
-  return { code: 0, entries, stderr: "" };
-}
 async function gitTreeEntriesAsync(ref, path, cwd, recursive) {
   const base = normalizeTreePath(path);
   const args = ["git", "-c", "core.quotepath=false", "ls-tree"];
@@ -2778,40 +2410,19 @@ async function gitTreeEntriesAsync(ref, path, cwd, recursive) {
   if (res.code !== 0)
     return { code: res.code, entries: [], stderr: res.stderr };
   const allowedTypes = recursive ? "blob|commit" : "tree|blob|commit";
-  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => parseLsTreeRecord(rec, allowedTypes)).filter((entry) => !!entry);
-  if (recursive)
-    entries.sort((a, b) => a.path.localeCompare(b.path));
-  else
-    entries = sortTreeEntries(entries);
-  return { code: 0, entries, stderr: "" };
-}
-function combineDirectAndRecursiveFiles(directEntries, fileEntries) {
-  const seen = new Set(directEntries.map((entry) => entry.path));
-  return [
-    ...directEntries,
-    ...fileEntries.filter((entry) => !seen.has(entry.path))
-  ];
-}
-function listTree(ref, path, cwd, options = {}) {
-  const base = normalizeTreePath(path);
-  if (ref === "worktree") {
-    return {
-      code: 0,
-      entries: worktreeFilesystemEntries(cwd, base, !!options.recursive, options.omitDirNames, options.excludeNames),
-      stderr: ""
-    };
-  }
-  const direct = gitTreeEntries(ref, base, cwd, false);
-  if (direct.code !== 0 || !options.recursive)
-    return direct;
-  const recursive = gitTreeEntries(ref, base, cwd, true);
-  if (recursive.code !== 0)
-    return recursive;
-  return {
-    code: 0,
-    entries: combineDirectAndRecursiveFiles(direct.entries, recursive.entries),
-    stderr: ""
-  };
+  let entries = res.stdout.split("\x00").filter(Boolean).map((rec) => parseLsTreeRecord(rec, allowedTypes)).filter((entry) => !!entry);
+  if (recursive)
+    entries.sort((a, b) => a.path.localeCompare(b.path));
+  else
+    entries = sortTreeEntries(entries);
+  return { code: 0, entries, stderr: "" };
+}
+function combineDirectAndRecursiveFiles(directEntries, fileEntries) {
+  const seen = new Set(directEntries.map((entry) => entry.path));
+  return [
+    ...directEntries,
+    ...fileEntries.filter((entry) => !seen.has(entry.path))
+  ];
 }
 async function listTreeAsync(ref, path, cwd, options = {}) {
   const base = normalizeTreePath(path);
@@ -2840,121 +2451,97 @@ async function listTreeResultAsync(ref, path, cwd, options = {}) {
     return { entries: result.entries };
   return { entries: [], ...gitFailureResult(result, "git ls-tree failed") };
 }
-function untrackedMeta(cwd) {
-  return untracked(cwd).flatMap((path) => {
-    const full = join4(cwd, path);
-    let fileExists = false;
-    try {
-      fileExists = existsSync(full) && statSync2(full).isFile();
-    } catch {
-      fileExists = false;
-    }
-    let scan;
-    if (fileExists) {
-      try {
-        scan = scanFileBinaryAndNewlines(full);
-      } catch {
-        return [];
-      }
-    } else {
-      return [];
-    }
-    return [
-      {
-        path,
-        status: "A",
-        additions: scan.binary ? 0 : scan.newlines,
-        deletions: 0,
-        binary: scan.binary,
-        untracked: true
-      }
-    ];
-  });
-}
-async function untrackedMetaAsync(cwd) {
-  const paths = await untrackedAsync(cwd);
-  return paths.flatMap((path) => {
-    const full = join4(cwd, path);
-    let fileExists = false;
-    try {
-      fileExists = existsSync(full) && statSync2(full).isFile();
-    } catch {
-      fileExists = false;
-    }
-    let scan;
-    if (fileExists) {
-      try {
-        scan = scanFileBinaryAndNewlines(full);
-      } catch {
-        return [];
-      }
-    } else {
-      return [];
-    }
-    return [
-      {
-        path,
-        status: "A",
-        additions: scan.binary ? 0 : scan.newlines,
-        deletions: 0,
-        binary: scan.binary,
-        untracked: true
-      }
-    ];
-  });
+function untrackedFileMeta(path, scan) {
+  return {
+    path,
+    status: "A",
+    additions: scan.binary ? 0 : scan.newlines,
+    deletions: 0,
+    binary: scan.binary,
+    untracked: true
+  };
 }
-function scanFileBinaryAndNewlines(full) {
-  const fd = openSync(full, "r");
+async function scanFileBinaryAndNewlinesAsync(full) {
+  const handle = await open(full, "r");
   const buffer = Buffer.allocUnsafe(64 * 1024);
   let newlines = 0;
   let inspected = 0;
   try {
     while (true) {
-      const read = readSync(fd, buffer, 0, buffer.length, null);
-      if (read <= 0)
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+      if (bytesRead <= 0)
         break;
-      const binaryProbeBytes = Math.min(read, Math.max(0, 8192 - inspected));
+      const binaryProbeBytes = Math.min(bytesRead, Math.max(0, 8192 - inspected));
       for (let i = 0;i < binaryProbeBytes; i++) {
         if (buffer[i] === 0)
           return { binary: true, newlines: 0 };
       }
-      inspected += read;
-      for (let i = 0;i < read; i++) {
+      inspected += bytesRead;
+      for (let i = 0;i < bytesRead; i++) {
         if (buffer[i] === 10)
           newlines++;
       }
     }
   } finally {
-    closeSync(fd);
+    await handle.close();
   }
   return { binary: false, newlines };
 }
-function fileMetaResult(args, cwd, includeUntracked = false) {
-  const ns = nameStatusResult(args, cwd);
-  if (ns.error)
-    return { files: [], error: ns.error };
-  const nm = numstatZResult(args, cwd);
-  if (nm.error)
-    return { files: [], error: nm.error };
-  const byPath = new Map(nm.files.map((file) => [file.path, file]));
-  const files = ns.files.map((file) => {
-    const stats = byPath.get(file.path);
-    return {
-      ...file,
-      additions: stats?.additions || 0,
-      deletions: stats?.deletions || 0,
-      binary: stats?.binary || false
-    };
-  });
-  return {
-    files: includeUntracked ? files.concat(untrackedMeta(cwd)) : files
+async function untrackedMetaAsync(cwd) {
+  const paths = await untrackedAsync(cwd);
+  const previous = untrackedScanCache.get(cwd);
+  const next = new Map;
+  const results = new Array(paths.length).fill(null);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < paths.length) {
+      const index = cursor++;
+      const path = paths[index];
+      const full = join4(cwd, path);
+      let stats;
+      try {
+        stats = await stat(full);
+      } catch {
+        continue;
+      }
+      if (!stats.isFile())
+        continue;
+      const signature = fileSignatureFromStats(stats);
+      const cached = previous?.get(path);
+      let scan;
+      if (cached && cached.signature === signature) {
+        scan = cached.scan;
+      } else {
+        try {
+          scan = await scanFileBinaryAndNewlinesAsync(full);
+        } catch {
+          continue;
+        }
+      }
+      next.set(path, { signature, scan });
+      results[index] = untrackedFileMeta(path, scan);
+    }
   };
+  await Promise.all(Array.from({
+    length: Math.min(UNTRACKED_SCAN_CONCURRENCY, Math.max(1, paths.length))
+  }, () => worker()));
+  untrackedScanCache.set(cwd, next);
+  return results.filter((meta) => meta !== null);
 }
 async function fileMetaResultAsync(args, cwd, includeUntracked = false) {
-  const ns = await nameStatusResultAsync(args, cwd);
+  let ns;
+  let nm;
+  if (args.includes("--")) {
+    [ns, nm] = await Promise.all([
+      nameStatusResultAsync(args, cwd),
+      numstatZResultAsync(args, cwd)
+    ]);
+  } else {
+    ns = await nameStatusResultAsync(args, cwd);
+    nm = await numstatZResultAsync(args, cwd);
+  }
   if (ns.error)
     return { files: [], error: ns.error };
-  const nm = await numstatZResultAsync(args, cwd);
   if (nm.error)
     return { files: [], error: nm.error };
   const byPath = new Map(nm.files.map((file) => [file.path, file]));
@@ -2971,25 +2558,6 @@ async function fileMetaResultAsync(args, cwd, includeUntracked = false) {
     files: includeUntracked ? files.concat(await untrackedMetaAsync(cwd)) : files
   };
 }
-function fileDiffText(args, path, cwd) {
-  const paths = Array.isArray(path) ? path : [path];
-  const res = run([
-    "git",
-    "-c",
-    "core.quotepath=false",
-    "diff",
-    "--no-color",
-    "--no-ext-diff",
-    "--find-renames",
-    ...args,
-    "--",
-    ...paths
-  ], cwd);
-  if (isCommandNotFoundResult("git", res)) {
-    return { ...res, stderr: commandNotFoundDetail("git"), status: 503 };
-  }
-  return res;
-}
 async function fileDiffTextAsync(args, path, cwd) {
   const paths = Array.isArray(path) ? path : [path];
   const res = await runGitAsync([
@@ -3009,24 +2577,6 @@ async function fileDiffTextAsync(args, path, cwd) {
   }
   return res;
 }
-function untrackedFileDiff(extras, path, cwd) {
-  const res = run([
-    "git",
-    "-c",
-    "core.quotepath=false",
-    "diff",
-    "--no-color",
-    "--no-ext-diff",
-    "--no-index",
-    ...extras,
-    "/dev/null",
-    path
-  ], cwd);
-  if (isCommandNotFoundResult("git", res)) {
-    return { ...res, stderr: commandNotFoundDetail("git"), status: 503 };
-  }
-  return res;
-}
 async function untrackedFileDiffAsync(extras, path, cwd) {
   const res = await runGitAsync([
     "git",
@@ -3122,7 +2672,7 @@ function truncateToNHunks(diffText, n, maxLines = Number.POSITIVE_INFINITY) {
     lineTruncated
   };
 }
-var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, repoStatusMapCache, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200, LS_TREE_SYMLINK_MODE = "120000";
+var BLAME_ZERO_SHA = "0000000000000000000000000000000000000000", WORKTREE_RECURSIVE_DEPTH_LIMIT = 32, WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000, DEFAULT_REF_COMMIT_LIMIT = 100, MAX_REF_COMMIT_LIMIT = 500, COMMIT_FORMAT = "%H%x00%s%x00%an%x00%aI", ALWAYS_WORKTREE_OMIT_DIR_NAMES, DEFAULT_WORKTREE_OMIT_DIR_NAMES, GIT_COMMAND_TIMEOUT_MS = 20000, repoStatusMapCache, HISTORY_FORMAT = "%H%x00%s%x00%an%x00%aI%x00%P%x00%b", MAX_HISTORY_LIMIT = 200, LS_TREE_SYMLINK_MODE = "120000", untrackedScanCache, UNTRACKED_SCAN_CONCURRENCY = 8;
 var init_git = __esm(() => {
   init_cache();
   init_command_resolver();
@@ -3174,6 +2724,7 @@ var init_git = __esm(() => {
     "obj"
   ];
   repoStatusMapCache = new Map;
+  untrackedScanCache = new Map;
 });
 
 // web-src/server/server-registry.ts
@@ -4417,16 +3968,11 @@ __export(exports_file_cli, {
   safeWorktreePathFromRoot: () => safeWorktreePathFromRoot,
   runFileCli: () => runFileCli,
   readShowTextAsync: () => readShowTextAsync,
-  readShowText: () => readShowText,
   parseFileArgs: () => parseFileArgs,
   buildFileShowReportAsync: () => buildFileShowReportAsync,
-  buildFileShowReport: () => buildFileShowReport,
   buildFileHistoryReportAsync: () => buildFileHistoryReportAsync,
-  buildFileHistoryReport: () => buildFileHistoryReport,
   buildFileDiffReportAsync: () => buildFileDiffReportAsync,
-  buildFileDiffReport: () => buildFileDiffReport,
   buildFileBlameReportAsync: () => buildFileBlameReportAsync,
-  buildFileBlameReport: () => buildFileBlameReport,
   FILE_HISTORY_HARD_CAP: () => FILE_HISTORY_HARD_CAP,
   FILE_HELP: () => FILE_HELP,
   FILE_DIFF_LINE_HARD_CAP: () => FILE_DIFF_LINE_HARD_CAP,
@@ -4643,14 +4189,14 @@ function parseFileArgs(argv) {
     if (oldPathError)
       return { ok: false, error: oldPathError };
   }
-  const untracked2 = flags.has("--untracked");
-  if (untracked2 && rawFrom !== undefined) {
+  const untracked = flags.has("--untracked");
+  if (untracked && rawFrom !== undefined) {
     return {
       ok: false,
       error: "--untracked cannot be combined with --from"
     };
   }
-  if (untracked2 && to !== "worktree") {
+  if (untracked && to !== "worktree") {
     return {
       ok: false,
       error: "--untracked requires --to worktree (or --to omitted)"
@@ -4694,7 +4240,7 @@ function parseFileArgs(argv) {
         ...oldPathRaw !== undefined ? { oldPath: oldPathRaw } : {},
         from,
         to,
-        untracked: untracked2,
+        untracked,
         ignoreWs,
         ignoreBlank,
         mode: full ? "full" : "preview",
@@ -4726,19 +4272,6 @@ function formatBlameText(result) {
 function formatHistoryText(commits) {
   return commits.map((c) => `${c.sha.slice(0, 8)}	${c.when}	${c.author}	${c.subject}`);
 }
-function buildFileBlameReport(root, command) {
-  const result = blame(root, {
-    path: command.path,
-    ref: command.ref,
-    base: command.base
-  });
-  return {
-    path: command.path,
-    ref: command.ref,
-    base: command.base,
-    result
-  };
-}
 async function buildFileBlameReportAsync(root, command) {
   const result = await blameAsync(root, {
     path: command.path,
@@ -4752,23 +4285,6 @@ async function buildFileBlameReportAsync(root, command) {
     result
   };
 }
-function buildFileHistoryReport(root, command) {
-  const result = commitHistory(root, {
-    ref: command.ref,
-    skip: command.skip,
-    limit: command.limit,
-    query: command.query,
-    path: command.path
-  });
-  return {
-    path: command.path,
-    ref: command.ref,
-    limit: command.limit,
-    skip: command.skip,
-    ...command.query !== undefined ? { query: command.query } : {},
-    result
-  };
-}
 async function buildFileHistoryReportAsync(root, command) {
   const result = await commitHistoryAsync(root, {
     ref: command.ref,
@@ -4786,8 +4302,8 @@ async function buildFileHistoryReportAsync(root, command) {
     result
   };
 }
-function runBlame(root, command) {
-  const report = buildFileBlameReport(root, command);
+async function runBlame(root, command) {
+  const report = await buildFileBlameReportAsync(root, command);
   if (command.json) {
     console.log(JSON.stringify(report, null, 2));
   } else {
@@ -4799,8 +4315,8 @@ function runBlame(root, command) {
     process.exit(1);
   }
 }
-function runHistory(root, command) {
-  const report = buildFileHistoryReport(root, command);
+async function runHistory(root, command) {
+  const report = await buildFileHistoryReportAsync(root, command);
   if (command.json) {
     console.log(JSON.stringify(report, null, 2));
   } else if (report.result.commits.length === 0) {
@@ -4852,28 +4368,6 @@ function safeWorktreePathFromRoot(root, path) {
     return null;
   }
 }
-function readShowText(root, command) {
-  if (command.ref !== "worktree" && command.ref !== "") {
-    return show(command.ref, command.path, root);
-  }
-  const full = safeWorktreePathFromRoot(root, command.path);
-  if (!full) {
-    return {
-      code: 1,
-      stdout: "",
-      stderr: "file not found or forbidden"
-    };
-  }
-  try {
-    const stat = statSync3(full);
-    if (!stat.isFile()) {
-      return { code: 1, stdout: "", stderr: "not a file" };
-    }
-    return { code: 0, stdout: readFileSync4(full, "utf8"), stderr: "" };
-  } catch {
-    return { code: 1, stdout: "", stderr: "file not readable" };
-  }
-}
 async function readShowTextAsync(root, command) {
   if (command.ref !== "worktree" && command.ref !== "") {
     return showAsync(command.ref, command.path, root);
@@ -4887,8 +4381,8 @@ async function readShowTextAsync(root, command) {
     };
   }
   try {
-    const stat = statSync3(full);
-    if (!stat.isFile()) {
+    const stat2 = statSync3(full);
+    if (!stat2.isFile()) {
       return { code: 1, stdout: "", stderr: "not a file" };
     }
     return { code: 0, stdout: readFileSync4(full, "utf8"), stderr: "" };
@@ -4896,33 +4390,6 @@ async function readShowTextAsync(root, command) {
     return { code: 1, stdout: "", stderr: "file not readable" };
   }
 }
-function buildFileShowReport(root, command) {
-  const res = readShowText(root, command);
-  if (res.code !== 0) {
-    const detail = res.stderr.trim() || `git show exited with code ${res.code}`;
-    return {
-      path: command.path,
-      ref: command.ref,
-      ...command.start !== undefined ? { start: command.start } : {},
-      ...command.end !== undefined ? { end: command.end } : {},
-      totalLines: 0,
-      complete: false,
-      text: "",
-      error: detail
-    };
-  }
-  const sliced = sliceLines(res.stdout, command.start, command.end);
-  return {
-    path: command.path,
-    ref: command.ref,
-    ...command.start !== undefined ? { start: command.start } : {},
-    ...command.end !== undefined ? { end: command.end } : {},
-    totalLines: sliced.total,
-    complete: sliced.complete,
-    text: sliced.lines.join(`
-`)
-  };
-}
 async function buildFileShowReportAsync(root, command) {
   const res = await readShowTextAsync(root, command);
   if (res.code !== 0) {
@@ -4950,8 +4417,8 @@ async function buildFileShowReportAsync(root, command) {
 `)
   };
 }
-function runShow(root, command) {
-  const report = buildFileShowReport(root, command);
+async function runShow(root, command) {
+  const report = await buildFileShowReportAsync(root, command);
   if (report.error !== undefined) {
     if (command.json) {
       console.log(JSON.stringify(report, null, 2));
@@ -4974,64 +4441,6 @@ function buildFileDiffRangeArgs(from, to) {
     refs.push(to);
   return refs;
 }
-function buildFileDiffReport(root, command) {
-  const base = {
-    path: command.path,
-    ...command.oldPath !== undefined ? { old_path: command.oldPath } : {},
-    from: command.untracked ? "/dev/null" : command.from,
-    to: command.to,
-    untracked: command.untracked,
-    ignore_ws: command.ignoreWs,
-    ignore_blank: command.ignoreBlank,
-    mode: command.mode,
-    max_hunks: command.mode === "preview" ? command.maxHunks : null,
-    max_lines: command.mode === "preview" ? command.maxLines : null,
-    diff: "",
-    hunk_count: 0,
-    rendered_hunk_count: 0,
-    line_count: 0,
-    truncated: false,
-    binary: false
-  };
-  if (!command.untracked && isSameWorktreeRange({ from: command.from, to: command.to })) {
-    return base;
-  }
-  const extras = [];
-  if (command.ignoreWs)
-    extras.push("-w");
-  if (command.ignoreBlank)
-    extras.push("--ignore-blank-lines");
-  let diffText = "";
-  let errText = "";
-  if (command.untracked) {
-    const res = untrackedFileDiff(extras, command.path, root);
-    diffText = res.stdout || "";
-    if (res.code !== 0)
-      errText = res.stderr.trim();
-  } else {
-    const args = [
-      ...extras,
-      ...buildFileDiffRangeArgs(command.from, command.to)
-    ];
-    const paths = command.oldPath !== undefined ? [command.oldPath, command.path] : command.path;
-    const res = fileDiffText(args, paths, root);
-    diffText = res.stdout || "";
-    if (res.code !== 0)
-      errText = res.stderr.trim();
-  }
-  const truncated = command.mode === "preview" ? truncateToNHunks(diffText, command.maxHunks, command.maxLines) : truncateToNHunks(diffText, 1e9);
-  const previewTruncated = command.mode === "preview" && (truncated.totalHunks > truncated.renderedHunks || truncated.lineTruncated);
-  return {
-    ...base,
-    diff: truncated.text,
-    hunk_count: truncated.totalHunks,
-    rendered_hunk_count: truncated.renderedHunks,
-    line_count: truncated.lineCount,
-    truncated: previewTruncated,
-    binary: diffText.includes("Binary files"),
-    ...errText ? { error: errText } : {}
-  };
-}
 async function buildFileDiffReportAsync(root, command) {
   const base = {
     path: command.path,
@@ -5090,8 +4499,8 @@ async function buildFileDiffReportAsync(root, command) {
     ...errText ? { error: errText } : {}
   };
 }
-function runDiff(root, command) {
-  const report = buildFileDiffReport(root, command);
+async function runDiff(root, command) {
+  const report = await buildFileDiffReportAsync(root, command);
   if (command.json) {
     console.log(JSON.stringify(report, null, 2));
   } else if (report.diff.length > 0) {
@@ -10049,18 +9458,18 @@ function formatRecentText(commits) {
   }
   return lines;
 }
-function buildStatusReport(opts) {
+async function buildStatusReport(opts) {
   const { root, ref, limit } = opts;
-  const stagedResult = fileMetaResult(["--cached"], root, false);
-  const changedResult = fileMetaResult(["HEAD"], root, true);
-  const worktreeFallbackResult = isMissingDiffBaseError(changedResult.error) ? fileMetaResult([], root, true) : null;
+  const stagedResult = await fileMetaResultAsync(["--cached"], root, false);
+  const changedResult = await fileMetaResultAsync(["HEAD"], root, true);
+  const worktreeFallbackResult = isMissingDiffBaseError(changedResult.error) ? await fileMetaResultAsync([], root, true) : null;
   const stagedFiles = stagedResult.files;
   const changedFiles = changedResult.error ? worktreeFallbackResult ? mergeMissingByPath(worktreeFallbackResult.files, stagedFiles) : [] : mergeMissingByPath(changedResult.files, stagedFiles);
   const changed = buildGroup(changedFiles, worktreeFallbackResult ? worktreeFallbackResult.error || stagedResult.error : changedResult.error || stagedResult.error);
   const staged = buildGroup(stagedFiles, stagedResult.error);
-  const history = commitHistory(root, { ref, skip: 0, limit });
-  const branch = currentBranch(root);
-  const remote = remoteWebUrl(root);
+  const history = await commitHistoryAsync(root, { ref, skip: 0, limit });
+  const branch = await currentBranchAsync(root);
+  const remote = await remoteWebUrlAsync(root);
   const registry = readServerRegistry(root);
   const serverUrl = registry?.url ?? null;
   const nextCommands = buildNextCommands(changed, staged, serverUrl);
@@ -10098,7 +9507,7 @@ function formatStatusReportText(report) {
   return lines.join(`
 `);
 }
-function runStatusCli(argv) {
+async function runStatusCli(argv) {
   const parsed = parseStatusArgs(argv);
   if (parsed.ok === false) {
     console.error(parsed.error);
@@ -10124,7 +9533,7 @@ function runStatusCli(argv) {
     process.exit(1);
   }
   const root = resolveRepoRoot(cwd);
-  const report = buildStatusReport({
+  const report = await buildStatusReport({
     root,
     ref: command.ref,
     limit: command.limit
@@ -14805,26 +14214,26 @@ function hasControlCharacter(value) {
 
 // web-src/server/database/discovery.ts
 import {
-  closeSync as closeSync2,
+  closeSync,
   existsSync as existsSync6,
-  openSync as openSync2,
-  readSync as readSync2,
+  openSync,
+  readSync,
   realpathSync as realpathSync5,
   statSync as statSync4
 } from "node:fs";
-import { lstat, open, readdir, readFile as readFile2, stat } from "node:fs/promises";
+import { lstat, open as open2, readdir, readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import { basename, join as join9, relative as relative4 } from "node:path";
 function isSqliteFile(fullPath) {
   try {
-    const stat2 = statSync4(fullPath);
-    if (!stat2.isFile() || stat2.size < 16)
+    const stat3 = statSync4(fullPath);
+    if (!stat3.isFile() || stat3.size < 16)
       return false;
     const buf = Buffer.alloc(16);
-    const fd = openSync2(fullPath, "r");
+    const fd = openSync(fullPath, "r");
     try {
-      readSync2(fd, buf, 0, 16, 0);
+      readSync(fd, buf, 0, 16, 0);
     } finally {
-      closeSync2(fd);
+      closeSync(fd);
     }
     return buf.toString("utf8", 0, 16) === SQLITE_MAGIC;
   } catch {
@@ -14833,10 +14242,10 @@ function isSqliteFile(fullPath) {
 }
 async function isSqliteFileAsync(fullPath) {
   try {
-    const fileStat = await stat(fullPath);
+    const fileStat = await stat2(fullPath);
     if (!fileStat.isFile() || fileStat.size < 16)
       return false;
-    const file = await open(fullPath, "r");
+    const file = await open2(fullPath, "r");
     try {
       const buf = Buffer.alloc(16);
       await file.read(buf, 0, 16, 0);
@@ -15300,7 +14709,7 @@ function cloneDockerDiscoveryResult(result) {
 }
 async function pathExistsAsync(path) {
   try {
-    await stat(path);
+    await stat2(path);
     return true;
   } catch {
     return false;
@@ -15649,6 +15058,7 @@ function startWorktreeUpdateWatch(options) {
   const initialScanAsync = options.initialScanMode === "async" || (!options.watch || options.watch === nodeWatch) && !options.readdirSync;
   const initialScanQueue = [];
   let initialScanTimer = null;
+  let processingInitialScan = false;
   const pendingPathInspections = new Map;
   let pathInspectionTimer = null;
   let timer = null;
@@ -15736,8 +15146,14 @@ function startWorktreeUpdateWatch(options) {
       return;
     }
     const next = initialScanQueue.shift();
-    if (next)
-      watchDirectory(next, true);
+    if (next) {
+      processingInitialScan = true;
+      try {
+        watchDirectory(next, true);
+      } finally {
+        processingInitialScan = false;
+      }
+    }
     if (watchers.size >= maxWatchedDirectories) {
       reportWatchLimit();
       initialScanQueue.length = 0;
@@ -15755,7 +15171,7 @@ function startWorktreeUpdateWatch(options) {
     if (children.length > remaining)
       reportWatchLimit();
     initialScanQueue.push(...children.slice(0, remaining));
-    if (!initialScanTimer)
+    if (!initialScanTimer && !processingInitialScan)
       initialScanTimer = setTimer(processInitialScanQueue, 5000);
   };
   const processChangedPath = (changed, fullChangedPath) => {
@@ -17334,7 +16750,7 @@ function createDockerAdapterCache(maxEntries = DEFAULT_MAX_DOCKER_ADAPTER_CACHE,
     }
   }
   return {
-    async getOrOpenAsync(key, open2) {
+    async getOrOpenAsync(key, open3) {
       prune();
       const cached = cache.get(key);
       if (cached) {
@@ -17348,7 +16764,7 @@ function createDockerAdapterCache(maxEntries = DEFAULT_MAX_DOCKER_ADAPTER_CACHE,
         closed: false,
         promise: undefined
       };
-      pendingEntry.promise = Promise.resolve().then(open2).then((adapter) => {
+      pendingEntry.promise = Promise.resolve().then(open3).then((adapter) => {
         if (pendingEntry.closed) {
           adapter.close();
         } else {
@@ -21646,27 +21062,27 @@ async function checkSqlite(cwd) {
   const status = await describeSqliteDriver();
   const rows = [sqliteStatusToRow(status)];
   if (status.kind === "ok") {
-    const open2 = await trySnapshotDbOpen(cwd);
-    if (open2.kind === "skipped") {
+    const open3 = await trySnapshotDbOpen(cwd);
+    if (open3.kind === "skipped") {
       rows.push({
         id: "sqlite.snapshot-open",
         title: "Snapshot DB open smoke test",
         status: "ok",
         detail: "Skipped (snapshot DB will be created on first use)"
       });
-    } else if (open2.kind === "ok") {
+    } else if (open3.kind === "ok") {
       rows.push({
         id: "sqlite.snapshot-open",
         title: "Snapshot DB open smoke test",
         status: "ok",
-        detail: `Opened ${open2.path}`
+        detail: `Opened ${open3.path}`
       });
     } else {
       rows.push({
         id: "sqlite.snapshot-open",
         title: "Snapshot DB open failed",
         status: "error",
-        detail: open2.message,
+        detail: open3.message,
         hint: "The snapshot DB exists but could not be opened. Inspect file permissions, possible corruption, or another process holding the file."
       });
     }
@@ -21715,8 +21131,8 @@ function checkSnapshotStore(cwd) {
   }
   let dbDetail = dbPath;
   try {
-    const stat2 = statSync5(dbPath);
-    dbDetail = `${dbPath} (${stat2.size.toLocaleString()} bytes)`;
+    const stat3 = statSync5(dbPath);
+    dbDetail = `${dbPath} (${stat3.size.toLocaleString()} bytes)`;
   } catch {
     dbDetail = `${dbPath} (not created yet — created on first snapshot)`;
   }
@@ -23330,7 +22746,8 @@ var init_journal2 = __esm(() => {
 });
 
 // web-src/server/search-service.ts
-import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync7, realpathSync as realpathSync6 } from "node:fs";
+import { existsSync as existsSync7, realpathSync as realpathSync6 } from "node:fs";
+import { lstat as lstat2, readFile as readFile3 } from "node:fs/promises";
 import { join as join18, relative as relative7 } from "node:path";
 async function rgAvailableAsync(cwd) {
   if (rgAvailableCache !== null)
@@ -23382,12 +22799,12 @@ function safeWorktreePath(env, path) {
 function filterCallerPaths(env, paths) {
   return paths.filter((path) => isSafePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, env.omitDirNames, env.excludeNames));
 }
-function grepWorktreeFallback(env, query, max, paths) {
-  const candidates = paths.length ? paths : listTree("worktree", "", env.cwd, {
+async function grepWorktreeFallback(env, query, max, paths) {
+  const candidates = paths.length ? paths : (await listTreeAsync("worktree", "", env.cwd, {
     recursive: true,
     omitDirNames: env.omitDirNames,
     excludeNames: env.excludeNames
-  }).entries.map((entry) => entry.path);
+  })).entries.map((entry) => entry.path);
   const matches = [];
   for (const path of candidates) {
     if (matches.length >= max)
@@ -23397,17 +22814,17 @@ function grepWorktreeFallback(env, query, max, paths) {
     const full = safeWorktreePath(env, path);
     if (!full)
       continue;
-    let stat2;
+    let stat3;
     try {
-      stat2 = lstatSync4(full);
+      stat3 = await lstat2(full);
     } catch {
       continue;
     }
-    if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > GREP_MAX_FILE_BYTES)
+    if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.size > GREP_MAX_FILE_BYTES)
       continue;
     let data;
     try {
-      data = readFileSync7(full);
+      data = await readFile3(full);
     } catch {
       continue;
     }
@@ -23447,7 +22864,7 @@ async function grepWorktreeAsync(env, req) {
       matches: []
     };
   }
-  const matches = grepWorktreeFallback(env, req.query, req.max, paths);
+  const matches = await grepWorktreeFallback(env, req.query, req.max, paths);
   return {
     ref: "worktree",
     engine: "fallback",
@@ -23553,7 +22970,7 @@ var init_search_service = __esm(() => {
 });
 
 // web-src/server/mcp.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { join as join19 } from "node:path";
 function defaultMcpTools(options = {}) {
   return [
@@ -24051,7 +23468,7 @@ function defaultMcpTools(options = {}) {
     }
   ];
 }
-function runStatusTool(input, defaultCwd) {
+async function runStatusTool(input, defaultCwd) {
   const params = isPlainObject(input) ? input : {};
   const cwdRaw = params.cwd;
   const refRaw = params.ref;
@@ -24092,7 +23509,7 @@ function runStatusTool(input, defaultCwd) {
     return { text: resolved.error, isError: true };
   }
   try {
-    const report = buildStatusReport({ root: resolved.root, ref, limit });
+    const report = await buildStatusReport({ root: resolved.root, ref, limit });
     return {
       text: JSON.stringify(report, null, 2),
       isError: !!(report.changed.error || report.staged.error)
@@ -24365,14 +23782,14 @@ async function runFileDiffTool(input, defaultCwd) {
   if (untrackedRaw !== undefined && typeof untrackedRaw !== "boolean") {
     return { text: "untracked must be a boolean", isError: true };
   }
-  const untracked2 = untrackedRaw === true;
-  if (untracked2 && params.from !== undefined) {
+  const untracked = untrackedRaw === true;
+  if (untracked && params.from !== undefined) {
     return {
       text: "untracked cannot be combined with from",
       isError: true
     };
   }
-  if (untracked2 && toParsed.ref !== "worktree") {
+  if (untracked && toParsed.ref !== "worktree") {
     return {
       text: "untracked requires to='worktree' (or omitted)",
       isError: true
@@ -24420,7 +23837,7 @@ async function runFileDiffTool(input, defaultCwd) {
     ...oldPath !== undefined ? { oldPath } : {},
     from: fromParsed.ref,
     to: toParsed.ref,
-    untracked: untracked2,
+    untracked,
     ignoreWs,
     ignoreBlank,
     mode,
@@ -25028,7 +24445,7 @@ var init_mcp = __esm(() => {
   init_search_cli();
   init_search_service();
   init_status_cli();
-  PACKAGE_VERSION = JSON.parse(readFileSync8(join19(ROOT, "package.json"), "utf8")).version;
+  PACKAGE_VERSION = JSON.parse(readFileSync7(join19(ROOT, "package.json"), "utf8")).version;
   MCP_SERVER_INFO = {
     name: "code-viewer",
     title: "code-viewer",
@@ -25109,13 +24526,13 @@ var init_state_route = __esm(() => {
 // web-src/server/preview.ts
 var exports_preview = {};
 import {
-  closeSync as closeSync3,
+  closeSync as closeSync2,
   constants as constants3,
   existsSync as existsSync8,
-  lstatSync as lstatSync5,
+  lstatSync as lstatSync4,
   mkdirSync as mkdirSync4,
-  openSync as openSync3,
-  readFileSync as readFileSync9,
+  openSync as openSync2,
+  readFileSync as readFileSync8,
   realpathSync as realpathSync7,
   renameSync,
   statSync as statSync6,
@@ -25356,7 +24773,7 @@ function staticFile(pathname) {
   const full = join20(WEB_ROOT, spec[0]);
   if (!existsSync8(full))
     return text("not found", 404);
-  return new Response(readFileSync9(full), {
+  return new Response(readFileSync8(full), {
     headers: { "Content-Type": spec[1], "Cache-Control": "no-store" }
   });
 }
@@ -25413,7 +24830,7 @@ function buildQuery(params) {
   const s = q.toString();
   return s ? `?${s}` : "";
 }
-function fileToMeta(file, range, extraQs) {
+function fileToMeta(file, range, extraQs, responseGeneration) {
   const sizeClass = classify(file);
   const q = {
     path: file.path,
@@ -25421,6 +24838,7 @@ function fileToMeta(file, range, extraQs) {
     status: file.status,
     from: range.from,
     to: range.to,
+    generation: responseGeneration,
     ...extraQs
   };
   if (file.untracked)
@@ -25459,7 +24877,7 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
     };
   }
   const { args, refs } = buildRangeArgs(range);
-  const fullArgs = [...extras, ...args];
+  const fullArgs = pathFilter ? [...extras, ...args, "--", pathFilter] : [...extras, ...args];
   const metaResult = await fileMetaResultAsync(fullArgs, cwd, false);
   const files = metaResult.files;
   if (!metaResult.error && includeUntracked(range, refs)) {
@@ -25477,7 +24895,7 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
     if (e === "--ignore-blank-lines")
       extraQs.ignore_blank = "1";
   }
-  const meta = filteredFiles.map((file) => fileToMeta(file, range, extraQs));
+  const meta = filteredFiles.map((file) => fileToMeta(file, range, extraQs, responseGeneration));
   const totals = meta.reduce((acc, file) => {
     acc.additions += file.additions || 0;
     acc.deletions += file.deletions || 0;
@@ -25496,7 +24914,7 @@ async function computePayload(extras, range, pathFilter = "", responseGeneration
   };
 }
 async function handleDiffJson(url) {
-  const responseGeneration = generation;
+  let responseGeneration = generation;
   const extras = [];
   if (url.searchParams.get("ignore_ws") === "1")
     extras.push("-w");
@@ -25522,9 +24940,15 @@ async function handleDiffJson(url) {
   const requestSequence = ++diffMetaRequestSequence;
   latestDiffMetaRequest.set(key, requestSequence);
   try {
-    const payload = await computePayload(extras, range, path, responseGeneration);
-    if (latestDiffMetaRequest.get(key) !== requestSequence || responseGeneration !== generation)
+    let payload = await computePayload(extras, range, path, responseGeneration);
+    if (latestDiffMetaRequest.get(key) !== requestSequence)
       return json2(payload);
+    if (responseGeneration !== generation) {
+      responseGeneration = generation;
+      payload = await computePayload(extras, range, path, responseGeneration);
+      if (latestDiffMetaRequest.get(key) !== requestSequence || responseGeneration !== generation)
+        return json2(payload);
+    }
     const sig = JSON.stringify({ ...payload, generation: undefined });
     if (noCache && (!cached || cached.sig !== sig)) {
       generation++;
@@ -25631,11 +25055,11 @@ function worktreeFileMetadata(path, knownSize) {
   if (!full)
     return {};
   try {
-    const stat2 = statSync6(full);
+    const stat3 = statSync6(full);
     return {
-      size: knownSize ?? stat2.size,
-      created_at: isoDate(stat2.birthtimeMs),
-      updated_at: isoDate(stat2.mtimeMs)
+      size: knownSize ?? stat3.size,
+      created_at: isoDate(stat3.birthtimeMs),
+      updated_at: isoDate(stat3.mtimeMs)
     };
   } catch {
     return {};
@@ -25656,10 +25080,10 @@ async function directoryMetadata(target, path) {
     if (!full)
       return {};
     try {
-      const stat2 = statSync6(full);
+      const stat3 = statSync6(full);
       return {
-        created_at: isoDate(stat2.birthtimeMs),
-        updated_at: isoDate(stat2.mtimeMs)
+        created_at: isoDate(stat3.birthtimeMs),
+        updated_at: isoDate(stat3.mtimeMs)
       };
     } catch {
       return {};
@@ -25704,7 +25128,7 @@ async function readReadme(target, dirPath) {
       if (!full)
         continue;
       try {
-        return { path, text: readFileSync9(full, "utf8") };
+        return { path, text: readFileSync8(full, "utf8") };
       } catch {
         continue;
       }
@@ -25993,7 +25417,7 @@ async function handleFileBlame(url) {
   return json2({ ...result, base, ref, generation: responseGeneration });
 }
 async function handleFileDiff(url) {
-  const responseGeneration = generation;
+  const serverGenerationAtRequest = generation;
   const path = url.searchParams.get("path") || "";
   if (!safePath(path))
     return text("invalid path", 400);
@@ -26007,6 +25431,9 @@ async function handleFileDiff(url) {
     from: url.searchParams.get("from") || "",
     to: url.searchParams.get("to") || ""
   };
+  const requestedGeneration = Number(url.searchParams.get("generation"));
+  const usesWorktree = !range.from || range.from === "worktree" || !range.to || range.to === "worktree";
+  const responseGeneration = !usesWorktree && Number.isSafeInteger(requestedGeneration) && requestedGeneration > 0 ? requestedGeneration : serverGenerationAtRequest;
   if (isSameWorktreeRange(range)) {
     return json2({
       path,
@@ -26060,7 +25487,7 @@ async function handleFileDiff(url) {
         errStatus = res.status ?? 500;
       }
     }
-    if (!errText && responseGeneration === generation)
+    if (!errText && serverGenerationAtRequest === generation)
       setTimedCacheEntry(fileCache, cacheKey, { diffText });
   }
   if (errStatus)
@@ -26085,8 +25512,8 @@ async function handleFileDiff(url) {
 }
 function worktreeLineIndexSignature(full) {
   try {
-    const stat2 = statSync6(full);
-    return `size:${stat2.size}|mtime:${stat2.mtimeMs}|ctime:${stat2.ctimeMs}|ino:${stat2.ino || 0}`;
+    const stat3 = statSync6(full);
+    return `size:${stat3.size}|mtime:${stat3.mtimeMs}|ctime:${stat3.ctimeMs}|ino:${stat3.ino || 0}`;
   } catch {
     return null;
   }
@@ -26101,10 +25528,10 @@ async function getWorktreeLineIndex(full) {
     lineIndexCache.set(full, cached);
     return cached.index;
   }
-  const stat2 = statSync6(full);
-  if (stat2.size > LINE_INDEX_MAX_FILE_BYTES)
+  const stat3 = statSync6(full);
+  if (stat3.size > LINE_INDEX_MAX_FILE_BYTES)
     return null;
-  const index = await buildLineOffsetIndexFromStream(fileReadableStream(full), stat2.size);
+  const index = await buildLineOffsetIndexFromStream(fileReadableStream(full), stat3.size);
   lineIndexCache.delete(full);
   lineIndexCache.set(full, { signature, index });
   while (lineIndexCache.size > 32) {
@@ -26476,11 +25903,11 @@ async function handleUploadFiles(req) {
   const written = [];
   try {
     for (const upload of uploads) {
-      const fd = openSync3(upload.target, uploadOpenFlags(), 420);
+      const fd = openSync2(upload.target, uploadOpenFlags(), 420);
       try {
         writeFileSync2(fd, new Uint8Array(await upload.file.arrayBuffer()));
       } finally {
-        closeSync3(fd);
+        closeSync2(fd);
       }
       written.push(upload.target);
     }
@@ -26600,7 +26027,7 @@ function moveMacPathIntoTrash(path) {
   }
 }
 async function movePathToTrash(path) {
-  lstatSync5(path);
+  lstatSync4(path);
   if (process.platform === "darwin") {
     return moveMacPathIntoTrash(path);
   }
@@ -27393,7 +26820,7 @@ var init_preview = __esm(async () => {
   init_state_store();
   init_worktree_watcher();
   WEB_ROOT = join20(ROOT, "web");
-  VERSION = JSON.parse(readFileSync9(join20(ROOT, "package.json"), "utf8")).version;
+  VERSION = JSON.parse(readFileSync8(join20(ROOT, "package.json"), "utf8")).version;
   DEFAULT_ARGS = ["HEAD"];
   WATCHED_ASSET_FILES = ["index.html", "style.css", "app.js"];
   LINE_INDEX_MAX_FILE_BYTES = 256 * 1024 * 1024;
@@ -27679,7 +27106,7 @@ if (process.argv[2] === "agent-help") {
   await runFileCli2(process.argv.slice(3));
 } else if (process.argv[2] === "status") {
   const { runStatusCli: runStatusCli2 } = await Promise.resolve().then(() => (init_status_cli(), exports_status_cli));
-  runStatusCli2(process.argv.slice(3));
+  await runStatusCli2(process.argv.slice(3));
 } else if (process.argv[2] === "skill") {
   const { runSkillCli: runSkillCli2 } = await Promise.resolve().then(() => (init_skill_cli(), exports_skill_cli));
   runSkillCli2(process.argv.slice(3));