farming-code 2.2.29 → 2.2.32

package/backend/{workspace-file-service.js → workspace-file-service.cjs}

@@ -1,272 +1,317 @@
-const crypto = require('crypto');
-const fs = require('fs');
-const fsp = require('fs/promises');
-const path = require('path');
-const { diffChars } = require('diff');
-const { execFile, spawn } = require('child_process');
-const readline = require('readline');
-const { pathToFileURL } = require('url');
-
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_file_service_exports = {};
+__export(workspace_file_service_exports, {
+  DEFAULT_MAX_FILE_SIZE: () => DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_MAX_WRITE_SIZE: () => DEFAULT_MAX_WRITE_SIZE,
+  DEFAULT_WATCH_DEPTH: () => DEFAULT_WATCH_DEPTH,
+  WorkspaceFileError: () => WorkspaceFileError,
+  WorkspaceFileService: () => WorkspaceFileService,
+  createAddedFileLineChangesHunk: () => createAddedFileLineChangesHunk,
+  isPackagedRuntime: () => isPackagedRuntime,
+  normalizeGitHistoryLimit: () => normalizeGitHistoryLimit,
+  normalizeGitHistorySkip: () => normalizeGitHistorySkip,
+  parseGitBlamePorcelain: () => parseGitBlamePorcelain,
+  parseGitHistoryChanges: () => parseGitHistoryChanges,
+  parseGitHistoryLog: () => parseGitHistoryLog,
+  parseGitHistoryReferences: () => parseGitHistoryReferences,
+  parseUnifiedDiffHunks: () => parseUnifiedDiffHunks,
+  parseUnifiedDiffRows: () => parseUnifiedDiffRows,
+  resolveCommandRunnerNodePath: () => resolveCommandRunnerNodePath,
+  selectUnifiedDiffHunk: () => selectUnifiedDiffHunk
+});
+module.exports = __toCommonJS(workspace_file_service_exports);
+const crypto = require("crypto");
+const fs = require("fs");
+const fsp = require("fs/promises");
+const path = require("path");
+const { diffChars } = require("diff");
+const { execFile, spawn } = require("child_process");
+const readline = require("readline");
+const { pathToFileURL } = require("url");
 const DEFAULT_MAX_FILE_SIZE = 1024 * 1024;
 const DEFAULT_MAX_WRITE_SIZE = 2 * 1024 * 1024;
 const DEFAULT_MAX_PREVIEW_FILE_SIZE = 8 * 1024 * 1024;
 const DEFAULT_SEARCH_LIMIT = 100;
 const DEFAULT_GIT_CHANGES_LIMIT = 500;
-const DEFAULT_GIT_STATUS_CACHE_TTL_MS = 30000;
+const DEFAULT_GIT_STATUS_CACHE_TTL_MS = 3e4;
 const DEFAULT_GIT_STATUS_INLINE_TIMEOUT_MS = 80;
-const DEFAULT_GIT_STATUS_TIMEOUT_MS = 15000;
-const DEFAULT_SEARCH_TIMEOUT_MS = 3000;
-const DEFAULT_BLAME_TIMEOUT_MS = 5000;
-const DEFAULT_DIFF_TIMEOUT_MS = 5000;
+const DEFAULT_GIT_STATUS_TIMEOUT_MS = 15e3;
+const DEFAULT_SEARCH_TIMEOUT_MS = 3e3;
+const DEFAULT_BLAME_TIMEOUT_MS = 5e3;
+const DEFAULT_DIFF_TIMEOUT_MS = 5e3;
 const DEFAULT_DIFF_MAX_BUFFER = 1024 * 1024;
 const DEFAULT_GIT_HISTORY_LIMIT = 50;
 const MAX_GIT_HISTORY_LIMIT = 100;
-const DEFAULT_GIT_HISTORY_TIMEOUT_MS = 5000;
+const DEFAULT_GIT_HISTORY_TIMEOUT_MS = 5e3;
 const DEFAULT_GIT_HISTORY_MAX_BUFFER = 8 * 1024 * 1024;
 const DEFAULT_WATCH_DEPTH = 1;
 const SEARCH_FILE_LIST_MAX_BUFFER = 16 * 1024 * 1024;
 const BINARY_SNIFF_BYTES = 8192;
 const PATH_SEARCH_MIN_CANDIDATES = 120;
 const PATH_SEARCH_CANDIDATE_MULTIPLIER = 8;
-const TIMEOUT = Symbol('timeout');
-const IMAGE_PREVIEW_MEDIA_TYPES = new Map([
-  ['.png', 'image/png'],
-  ['.jpg', 'image/jpeg'],
-  ['.jpeg', 'image/jpeg'],
-  ['.gif', 'image/gif'],
-  ['.webp', 'image/webp'],
-  ['.bmp', 'image/bmp'],
-  ['.ico', 'image/x-icon'],
-  ['.avif', 'image/avif'],
-  ['.svg', 'image/svg+xml'],
+const TIMEOUT = /* @__PURE__ */ Symbol("timeout");
+function processError(value) {
+  if (value instanceof Error) return value;
+  return Object.assign(new Error(String(value)), { cause: value });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+const IMAGE_PREVIEW_MEDIA_TYPES = /* @__PURE__ */ new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".bmp", "image/bmp"],
+  [".ico", "image/x-icon"],
+  [".avif", "image/avif"],
+  [".svg", "image/svg+xml"]
 ]);
-const TEXT_IMAGE_PREVIEW_EXTENSIONS = new Set(['.svg']);
-const IGNORED_NAMES = new Set([
-  '.git',
-  '.farming',
-  'node_modules',
-  'dist',
-  'build',
-  'coverage',
-  '.next',
-  '.vite',
+const TEXT_IMAGE_PREVIEW_EXTENSIONS = /* @__PURE__ */ new Set([".svg"]);
+const IGNORED_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  ".farming",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".vite"
 ]);
-const SEARCH_IGNORED_NAMES = new Set([
+const SEARCH_IGNORED_NAMES = /* @__PURE__ */ new Set([
   ...IGNORED_NAMES,
-  '.dolt',
-  '.doltcfg',
-  '.idea',
-  '.vscode',
-  '.tmp',
-  '.DS_Store',
-  'dist-release',
-  'reference',
-  'test-results',
-  'playwright-report',
-  'server.log',
-  'local-farming.log',
-  '.turbo',
-  '.cache',
-  '.pytest_cache',
-  '.mypy_cache',
-  '.ruff_cache',
-  '__pycache__',
+  ".dolt",
+  ".doltcfg",
+  ".idea",
+  ".vscode",
+  ".tmp",
+  ".DS_Store",
+  "dist-release",
+  "reference",
+  "test-results",
+  "playwright-report",
+  "server.log",
+  "local-farming.log",
+  ".turbo",
+  ".cache",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  "__pycache__"
 ]);
-const EXPANDED_SEARCH_IGNORED_NAMES = new Set([
-  '.git',
-  '.DS_Store',
-  'server.log',
-  'local-farming.log',
-  'node_modules',
-  'dist',
-  'build',
-  'coverage',
-  '.next',
-  '.vite',
-  '.turbo',
-  '.cache',
-  '.pytest_cache',
-  '.mypy_cache',
-  '.ruff_cache',
-  '__pycache__',
-  'test-results',
-  'playwright-report',
+const EXPANDED_SEARCH_IGNORED_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  ".DS_Store",
+  "server.log",
+  "local-farming.log",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".vite",
+  ".turbo",
+  ".cache",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  "__pycache__",
+  "test-results",
+  "playwright-report"
 ]);
-const HIDDEN_NAMES = new Set([
+const HIDDEN_NAMES = /* @__PURE__ */ new Set([
   ...IGNORED_NAMES,
-  '.dolt',
-  '.doltcfg',
-  '.idea',
-  '.vscode',
-  '.tmp',
-  '.DS_Store',
-  'dist-release',
-  'reference',
-  'test-results',
-  'playwright-report',
-  'server.log',
-  'local-farming.log',
-  '.turbo',
-  '.cache',
-  '.pytest_cache',
-  '.mypy_cache',
-  '.ruff_cache',
-  '__pycache__',
+  ".dolt",
+  ".doltcfg",
+  ".idea",
+  ".vscode",
+  ".tmp",
+  ".DS_Store",
+  "dist-release",
+  "reference",
+  "test-results",
+  "playwright-report",
+  "server.log",
+  "local-farming.log",
+  ".turbo",
+  ".cache",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  "__pycache__"
 ]);
-const TREE_HIDDEN_NAMES = new Set([
-  '.git',
-  '.DS_Store',
-  'server.log',
-  'local-farming.log',
+const TREE_HIDDEN_NAMES = /* @__PURE__ */ new Set([
+  ".git",
+  ".DS_Store",
+  "server.log",
+  "local-farming.log"
 ]);
-
 function gitDiffWhitespaceArgs(value) {
-  if (value === 'ALL' || value === 'IGNORE_ALL') return ['--ignore-all-space'];
-  if (value === 'TRAILING' || value === 'IGNORE_TRAILING') return ['--ignore-space-at-eol'];
-  if (value === 'LEADING_AND_TRAILING' || value === 'IGNORE_LEADING_AND_TRAILING') return ['--ignore-space-change'];
+  if (value === "ALL" || value === "IGNORE_ALL") return ["--ignore-all-space"];
+  if (value === "TRAILING" || value === "IGNORE_TRAILING") return ["--ignore-space-at-eol"];
+  if (value === "LEADING_AND_TRAILING" || value === "IGNORE_LEADING_AND_TRAILING") return ["--ignore-space-change"];
   return [];
 }
-
 function gitDiffContextArgs(value) {
   const context = Number(value);
   if (!Number.isInteger(context) || context < 0) return [];
-  return [`--unified=${Math.min(context, 10000)}`];
+  return [`--unified=${Math.min(context, 1e4)}`];
 }
-
 function resolveBundledRipgrepPath() {
-  const script = path.join(__dirname, '..', 'node_modules', 'ripgrep', 'lib', 'rg.mjs');
+  const script = path.join(__dirname, "..", "node_modules", "ripgrep", "lib", "rg.mjs");
   if (fs.existsSync(script)) return script;
-  const binaryName = process.platform === 'win32' ? 'rg.cmd' : 'rg';
-  const bin = path.join(__dirname, '..', 'node_modules', '.bin', binaryName);
-  return fs.existsSync(bin) ? bin : '';
+  const binaryName = process.platform === "win32" ? "rg.cmd" : "rg";
+  const bin = path.join(__dirname, "..", "node_modules", ".bin", binaryName);
+  return fs.existsSync(bin) ? bin : "";
 }
-
 function resolveBundledRipgrepModulePath() {
   try {
-    return require.resolve('ripgrep');
+    return require.resolve("ripgrep");
   } catch {
-    const candidate = path.join(__dirname, '..', 'node_modules', 'ripgrep', 'lib', 'index.mjs');
-    return fs.existsSync(candidate) ? candidate : '';
+    const candidate = path.join(__dirname, "..", "node_modules", "ripgrep", "lib", "index.mjs");
+    return fs.existsSync(candidate) ? candidate : "";
   }
 }
-
 function isCommandUnavailable(error) {
-  return error && (error.code === 'ENOENT' || error.code === 'EACCES');
+  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "EACCES");
 }
-
 class WorkspaceFileError extends Error {
+  details;
+  statusCode;
   constructor(message, statusCode = 400, details = {}) {
     super(message);
-    this.name = 'WorkspaceFileError';
+    this.name = "WorkspaceFileError";
     this.statusCode = statusCode;
     this.details = details;
   }
 }
-
 function resolveCommandRunnerNodePath(options = {}) {
   return options.nodePath || process.env.FARMING_NODE_BIN || process.execPath;
 }
-
 function isPackagedRuntime() {
-  return Boolean(process.pkg) || process.env.FARMING_PACKAGED_RUNTIME === '1';
+  return Boolean(process.pkg) || process.env.FARMING_PACKAGED_RUNTIME === "1";
 }
-
 let chokidarPromise = null;
-
 async function loadChokidar() {
   if (!chokidarPromise) {
-    chokidarPromise = import('chokidar').then(module => module.default || module);
+    chokidarPromise = import("chokidar").then((module2) => module2.default || module2);
   }
   return chokidarPromise;
 }
-
 class CommandRunner {
+  child;
+  helperPath;
+  nextId;
+  nodePath;
+  pending;
+  ready;
   constructor(options = {}) {
-    this.helperPath = options.helperPath || path.join(__dirname, 'command-runner-child.js');
+    this.helperPath = options.helperPath || path.join(__dirname, "command-runner-child.cjs");
     this.nodePath = resolveCommandRunnerNodePath(options);
     this.nextId = 1;
-    this.pending = new Map();
+    this.pending = /* @__PURE__ */ new Map();
     this.child = null;
     this.ready = false;
     if (!options.disableHelper && !isPackagedRuntime()) {
       this.start();
     }
   }
-
   start() {
     try {
       this.child = spawn(this.nodePath, [this.helperPath], {
         cwd: __dirname,
         env: process.env,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        stdio: ["pipe", "pipe", "pipe"]
       });
     } catch {
       this.child = null;
       return;
     }
-
+    const child = this.child;
+    if (!child) return;
     this.ready = true;
     const rl = readline.createInterface({
-      input: this.child.stdout,
-      crlfDelay: Infinity,
+      input: child.stdout,
+      crlfDelay: Infinity
     });
-
-    rl.on('line', line => {
+    rl.on("line", (line) => {
       let response;
       try {
         response = JSON.parse(line);
       } catch {
         return;
       }
-
       const pending = this.pending.get(response.id);
       if (!pending) return;
       this.pending.delete(response.id);
-
       if (response.ok) {
         pending.resolve({
-          stdout: response.stdout || '',
-          stderr: response.stderr || '',
+          stdout: response.stdout || "",
+          stderr: response.stderr || ""
         });
         return;
       }
-
-      const error = new Error(response.error?.message || 'command failed');
+      const error = new Error(response.error?.message || "command failed");
       error.code = response.error?.code;
       error.signal = response.error?.signal;
-      error.stdout = response.error?.stdout || '';
-      error.stderr = response.error?.stderr || '';
+      error.stdout = response.error?.stdout || "";
+      error.stderr = response.error?.stderr || "";
       pending.reject(error);
     });
-
-    this.child.stderr.on('data', data => {
-      const text = String(data || '').trim();
-      if (text) console.error('Workspace command helper:', text);
+    child.stderr.on("data", (data) => {
+      const text = String(data || "").trim();
+      if (text) console.error("Workspace command helper:", text);
     });
-
-    this.child.on('error', () => {
+    child.on("error", () => {
       this.ready = false;
       this.child = null;
       const pending = Array.from(this.pending.values());
       this.pending.clear();
-      pending.forEach(({ reject }) => reject(new Error('workspace command helper failed')));
+      pending.forEach(({ reject }) => reject(new Error("workspace command helper failed")));
     });
-
-    this.child.on('exit', () => {
+    child.on("exit", () => {
       this.ready = false;
       this.child = null;
       const pending = Array.from(this.pending.values());
       this.pending.clear();
-      pending.forEach(({ reject }) => reject(new Error('workspace command helper exited')));
+      pending.forEach(({ reject }) => reject(new Error("workspace command helper exited")));
     });
   }
-
   run(command, args, options = {}) {
     if (!this.ready || !this.child || !this.child.stdin.writable) {
       return execFileAsync(command, args, options);
     }
-
     const id = String(this.nextId++);
+    const child = this.child;
     const request = {
       id,
       command,
@@ -274,19 +319,18 @@ class CommandRunner {
       cwd: options.cwd,
       env: options.env,
       maxBuffer: options.maxBuffer,
-      timeout: options.timeout,
+      timeout: options.timeout
     };
-
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject });
-      this.child.stdin.write(`${JSON.stringify(request)}\n`, error => {
+      child.stdin.write(`${JSON.stringify(request)}
+`, (error) => {
         if (!error) return;
         this.pending.delete(id);
         reject(error);
       });
     });
   }
-
   dispose() {
     if (!this.child) return;
     this.child.kill();
@@ -294,76 +338,61 @@ class CommandRunner {
     this.ready = false;
   }
 }
-
 function isInside(root, target) {
   const relative = path.relative(root, target);
-  return relative === '' || Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative);
+  return relative === "" || Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
 }
-
 function isInsideAnyRoot(roots, target) {
   return (Array.isArray(roots) ? roots : []).some((root) => {
     let realRoot = root;
     try {
       realRoot = fs.realpathSync(root);
     } catch {
-      // Missing allowed roots cannot authorize a resolved target.
     }
     return isInside(realRoot, target);
   });
 }
-
 function joinRelativePath(parentPath, name) {
-  return [String(parentPath || '').replace(/\/+$/, ''), name]
-    .filter(Boolean)
-    .join('/')
-    .replace(/\\/g, '/');
-}
-
-function normalizeUserPath(userPath = '') {
-  const value = String(userPath || '').trim();
-  if (!value || value === '.') return '';
+  return [String(parentPath || "").replace(/\/+$/, ""), name].filter(Boolean).join("/").replace(/\\/g, "/");
+}
+function normalizeUserPath(userPath = "") {
+  const value = String(userPath || "").trim();
+  if (!value || value === ".") return "";
   if (path.isAbsolute(value)) {
-    throw new WorkspaceFileError('absolute paths are not allowed', 400);
+    throw new WorkspaceFileError("absolute paths are not allowed", 400);
   }
   const normalized = path.normalize(value);
-  if (normalized === '..' || normalized.startsWith(`..${path.sep}`)) {
-    throw new WorkspaceFileError('path must stay inside the workspace', 403);
+  if (normalized === ".." || normalized.startsWith(`..${path.sep}`)) {
+    throw new WorkspaceFileError("path must stay inside the workspace", 403);
   }
-  return normalized === '.' ? '' : normalized;
+  return normalized === "." ? "" : normalized;
 }
-
 function relativeFromRoot(root, target) {
   const relative = path.relative(root, target);
-  return relative.split(path.sep).join('/');
+  return relative.split(path.sep).join("/");
 }
-
 function normalizeSearchResultPath(resultPath) {
-  return String(resultPath || '').replace(/^\.\//, '');
+  return String(resultPath || "").replace(/^\.\//, "");
 }
-
 function searchIgnoredNames(includeIgnored = false) {
   return includeIgnored ? EXPANDED_SEARCH_IGNORED_NAMES : SEARCH_IGNORED_NAMES;
 }
-
 function searchExcludeGlobArgs() {
   const args = [];
   SEARCH_IGNORED_NAMES.forEach((name) => {
-    args.push('--glob', `!${name}/**`);
-    args.push('--glob', `!**/${name}/**`);
+    args.push("--glob", `!${name}/**`);
+    args.push("--glob", `!**/${name}/**`);
   });
   return args;
 }
-
 function isSearchIgnoredRelativePath(relativePath, includeIgnored = false) {
-  return String(relativePath || '').split(/[\\/]/).some(part => searchIgnoredNames(includeIgnored).has(part));
+  return String(relativePath || "").split(/[\\/]/).some((part) => searchIgnoredNames(includeIgnored).has(part));
 }
-
 function shouldPruneDirectoryNameSearch(relativePath) {
-  return String(relativePath || '').split(/[\\/]/).some(part => IGNORED_NAMES.has(part));
+  return String(relativePath || "").split(/[\\/]/).some((part) => IGNORED_NAMES.has(part));
 }
-
 function gitStatusExcludePathspecArgs() {
-  const args = ['--', '.'];
+  const args = ["--", "."];
   HIDDEN_NAMES.forEach((name) => {
     args.push(`:(exclude)${name}`);
     args.push(`:(exclude)${name}/**`);
@@ -372,9 +401,8 @@ function gitStatusExcludePathspecArgs() {
   });
   return args;
 }
-
-function gitSearchExcludePathspecArgs(includeIgnored = false, searchPath = '.') {
-  const args = ['--', searchPath];
+function gitSearchExcludePathspecArgs(includeIgnored = false, searchPath = ".") {
+  const args = ["--", searchPath];
   searchIgnoredNames(includeIgnored).forEach((name) => {
     args.push(`:(exclude)${name}`);
     args.push(`:(exclude)${name}/**`);
@@ -383,27 +411,22 @@ function gitSearchExcludePathspecArgs(includeIgnored = false, searchPath = '.')
   });
   return args;
 }
-
 function normalizeGitStatusPath(resultPath) {
-  return normalizeSearchResultPath(resultPath).replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+  return normalizeSearchResultPath(resultPath).replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
 }
-
 function sha1(buffer) {
-  return crypto.createHash('sha1').update(buffer).digest('hex');
+  return crypto.createHash("sha1").update(buffer).digest("hex");
 }
-
 function previewForPath(filePath, options = {}) {
   const extension = path.extname(filePath).toLowerCase();
-  if (extension === '.pdf') return { kind: 'pdf', mediaType: 'application/pdf' };
+  if (extension === ".pdf") return { kind: "pdf", mediaType: "application/pdf" };
   if (!options.includeTextImages && TEXT_IMAGE_PREVIEW_EXTENSIONS.has(extension)) return null;
   const mediaType = IMAGE_PREVIEW_MEDIA_TYPES.get(extension);
-  return mediaType ? { kind: 'image', mediaType } : null;
+  return mediaType ? { kind: "image", mediaType } : null;
 }
-
 function metadataFileVersion(relativePath, stat) {
-  return sha1(Buffer.from(`${relativePath}:${stat.size}:${stat.mtimeMs}`, 'utf8'));
+  return sha1(Buffer.from(`${relativePath}:${stat.size}:${stat.mtimeMs}`, "utf8"));
 }
-
 function workspaceEntryVersion(stat) {
   return sha1(Buffer.from([
     stat.dev,
@@ -411,28 +434,25 @@ function workspaceEntryVersion(stat) {
     stat.mode,
     stat.size,
     stat.mtimeMs,
-    stat.ctimeMs,
-  ].join(':'), 'utf8'));
+    stat.ctimeMs
+  ].join(":"), "utf8"));
 }
-
 async function readTextPrefix(target, maxBytes) {
-  const handle = await fsp.open(target, 'r');
+  const handle = await fsp.open(target, "r");
   try {
     const buffer = Buffer.alloc(maxBytes);
     const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
-    return buffer.subarray(0, bytesRead).toString('utf8');
+    return buffer.subarray(0, bytesRead).toString("utf8");
   } finally {
     await handle.close();
   }
 }
-
 async function isProbablyBinaryFile(target) {
-  const handle = await fsp.open(target, 'r');
+  const handle = await fsp.open(target, "r");
   try {
     const buffer = Buffer.alloc(BINARY_SNIFF_BYTES);
     const { bytesRead } = await handle.read(buffer, 0, BINARY_SNIFF_BYTES, 0);
     if (bytesRead === 0) return false;
-
     let suspiciousControlBytes = 0;
     for (let index = 0; index < bytesRead; index += 1) {
       const byte = buffer[index];
@@ -442,48 +462,41 @@ async function isProbablyBinaryFile(target) {
         suspiciousControlBytes += 1;
       }
     }
-
     return suspiciousControlBytes / bytesRead > 0.3;
   } finally {
     await handle.close();
   }
 }
-
 function shouldIgnorePath(filePath) {
-  return filePath.split(path.sep).some(part => IGNORED_NAMES.has(part));
+  return filePath.split(path.sep).some((part) => IGNORED_NAMES.has(part));
 }
-
 function shouldHidePath(filePath) {
-  return String(filePath || '').split(/[\\/]/).some(part => HIDDEN_NAMES.has(part));
+  return String(filePath || "").split(/[\\/]/).some((part) => HIDDEN_NAMES.has(part));
 }
-
 function normalizeEntryName(name) {
-  const value = String(name || '').trim();
-  if (!value || value === '.' || value === '..') {
-    throw new WorkspaceFileError('name is required', 400);
+  const value = String(name || "").trim();
+  if (!value || value === "." || value === "..") {
+    throw new WorkspaceFileError("name is required", 400);
   }
-  if (value.includes('/') || value.includes('\\') || path.basename(value) !== value) {
-    throw new WorkspaceFileError('name must be a single path segment', 400);
+  if (value.includes("/") || value.includes("\\") || path.basename(value) !== value) {
+    throw new WorkspaceFileError("name must be a single path segment", 400);
   }
   if (IGNORED_NAMES.has(value)) {
-    throw new WorkspaceFileError('ignored paths cannot be changed', 403);
+    throw new WorkspaceFileError("ignored paths cannot be changed", 403);
   }
   return value;
 }
-
 function parentDirectory(filePath) {
-  const normalized = String(filePath || '').replace(/\/+$/, '');
-  const index = normalized.lastIndexOf('/');
-  return index === -1 ? '' : normalized.slice(0, index);
+  const normalized = String(filePath || "").replace(/\/+$/, "");
+  const index = normalized.lastIndexOf("/");
+  return index === -1 ? "" : normalized.slice(0, index);
 }
-
 function execFileAsync(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     execFile(command, args, {
-      encoding: 'utf8',
+      encoding: "utf8",
       maxBuffer: 2 * 1024 * 1024,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      ...options,
+      ...options
     }, (error, stdout, stderr) => {
       if (error) {
         error.stdout = stdout;
@@ -495,92 +508,83 @@ function execFileAsync(command, args, options = {}) {
     });
   });
 }
-
 function gitStatusKind(statusCode) {
-  if (!statusCode || statusCode.length < 2) return 'modified';
-  if (statusCode === '??') return 'untracked';
-  if (statusCode.includes('U') || statusCode === 'AA' || statusCode === 'DD') return 'conflicted';
-  if (statusCode.includes('D')) return 'deleted';
-  if (statusCode.includes('A')) return 'added';
-  if (statusCode.includes('R')) return 'renamed';
-  if (statusCode.includes('M')) return 'modified';
-  return 'modified';
-}
-
+  const code = String(statusCode || "");
+  if (code.length < 2) return "modified";
+  if (code === "??") return "untracked";
+  if (code.includes("U") || code === "AA" || code === "DD") return "conflicted";
+  if (code.includes("D")) return "deleted";
+  if (code.includes("A")) return "added";
+  if (code.includes("R")) return "renamed";
+  if (code.includes("M")) return "modified";
+  return "modified";
+}
 function gitStatusLabel(kind) {
-  if (kind === 'added') return 'A';
-  if (kind === 'deleted') return 'D';
-  if (kind === 'renamed') return 'R';
-  if (kind === 'untracked') return 'U';
-  if (kind === 'conflicted') return '!';
-  return 'M';
-}
-
+  if (kind === "added") return "A";
+  if (kind === "deleted") return "D";
+  if (kind === "renamed") return "R";
+  if (kind === "untracked") return "U";
+  if (kind === "conflicted") return "!";
+  return "M";
+}
 function gitStatusReviewRank(kind) {
-  if (kind === 'conflicted') return 0;
-  if (kind === 'modified') return 1;
-  if (kind === 'added') return 2;
-  if (kind === 'deleted') return 3;
-  if (kind === 'renamed') return 4;
-  if (kind === 'untracked') return 5;
+  if (kind === "conflicted") return 0;
+  if (kind === "modified") return 1;
+  if (kind === "added") return 2;
+  if (kind === "deleted") return 3;
+  if (kind === "renamed") return 4;
+  if (kind === "untracked") return 5;
   return 6;
 }
-
 function normalizeGitHistoryLimit(value) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 1) return DEFAULT_GIT_HISTORY_LIMIT;
   return Math.min(parsed, MAX_GIT_HISTORY_LIMIT);
 }
-
 function normalizeGitHistorySkip(value) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed < 0) return 0;
-  return Math.min(parsed, 1_000_000);
+  return Math.min(parsed, 1e6);
 }
-
-function normalizeGitObjectId(value, fieldName = 'commit') {
-  const normalized = String(value || '').trim();
+function normalizeGitObjectId(value, fieldName = "commit") {
+  const normalized = String(value || "").trim();
   if (!/^[0-9a-f]{40,64}$/i.test(normalized)) {
     throw new WorkspaceFileError(`${fieldName} must be a full git object id`, 400);
   }
   return normalized.toLowerCase();
 }
-
 function gitEmptyTreeObjectId(objectFormat) {
-  const algorithm = objectFormat === 'sha256' ? 'sha256' : 'sha1';
-  return crypto.createHash(algorithm).update(Buffer.from('tree 0\0')).digest('hex');
+  const algorithm = objectFormat === "sha256" ? "sha256" : "sha1";
+  return crypto.createHash(algorithm).update(Buffer.from("tree 0\0")).digest("hex");
 }
-
 function gitHistoryReference(value) {
-  let id = String(value || '').trim();
+  let id = String(value || "").trim();
   if (!id) return null;
-  if (id.startsWith('tag: ')) id = id.slice(5);
-  if (id === 'HEAD') return { id, name: id, category: 'head' };
-  if (id.startsWith('refs/heads/')) {
-    return { id, name: id.slice('refs/heads/'.length), category: 'local-branch' };
+  if (id.startsWith("tag: ")) id = id.slice(5);
+  if (id === "HEAD") return { id, name: id, category: "head" };
+  if (id.startsWith("refs/heads/")) {
+    return { id, name: id.slice("refs/heads/".length), category: "local-branch" };
   }
-  if (id.startsWith('refs/remotes/')) {
+  if (id.startsWith("refs/remotes/")) {
     if (/\/HEAD$/.test(id)) return null;
-    return { id, name: id.slice('refs/remotes/'.length), category: 'remote-branch' };
+    return { id, name: id.slice("refs/remotes/".length), category: "remote-branch" };
   }
-  if (id.startsWith('refs/tags/')) {
-    return { id, name: id.slice('refs/tags/'.length), category: 'tag' };
+  if (id.startsWith("refs/tags/")) {
+    return { id, name: id.slice("refs/tags/".length), category: "tag" };
   }
-  return { id, name: id.replace(/^refs\//, ''), category: 'reference' };
+  return { id, name: id.replace(/^refs\//, ""), category: "reference" };
 }
-
 function parseGitHistoryReferences(value) {
   const references = [];
-  const seen = new Set();
-  const add = candidate => {
+  const seen = /* @__PURE__ */ new Set();
+  const add = (candidate) => {
     const reference = gitHistoryReference(candidate);
     if (!reference || seen.has(reference.id)) return;
     seen.add(reference.id);
     references.push(reference);
   };
-
-  String(value || '').split(', ').forEach(decoration => {
-    const arrowIndex = decoration.indexOf(' -> ');
+  String(value || "").split(", ").forEach((decoration) => {
+    const arrowIndex = decoration.indexOf(" -> ");
     if (arrowIndex === -1) {
       add(decoration);
       return;
@@ -590,9 +594,8 @@ function parseGitHistoryReferences(value) {
   });
   return references;
 }
-
 function parseGitHistoryLog(stdout) {
-  const fields = String(stdout || '').split('\0');
+  const fields = String(stdout || "").split("\0");
   const items = [];
   for (let index = 0; index + 7 < fields.length; index += 8) {
     const id = fields[index];
@@ -601,170 +604,142 @@ function parseGitHistoryLog(stdout) {
     items.push({
       id,
       displayId: id.slice(0, 8),
-      parentIds: fields[index + 1].split(' ').filter(Boolean),
+      parentIds: fields[index + 1].split(" ").filter(Boolean),
       author: fields[index + 2],
       authorEmail: fields[index + 3],
-      timestamp: Number.isFinite(timestamp) ? timestamp : undefined,
+      timestamp: Number.isFinite(timestamp) ? timestamp : void 0,
       subject: fields[index + 5],
-      message: String(fields[index + 6] || '').trimEnd(),
-      references: parseGitHistoryReferences(fields[index + 7]),
+      message: String(fields[index + 6] || "").trimEnd(),
+      references: parseGitHistoryReferences(fields[index + 7])
     });
   }
   return items;
 }
-
 function gitHistoryChangeKind(statusCode) {
-  if (statusCode.startsWith('A')) return 'added';
-  if (statusCode.startsWith('D')) return 'deleted';
-  if (statusCode.startsWith('R')) return 'renamed';
-  if (statusCode.startsWith('C')) return 'copied';
-  if (statusCode.startsWith('T')) return 'type-changed';
-  return 'modified';
-}
-
+  const code = String(statusCode || "");
+  if (code.startsWith("A")) return "added";
+  if (code.startsWith("D")) return "deleted";
+  if (code.startsWith("R")) return "renamed";
+  if (code.startsWith("C")) return "copied";
+  if (code.startsWith("T")) return "type-changed";
+  return "modified";
+}
 function gitHistoryChangeLabel(kind) {
-  if (kind === 'added') return 'A';
-  if (kind === 'deleted') return 'D';
-  if (kind === 'renamed') return 'R';
-  if (kind === 'copied') return 'C';
-  if (kind === 'type-changed') return 'T';
-  return 'M';
-}
-
+  if (kind === "added") return "A";
+  if (kind === "deleted") return "D";
+  if (kind === "renamed") return "R";
+  if (kind === "copied") return "C";
+  if (kind === "type-changed") return "T";
+  return "M";
+}
 function parseGitHistoryChanges(stdout) {
-  const fields = String(stdout || '').split('\0');
+  const fields = String(stdout || "").split("\0");
   const items = [];
-  for (let index = 0; index < fields.length;) {
+  for (let index = 0; index < fields.length; ) {
     const statusCode = fields[index++];
     if (!statusCode) continue;
     const kind = gitHistoryChangeKind(statusCode);
-    if (kind === 'renamed' || kind === 'copied') {
-      const previousPath = fields[index++] || '';
-      const filePath = fields[index++] || '';
-      if (!filePath) continue;
-      items.push({ path: filePath, previousPath, status: kind, statusLabel: gitHistoryChangeLabel(kind) });
+    if (kind === "renamed" || kind === "copied") {
+      const previousPath = fields[index++] || "";
+      const filePath2 = fields[index++] || "";
+      if (!filePath2) continue;
+      items.push({ path: filePath2, previousPath, status: kind, statusLabel: gitHistoryChangeLabel(kind) });
       continue;
     }
-    const filePath = fields[index++] || '';
+    const filePath = fields[index++] || "";
     if (!filePath) continue;
     items.push({ path: filePath, status: kind, statusLabel: gitHistoryChangeLabel(kind) });
   }
   return items;
 }
-
 async function workspaceEntryTypeForGitChange(root, filePath) {
   try {
-    const stat = await fsp.lstat(path.join(root, filePath.replace(/\/+$/, '')));
-    if (stat.isDirectory()) return 'directory';
-    if (stat.isFile()) return 'file';
-    if (stat.isSymbolicLink()) return 'symlink';
-    return 'other';
+    const stat = await fsp.lstat(path.join(root, filePath.replace(/\/+$/, "")));
+    if (stat.isDirectory()) return "directory";
+    if (stat.isFile()) return "file";
+    if (stat.isSymbolicLink()) return "symlink";
+    return "other";
   } catch {
-    return 'file';
+    return "file";
   }
 }
-
 function gitStatusRank(kind) {
-  if (kind === 'conflicted') return 6;
-  if (kind === 'deleted') return 5;
-  if (kind === 'modified') return 4;
-  if (kind === 'renamed') return 3;
-  if (kind === 'added') return 2;
-  if (kind === 'untracked') return 1;
+  if (kind === "conflicted") return 6;
+  if (kind === "deleted") return 5;
+  if (kind === "modified") return 4;
+  if (kind === "renamed") return 3;
+  if (kind === "added") return 2;
+  if (kind === "untracked") return 1;
   return 0;
 }
-
 function isPathWordBoundary(text, index) {
   if (index === 0) return true;
-  const previous = text[index - 1] || '';
-  const current = text[index] || '';
+  const previous = text[index - 1] || "";
+  const current = text[index] || "";
   if (/[-_\s./\\]/.test(previous)) return true;
   return /[a-z0-9]/.test(previous) && /[A-Z]/.test(current);
 }
-
 function scoreBoundaryMatch(text, normalizedQuery) {
   if (!text || !normalizedQuery || normalizedQuery.length > 6) return null;
   let queryIndex = 0;
   let score = 0;
-
   for (let textIndex = 0; textIndex < text.length && queryIndex < normalizedQuery.length; textIndex += 1) {
     if (!isPathWordBoundary(text, textIndex)) continue;
     if (text[textIndex].toLowerCase() !== normalizedQuery[queryIndex]) continue;
     score += textIndex;
     queryIndex += 1;
   }
-
   return queryIndex === normalizedQuery.length ? score : null;
 }
-
 function scorePathMatch(filePath, query, options = {}) {
   const pathText = normalizeSearchResultPath(filePath);
   const normalizedPath = pathText.toLowerCase();
-  const normalizedQuery = String(query || '').trim().replace(/^\.\/+/, '').toLowerCase();
+  const normalizedQuery = String(query || "").trim().replace(/^\.\/+/, "").toLowerCase();
   if (!normalizedPath || !normalizedQuery) return null;
-
   const fileNameText = path.posix.basename(pathText);
   const fileName = fileNameText.toLowerCase();
   if (normalizedPath === normalizedQuery) return 0;
   if (fileName === normalizedQuery) return 1;
-
   const nameBoundaryScore = scoreBoundaryMatch(fileNameText, normalizedQuery);
   if (nameBoundaryScore !== null) return 5 + nameBoundaryScore / 100;
-
   const nameIndex = fileName.indexOf(normalizedQuery);
   if (nameIndex !== -1) return 10 + nameIndex;
-
   if (options.allowPathMatch === false) return null;
-
   const pathIndex = normalizedPath.indexOf(normalizedQuery);
   if (pathIndex !== -1) return 40 + pathIndex;
-
   if (normalizedQuery.length > 6) return null;
-
   let queryIndex = 0;
   let score = 80;
-  for (let pathIndex = 0; pathIndex < normalizedPath.length && queryIndex < normalizedQuery.length; pathIndex += 1) {
-    if (normalizedPath[pathIndex] !== normalizedQuery[queryIndex]) continue;
-    score += pathIndex;
+  for (let pathIndex2 = 0; pathIndex2 < normalizedPath.length && queryIndex < normalizedQuery.length; pathIndex2 += 1) {
+    if (normalizedPath[pathIndex2] !== normalizedQuery[queryIndex]) continue;
+    score += pathIndex2;
     queryIndex += 1;
   }
-
   return queryIndex === normalizedQuery.length ? score : null;
 }
-
 function pathSearchEntryRank(entryType) {
-  return entryType === 'directory' ? 0 : 1;
+  return entryType === "directory" ? 0 : 1;
 }
-
 function pathSearchDepth(filePath) {
-  return normalizeSearchResultPath(filePath).split('/').filter(Boolean).length;
+  return normalizeSearchResultPath(filePath).split("/").filter(Boolean).length;
 }
-
 function comparePathSearchMatches(a, b) {
-  return (
-    a.score - b.score ||
-    pathSearchDepth(a.path) - pathSearchDepth(b.path) ||
-    pathSearchEntryRank(a.entryType) - pathSearchEntryRank(b.entryType) ||
-    a.path.localeCompare(b.path)
-  );
-}
-
+  return (a.score ?? 0) - (b.score ?? 0) || pathSearchDepth(a.path) - pathSearchDepth(b.path) || pathSearchEntryRank(a.entryType) - pathSearchEntryRank(b.entryType) || a.path.localeCompare(b.path);
+}
 function pathSearchMatchForPath(filePath, query, entryType, allowPathMatch) {
   const score = scorePathMatch(filePath, query, { allowPathMatch });
   if (score === null) return null;
   return {
-    path: filePath,
+    path: normalizeSearchResultPath(filePath),
     entryType,
-    score,
+    score
   };
 }
-
 function directoryNameSearchScore(directoryPath, query, allowPathMatch) {
   const pathText = normalizeSearchResultPath(directoryPath);
   const normalizedPath = pathText.toLowerCase();
-  const normalizedQuery = String(query || '').trim().replace(/^\.\/+/, '').toLowerCase();
+  const normalizedQuery = String(query || "").trim().replace(/^\.\/+/, "").toLowerCase();
   if (!normalizedPath || !normalizedQuery) return null;
-
   const directoryName = path.posix.basename(pathText).toLowerCase();
   if (normalizedPath === normalizedQuery) return 0;
   if (directoryName === normalizedQuery) return 1;
@@ -778,45 +753,40 @@ function directoryNameSearchScore(directoryPath, query, allowPathMatch) {
   if (pathIndex !== -1) return 40 + pathIndex;
   return null;
 }
-
 function directoryNameSearchMatchForPath(directoryPath, query, allowPathMatch) {
   const score = directoryNameSearchScore(directoryPath, query, allowPathMatch);
   if (score === null) return null;
   return {
-    path: directoryPath,
-    entryType: 'directory',
-    score,
+    path: normalizeSearchResultPath(directoryPath),
+    entryType: "directory",
+    score
   };
 }
-
 function ancestorDirectoryPaths(filePath) {
-  const segments = normalizeSearchResultPath(filePath).split('/').filter(Boolean);
+  const segments = normalizeSearchResultPath(filePath).split("/").filter(Boolean);
   const ancestors = [];
   for (let index = 1; index < segments.length; index += 1) {
-    ancestors.push(segments.slice(0, index).join('/'));
+    ancestors.push(segments.slice(0, index).join("/"));
   }
   return ancestors;
 }
-
 function pathSearchMatchesForFile(filePath, query, includeIgnored = false) {
   const allowPathMatch = isLikelyPathQuery(query);
   const matches = [];
-  const fileMatch = pathSearchMatchForPath(filePath, query, 'file', allowPathMatch);
+  const fileMatch = pathSearchMatchForPath(filePath, query, "file", allowPathMatch);
   if (fileMatch) matches.push(fileMatch);
   ancestorDirectoryPaths(filePath).forEach((directoryPath) => {
     if (isSearchIgnoredRelativePath(directoryPath, includeIgnored)) return;
-    const directoryMatch = pathSearchMatchForPath(directoryPath, query, 'directory', allowPathMatch);
+    const directoryMatch = pathSearchMatchForPath(directoryPath, query, "directory", allowPathMatch);
     if (directoryMatch) matches.push(directoryMatch);
   });
   return matches;
 }
-
 function isLikelyPathQuery(query) {
-  return /[./\\]/.test(String(query || '').trim());
+  return /[./\\]/.test(String(query || "").trim());
 }
-
 function dedupePathMatches(matches, limit) {
-  const seen = new Set();
+  const seen = /* @__PURE__ */ new Set();
   const deduped = [];
   for (const match of matches) {
     if (!match || seen.has(match.path)) continue;
@@ -826,110 +796,92 @@ function dedupePathMatches(matches, limit) {
   }
   return deduped;
 }
-
 function parseGitStatus(stdout) {
-  const records = String(stdout || '').split('\0').filter(Boolean);
-  const statusByPath = new Map();
-
+  const records = String(stdout || "").split("\0").filter(Boolean);
+  const statusByPath = /* @__PURE__ */ new Map();
   for (let index = 0; index < records.length; index += 1) {
     const record = records[index];
     if (record.length < 4) continue;
-
     const statusCode = record.slice(0, 2);
     const filePath = normalizeGitStatusPath(record.slice(3));
     if (!filePath) continue;
-
     const kind = gitStatusKind(statusCode);
-    const previousPath = statusCode.includes('R') || statusCode.includes('C')
-      ? normalizeGitStatusPath(records[index + 1])
-      : '';
+    const previousPath = statusCode.includes("R") || statusCode.includes("C") ? normalizeGitStatusPath(records[index + 1]) : "";
     statusByPath.set(filePath, {
       kind,
       label: gitStatusLabel(kind),
-      ...(previousPath ? { previousPath } : {}),
+      ...previousPath ? { previousPath } : {}
     });
-
-    if (statusCode.includes('R') || statusCode.includes('C')) {
+    if (statusCode.includes("R") || statusCode.includes("C")) {
       index += 1;
     }
   }
-
   return statusByPath;
 }
-
 function parseGitBlamePorcelain(stdout) {
-  const lines = String(stdout || '').split('\n');
+  const lines = String(stdout || "").split("\n");
   const blameLines = [];
   let index = 0;
-
   while (index < lines.length) {
     const header = lines[index];
-    const match = /^(\^?[0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/.exec(header || '');
+    const match = /^(\^?[0-9a-f]{40}) (\d+) (\d+)(?: (\d+))?$/.exec(header || "");
     if (!match) {
       index += 1;
       continue;
     }
-
     const entry = {
-      commit: match[1].replace(/^\^/, ''),
+      commit: match[1].replace(/^\^/, ""),
       originalLineNumber: Number(match[2]),
       lineNumber: Number(match[3]),
-      author: '',
-      authorMail: '',
+      author: "",
+      authorMail: "",
       authorTime: null,
-      authorTimeIso: '',
-      summary: '',
-      content: '',
+      authorTimeIso: "",
+      summary: "",
+      content: ""
     };
     index += 1;
-
     while (index < lines.length) {
       const line = lines[index];
       index += 1;
-      if (line.startsWith('\t')) {
+      if (line.startsWith("	")) {
         entry.content = line.slice(1);
         break;
       }
-
-      const separator = line.indexOf(' ');
+      const separator = line.indexOf(" ");
       const fieldName = separator === -1 ? line : line.slice(0, separator);
-      const value = separator === -1 ? '' : line.slice(separator + 1);
-      if (fieldName === 'author') entry.author = value;
-      if (fieldName === 'author-mail') entry.authorMail = value.replace(/^<|>$/g, '');
-      if (fieldName === 'author-time') {
+      const value = separator === -1 ? "" : line.slice(separator + 1);
+      if (fieldName === "author") entry.author = value;
+      if (fieldName === "author-mail") entry.authorMail = value.replace(/^<|>$/g, "");
+      if (fieldName === "author-time") {
         const time = Number(value);
         entry.authorTime = Number.isFinite(time) ? time : null;
-        entry.authorTimeIso = Number.isFinite(time) ? new Date(time * 1000).toISOString() : '';
+        entry.authorTimeIso = Number.isFinite(time) ? new Date(time * 1e3).toISOString() : "";
       }
-      if (fieldName === 'summary') entry.summary = value;
+      if (fieldName === "summary") entry.summary = value;
     }
-
     const uncommitted = /^0+$/.test(entry.commit);
     blameLines.push({
       ...entry,
-      shortCommit: uncommitted ? 'uncommitted' : entry.commit.slice(0, 8),
-      uncommitted,
+      shortCommit: uncommitted ? "uncommitted" : entry.commit.slice(0, 8),
+      uncommitted
     });
   }
-
   return blameLines;
 }
-
 function parseUnifiedDiffHunks(patch) {
-  const lines = String(patch || '').split('\n');
+  const lines = String(patch || "").split("\n");
   const hunks = [];
   let hunk = null;
-
   const finishHunk = () => {
     if (hunk) {
       hunks.push({
         ...hunk,
-        patch: hunk.patchLines.join('\n'),
+        patch: hunk.patchLines.join("\n")
       });
     }
     hunk = null;
   };
-
   for (const line of lines) {
     const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(line);
     if (match) {
@@ -940,21 +892,18 @@ function parseUnifiedDiffHunks(patch) {
         oldLines: Number(match[2] || 1),
         newStart: Number(match[3]),
         newLines: Number(match[4] || 1),
-        heading: match[5] ? match[5].trim() : '',
-        patchLines: [line],
+        heading: match[5] ? match[5].trim() : "",
+        patchLines: [line]
       };
       continue;
     }
-
     if (hunk) {
       hunk.patchLines.push(line);
     }
   }
-
   finishHunk();
   return hunks;
 }
-
 function intralineRanges(leftText, rightText) {
   const changes = diffChars(leftText, rightText, { timeout: 100 });
   if (!changes) return {};
@@ -978,28 +927,27 @@ function intralineRanges(leftText, rightText) {
     rightOffset += length;
   }
   return {
-    ...(left.length ? { left } : {}),
-    ...(right.length ? { right } : {}),
+    ...left.length ? { left } : {},
+    ...right.length ? { right } : {}
   };
 }
-
 function parseUnifiedDiffRows(patch) {
-  return parseUnifiedDiffHunks(patch).map(hunk => {
+  return parseUnifiedDiffHunks(patch).map((hunk) => {
     let oldLine = hunk.oldStart;
     let newLine = hunk.newStart;
     const rows = [];
     let previousCell = null;
     for (const line of hunk.patchLines.slice(1)) {
-      if (line.startsWith('\')) {
+      if (line.startsWith("\")) {
         if (previousCell) previousCell.missingNewlineAtEnd = true;
         continue;
       }
-      if (line.startsWith(' ')) {
+      if (line.startsWith(" ")) {
         const text = line.slice(1);
         const row = {
-          kind: 'context',
+          kind: "context",
           left: { line: oldLine, text },
-          right: { line: newLine, text },
+          right: { line: newLine, text }
         };
         rows.push(row);
         previousCell = row.right;
@@ -1007,40 +955,41 @@ function parseUnifiedDiffRows(patch) {
         newLine++;
         continue;
       }
-      if (line.startsWith('-')) {
-        const row = { kind: 'deleted', left: { line: oldLine, text: line.slice(1) } };
+      if (line.startsWith("-")) {
+        const row = { kind: "deleted", left: { line: oldLine, text: line.slice(1) } };
         rows.push(row);
         previousCell = row.left;
         oldLine++;
         continue;
       }
-      if (line.startsWith('+')) {
-        const row = { kind: 'added', right: { line: newLine, text: line.slice(1) } };
+      if (line.startsWith("+")) {
+        const row = { kind: "added", right: { line: newLine, text: line.slice(1) } };
         rows.push(row);
         previousCell = row.right;
         newLine++;
       }
     }
     const pairedRows = [];
-    for (let index = 0; index < rows.length;) {
-      if (rows[index].kind !== 'deleted') {
+    for (let index = 0; index < rows.length; ) {
+      if (rows[index].kind !== "deleted") {
         pairedRows.push(rows[index]);
         index += 1;
         continue;
       }
       const deleted = [];
-      while (index < rows.length && rows[index].kind === 'deleted') deleted.push(rows[index++]);
+      while (index < rows.length && rows[index].kind === "deleted") deleted.push(rows[index++]);
       const added = [];
-      while (index < rows.length && rows[index].kind === 'added') added.push(rows[index++]);
+      while (index < rows.length && rows[index].kind === "added") added.push(rows[index++]);
       const paired = Math.min(deleted.length, added.length);
       for (let pairIndex = 0; pairIndex < paired; pairIndex += 1) {
         const left = deleted[pairIndex].left;
         const right = added[pairIndex].right;
+        if (!left || !right) continue;
         const intraline = intralineRanges(left.text, right.text);
         pairedRows.push({
-          kind: 'changed',
-          left: { ...left, ...(intraline.left ? { intraline: intraline.left } : {}) },
-          right: { ...right, ...(intraline.right ? { intraline: intraline.right } : {}) },
+          kind: "changed",
+          left: { ...left, ...intraline.left ? { intraline: intraline.left } : {} },
+          right: { ...right, ...intraline.right ? { intraline: intraline.right } : {} }
         });
       }
       pairedRows.push(...deleted.slice(paired));
@@ -1052,55 +1001,48 @@ function parseUnifiedDiffRows(patch) {
       oldLines: hunk.oldLines,
       newStart: hunk.newStart,
       newLines: hunk.newLines,
-      rows: pairedRows,
+      rows: pairedRows
     };
   });
 }
-
 function lineInUnifiedDiffHunk(hunk, side, lineNumber) {
-  const start = side === 'old' ? hunk.oldStart : hunk.newStart;
-  const count = side === 'old' ? hunk.oldLines : hunk.newLines;
+  const start = side === "old" ? hunk.oldStart : hunk.newStart;
+  const count = side === "old" ? hunk.oldLines : hunk.newLines;
   const end = Math.max(start, start + count - 1);
   return lineNumber >= start && lineNumber <= end;
 }
-
 function selectUnifiedDiffHunk(patch, side, lineNumber) {
   const hunks = parseUnifiedDiffHunks(patch);
-  return hunks.find(hunk => lineInUnifiedDiffHunk(hunk, side, lineNumber)) || null;
+  return hunks.find((hunk) => lineInUnifiedDiffHunk(hunk, side, lineNumber)) || null;
 }
-
 function createAddedFileLineChangesHunk(content, lineNumber, contextLines = 20) {
-  const lines = String(content || '').split('\n');
-  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+  const lines = String(content || "").split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
   if (lines.length === 0) return null;
-
   const startIndex = Math.max(0, lineNumber - contextLines - 1);
   const endIndex = Math.min(lines.length, lineNumber + contextLines);
   const newStart = startIndex + 1;
   const newLines = endIndex - startIndex;
   const patchLines = [
     `@@ -0,0 +${newStart},${newLines} @@`,
-    ...lines.slice(startIndex, endIndex).map(line => `+${line}`),
+    ...lines.slice(startIndex, endIndex).map((line) => `+${line}`)
   ];
-
   return {
     header: patchLines[0],
     oldStart: 0,
     oldLines: 0,
     newStart,
     newLines,
-    heading: '',
-    patch: patchLines.join('\n'),
+    heading: "",
+    patch: patchLines.join("\n")
   };
 }
-
 function strongestStatus(current, next) {
   if (!current) return next;
   return gitStatusRank(next.kind) > gitStatusRank(current.kind) ? next : current;
 }
-
 function buildDescendantGitStatusByDirectory(statusByPath) {
-  const statusByDirectory = new Map();
+  const statusByDirectory = /* @__PURE__ */ new Map();
   statusByPath.forEach((status, statusPath) => {
     let directory = parentDirectory(statusPath);
     while (directory) {
@@ -1110,8 +1052,36 @@ function buildDescendantGitStatusByDirectory(statusByPath) {
   });
   return statusByDirectory;
 }
-
 class WorkspaceFileService {
+  blameTimeoutMs;
+  bundledRipgrepModule;
+  bundledRipgrepModulePath;
+  commandRunner;
+  diffMaxBuffer;
+  diffTimeoutMs;
+  disposed;
+  flushWorkspaceWrites;
+  gitHistoryMaxBuffer;
+  gitHistoryTimeoutMs;
+  gitPath;
+  gitStatusCache;
+  gitStatusCacheTtlMs;
+  gitStatusInlineTimeoutMs;
+  gitStatusTimeoutMs;
+  maxFileSize;
+  maxPreviewFileSize;
+  maxWriteSize;
+  mutationQueues;
+  ownsCommandRunner;
+  rgFallbackPath;
+  rgPath;
+  searchLimit;
+  searchTimeoutMs;
+  watchDepth;
+  watchOptions;
+  watcherLifecycleGeneration;
+  watcherSubscriptionGeneration;
+  watchers;
   constructor(options = {}) {
     this.maxFileSize = options.maxFileSize || DEFAULT_MAX_FILE_SIZE;
     this.maxWriteSize = options.maxWriteSize || DEFAULT_MAX_WRITE_SIZE;
@@ -1124,39 +1094,38 @@ class WorkspaceFileService {
     this.gitHistoryTimeoutMs = options.gitHistoryTimeoutMs ?? DEFAULT_GIT_HISTORY_TIMEOUT_MS;
     this.gitHistoryMaxBuffer = options.gitHistoryMaxBuffer ?? DEFAULT_GIT_HISTORY_MAX_BUFFER;
     const bundledRipgrepPath = resolveBundledRipgrepPath();
-    this.rgPath = options.rgPath || process.env.FARMING_RG_BIN || bundledRipgrepPath || 'rg';
-    this.rgFallbackPath = options.rgFallbackPath ?? (this.rgPath === 'rg' ? bundledRipgrepPath : 'rg');
+    this.rgPath = options.rgPath || process.env.FARMING_RG_BIN || bundledRipgrepPath || "rg";
+    this.rgFallbackPath = options.rgFallbackPath ?? (this.rgPath === "rg" ? bundledRipgrepPath : "rg");
     this.bundledRipgrepModulePath = options.bundledRipgrepModulePath ?? resolveBundledRipgrepModulePath();
     this.bundledRipgrepModule = null;
-    this.gitPath = options.gitPath || 'git';
+    this.gitPath = options.gitPath || "git";
     this.gitStatusCacheTtlMs = options.gitStatusCacheTtlMs ?? DEFAULT_GIT_STATUS_CACHE_TTL_MS;
     this.gitStatusInlineTimeoutMs = options.gitStatusInlineTimeoutMs ?? DEFAULT_GIT_STATUS_INLINE_TIMEOUT_MS;
     this.gitStatusTimeoutMs = options.gitStatusTimeoutMs ?? DEFAULT_GIT_STATUS_TIMEOUT_MS;
-    this.gitStatusCache = new Map();
-    this.mutationQueues = new Map();
+    this.gitStatusCache = /* @__PURE__ */ new Map();
+    this.mutationQueues = /* @__PURE__ */ new Map();
     this.flushWorkspaceWrites = options.flushWorkspaceWrites !== false;
-    this.watchers = new Map();
+    this.watchers = /* @__PURE__ */ new Map();
     this.watcherSubscriptionGeneration = 0;
     this.watcherLifecycleGeneration = 0;
     this.disposed = false;
     this.watchOptions = options.watchOptions || {};
-    this.watchDepth = Number.isFinite(options.watchDepth) ? Math.max(0, options.watchDepth) : DEFAULT_WATCH_DEPTH;
+    this.watchDepth = Number.isFinite(options.watchDepth) ? Math.max(0, options.watchDepth ?? 0) : DEFAULT_WATCH_DEPTH;
     this.commandRunner = options.commandRunner || new CommandRunner(options.commandRunnerOptions);
     this.ownsCommandRunner = !options.commandRunner;
   }
-
   execFile(command, args, options = {}) {
     return this.commandRunner.run(command, args, {
       maxBuffer: 2 * 1024 * 1024,
-      ...options,
+      ...options
     });
   }
-
   async runWorkspaceMutation(workspaceRoot, operation) {
     const root = await this.resolveRoot(workspaceRoot);
     const previous = this.mutationQueues.get(root) || Promise.resolve();
-    let release;
-    const current = new Promise(resolve => {
+    let release = () => {
+    };
+    const current = new Promise((resolve) => {
       release = resolve;
     });
     const tail = previous.then(() => current);
@@ -1171,18 +1140,17 @@ class WorkspaceFileService {
       }
     }
   }
-
   async waitForWorkspaceMutations(workspaceRoot) {
     const root = await this.resolveRoot(workspaceRoot);
     const pending = this.mutationQueues.get(root);
     if (pending) await pending;
     return root;
   }
-
   async execRipgrep(args, options = {}) {
     try {
       return await this.execFile(this.rgPath, args, options);
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (!isCommandUnavailable(error) || !this.rgFallbackPath || this.rgFallbackPath === this.rgPath) {
         if (isCommandUnavailable(error)) {
           return this.runBundledRipgrep(args, options);
@@ -1192,7 +1160,8 @@ class WorkspaceFileService {
       this.rgPath = this.rgFallbackPath;
       try {
         return await this.execFile(this.rgPath, args, options);
-      } catch (fallbackError) {
+      } catch (caughtFallback) {
+        const fallbackError = processError(caughtFallback);
         if (isCommandUnavailable(fallbackError)) {
           return this.runBundledRipgrep(args, options);
         }
@@ -1200,11 +1169,10 @@ class WorkspaceFileService {
       }
     }
   }
-
   async loadBundledRipgrep() {
     if (!this.bundledRipgrepModulePath) {
-      const error = new Error('bundled ripgrep is unavailable');
-      error.code = 'ENOENT';
+      const error = new Error("bundled ripgrep is unavailable");
+      error.code = "ENOENT";
       throw error;
     }
     if (!this.bundledRipgrepModule) {
@@ -1212,29 +1180,26 @@ class WorkspaceFileService {
     }
     return this.bundledRipgrepModule;
   }
-
   async runBundledRipgrep(args, options = {}) {
     const { ripgrep } = await this.loadBundledRipgrep();
     const cwd = options.cwd || process.cwd();
     const run = ripgrep(args, {
       buffer: true,
       env: options.env || process.env,
-      preopens: { '.': cwd },
+      preopens: { ".": cwd }
     });
-    const result = await (options.timeout
-      ? Promise.race([
-        run,
-        new Promise((_, reject) => {
-          setTimeout(() => {
-            const error = new Error('bundled ripgrep timed out');
-            error.code = 'ETIMEDOUT';
-            reject(error);
-          }, options.timeout);
-        }),
-      ])
-      : run);
-    const stdout = result.stdout || '';
-    const stderr = result.stderr || '';
+    const result = await (options.timeout ? Promise.race([
+      run,
+      new Promise((_, reject) => {
+        setTimeout(() => {
+          const error = new Error("bundled ripgrep timed out");
+          error.code = "ETIMEDOUT";
+          reject(error);
+        }, options.timeout);
+      })
+    ]) : run);
+    const stdout = result.stdout || "";
+    const stderr = result.stderr || "";
     if (result.code && result.code !== 0) {
       const error = new Error(stderr || `ripgrep exited with code ${result.code}`);
       error.code = result.code;
@@ -1244,44 +1209,41 @@ class WorkspaceFileService {
     }
     return { stdout, stderr };
   }
-
   async listSearchFiles(root, searchPath, timeout) {
     try {
       return await this.execFile(this.gitPath, [
-        '-C',
+        "-C",
         root,
-        'ls-files',
-        '-co',
-        '--exclude-standard',
-        '--',
-        searchPath,
+        "ls-files",
+        "-co",
+        "--exclude-standard",
+        "--",
+        searchPath
       ], { cwd: root, timeout, maxBuffer: SEARCH_FILE_LIST_MAX_BUFFER });
     } catch {
       return this.execRipgrep([
-        '--files',
-        '--hidden',
+        "--files",
+        "--hidden",
         ...searchExcludeGlobArgs(),
-        searchPath,
+        searchPath
       ], { cwd: root, timeout, maxBuffer: SEARCH_FILE_LIST_MAX_BUFFER });
     }
   }
-
   async collectGitIgnoredPathMatchCandidates(root, searchPath, query, limit, timeout) {
     const candidateLimit = Math.max(PATH_SEARCH_MIN_CANDIDATES, limit * PATH_SEARCH_CANDIDATE_MULTIPLIER);
     const { stdout } = await this.execFile(this.gitPath, [
-      '-C',
+      "-C",
       root,
-      'ls-files',
-      '--others',
-      '--ignored',
-      '--exclude-standard',
-      ...gitSearchExcludePathspecArgs(true, searchPath),
+      "ls-files",
+      "--others",
+      "--ignored",
+      "--exclude-standard",
+      ...gitSearchExcludePathspecArgs(true, searchPath)
     ], { cwd: root, timeout, maxBuffer: SEARCH_FILE_LIST_MAX_BUFFER });
     const scoredMatches = [];
-    const seenMatchPaths = new Set();
+    const seenMatchPaths = /* @__PURE__ */ new Set();
     let truncated = false;
-
-    for (const line of stdout.split('\n')) {
+    for (const line of String(stdout).split("\n")) {
       const filePath = normalizeSearchResultPath(line);
       if (!filePath || isSearchIgnoredRelativePath(filePath, true)) continue;
       for (const match of pathSearchMatchesForFile(filePath, query, true)) {
@@ -1295,44 +1257,38 @@ class WorkspaceFileService {
       }
       if (truncated) break;
     }
-
     scoredMatches.sort(comparePathSearchMatches);
     return {
-      matches: scoredMatches.slice(0, limit).map(match => ({
-        kind: 'path',
+      matches: scoredMatches.slice(0, limit).map((match) => ({
+        kind: "path",
         entryType: match.entryType,
         path: match.path,
         lineNumber: 1,
-        lines: '',
-        ranges: [],
+        lines: "",
+        ranges: []
       })),
-      truncated,
+      truncated
     };
   }
-
   streamPathMatches(command, root, searchPath, query, limit, timeout, stopAtLimit = false) {
     const args = [
-      '--files',
-      '--hidden',
+      "--files",
+      "--hidden",
       ...searchExcludeGlobArgs(),
-      searchPath,
+      searchPath
     ];
-    const candidateLimit = stopAtLimit
-      ? limit
-      : Math.max(PATH_SEARCH_MIN_CANDIDATES, limit * PATH_SEARCH_CANDIDATE_MULTIPLIER);
-
+    const candidateLimit = stopAtLimit ? limit : Math.max(PATH_SEARCH_MIN_CANDIDATES, limit * PATH_SEARCH_CANDIDATE_MULTIPLIER);
     return new Promise((resolve, reject) => {
       const child = spawn(command, args, {
         cwd: root,
-        stdio: ['ignore', 'pipe', 'pipe'],
+        stdio: ["ignore", "pipe", "pipe"]
       });
-      let pending = '';
-      let stderr = '';
+      let pending = "";
+      let stderr = "";
       let settled = false;
       let truncated = false;
       const scoredMatches = [];
-      const seenMatchPaths = new Set();
-
+      const seenMatchPaths = /* @__PURE__ */ new Set();
       const settle = (error) => {
         if (settled) return;
         settled = true;
@@ -1343,24 +1299,22 @@ class WorkspaceFileService {
         }
         scoredMatches.sort(comparePathSearchMatches);
         resolve({
-          matches: scoredMatches.slice(0, limit).map(match => ({
-            kind: 'path',
+          matches: scoredMatches.slice(0, limit).map((match) => ({
+            kind: "path",
             entryType: match.entryType,
             path: match.path,
             lineNumber: 1,
-            lines: '',
-            ranges: [],
+            lines: "",
+            ranges: []
           })),
-          truncated,
+          truncated
         });
       };
-
       const stopEarly = () => {
         truncated = true;
         child.kill();
         settle();
       };
-
       const processLine = (line) => {
         const filePath = normalizeSearchResultPath(line);
         if (!filePath || isSearchIgnoredRelativePath(filePath)) return;
@@ -1374,38 +1328,33 @@ class WorkspaceFileService {
           }
         }
       };
-
       const timer = setTimeout(() => {
         truncated = true;
         child.kill();
         settle();
       }, timeout);
-
-      child.stdout.on('data', chunk => {
+      child.stdout.on("data", (chunk) => {
         if (settled) return;
-        pending += String(chunk || '');
-        const lines = pending.split('\n');
-        pending = lines.pop() || '';
+        pending += String(chunk || "");
+        const lines = pending.split("\n");
+        pending = lines.pop() || "";
         for (const line of lines) {
           processLine(line);
           if (settled) return;
         }
       });
-
-      child.stderr.on('data', chunk => {
-        stderr += String(chunk || '');
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk || "");
       });
-
-      child.on('error', error => {
+      child.on("error", (error) => {
         settle(error);
       });
-
-      child.on('close', (code, signal) => {
+      child.on("close", (code, signal) => {
         if (settled) return;
         if (pending) processLine(pending);
         if (settled) return;
-        if (code && code !== 0 && signal !== 'SIGTERM') {
-          const error = new Error(stderr || 'path search failed');
+        if (code && code !== 0 && signal !== "SIGTERM") {
+          const error = new Error(stderr || "path search failed");
           error.code = code;
           error.signal = signal;
           error.stderr = stderr;
@@ -1416,11 +1365,11 @@ class WorkspaceFileService {
       });
     });
   }
-
   async collectPathMatchCandidates(root, searchPath, query, limit, timeout, stopAtLimit = false) {
     try {
       return await this.streamPathMatches(this.rgPath, root, searchPath, query, limit, timeout, stopAtLimit);
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (!isCommandUnavailable(error) || !this.rgFallbackPath || this.rgFallbackPath === this.rgPath) {
         if (isCommandUnavailable(error)) {
           return this.collectBundledPathMatchCandidates(root, searchPath, query, limit, timeout, stopAtLimit);
@@ -1430,7 +1379,8 @@ class WorkspaceFileService {
       this.rgPath = this.rgFallbackPath;
       try {
         return await this.streamPathMatches(this.rgPath, root, searchPath, query, limit, timeout, stopAtLimit);
-      } catch (fallbackError) {
+      } catch (caughtFallback) {
+        const fallbackError = processError(caughtFallback);
         if (isCommandUnavailable(fallbackError)) {
           return this.collectBundledPathMatchCandidates(root, searchPath, query, limit, timeout, stopAtLimit);
         }
@@ -1438,19 +1388,17 @@ class WorkspaceFileService {
       }
     }
   }
-
   async collectDirectoryNameMatchCandidates(root, searchPath, query, limit, timeout) {
     const startedAt = Date.now();
     const allowPathMatch = isLikelyPathQuery(query);
     const candidateLimit = Math.max(PATH_SEARCH_MIN_CANDIDATES, limit * PATH_SEARCH_CANDIDATE_MULTIPLIER);
-    const startRelativePath = searchPath === '.' ? '' : normalizeSearchResultPath(searchPath);
-    const startDirectory = path.resolve(root, startRelativePath || '.');
+    const startRelativePath = searchPath === "." ? "" : normalizeSearchResultPath(searchPath);
+    const startDirectory = path.resolve(root, startRelativePath || ".");
     const queue = [{ target: startDirectory, relativePath: startRelativePath }];
     const scoredMatches = [];
-    const seenMatchPaths = new Set();
+    const seenMatchPaths = /* @__PURE__ */ new Set();
     let visited = 0;
     let truncated = false;
-
     while (queue.length > 0) {
       if (Date.now() - startedAt > timeout) {
         truncated = true;
@@ -1460,18 +1408,15 @@ class WorkspaceFileService {
         truncated = true;
         break;
       }
-
       const current = queue.shift();
       if (!current || shouldPruneDirectoryNameSearch(current.relativePath)) continue;
       visited += 1;
-
       let entries;
       try {
         entries = await fsp.readdir(current.target, { withFileTypes: true });
       } catch {
         continue;
       }
-
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const childRelativePath = normalizeSearchResultPath(
@@ -1492,35 +1437,31 @@ class WorkspaceFileService {
       }
       if (truncated) break;
     }
-
     scoredMatches.sort(comparePathSearchMatches);
     return {
-      matches: scoredMatches.slice(0, limit).map(match => ({
-        kind: 'path',
-        entryType: 'directory',
+      matches: scoredMatches.slice(0, limit).map((match) => ({
+        kind: "path",
+        entryType: "directory",
         path: match.path,
         lineNumber: 1,
-        lines: '',
-        ranges: [],
+        lines: "",
+        ranges: []
       })),
-      truncated,
+      truncated
     };
   }
-
   async collectBundledPathMatchCandidates(root, searchPath, query, limit, timeout, stopAtLimit = false) {
-    const candidateLimit = stopAtLimit
-      ? limit
-      : Math.max(PATH_SEARCH_MIN_CANDIDATES, limit * PATH_SEARCH_CANDIDATE_MULTIPLIER);
+    const candidateLimit = stopAtLimit ? limit : Math.max(PATH_SEARCH_MIN_CANDIDATES, limit * PATH_SEARCH_CANDIDATE_MULTIPLIER);
     const { stdout } = await this.runBundledRipgrep([
-      '--files',
-      '--hidden',
+      "--files",
+      "--hidden",
       ...searchExcludeGlobArgs(),
-      searchPath,
+      searchPath
     ], { cwd: root, timeout, maxBuffer: SEARCH_FILE_LIST_MAX_BUFFER });
     const scoredMatches = [];
-    const seenMatchPaths = new Set();
+    const seenMatchPaths = /* @__PURE__ */ new Set();
     let truncated = false;
-    for (const line of stdout.split('\n')) {
+    for (const line of String(stdout).split("\n")) {
       const filePath = normalizeSearchResultPath(line);
       if (!filePath || isSearchIgnoredRelativePath(filePath)) continue;
       for (const match of pathSearchMatchesForFile(filePath, query)) {
@@ -1536,310 +1477,284 @@ class WorkspaceFileService {
     }
     scoredMatches.sort(comparePathSearchMatches);
     return {
-      matches: scoredMatches.slice(0, limit).map(match => ({
-        kind: 'path',
+      matches: scoredMatches.slice(0, limit).map((match) => ({
+        kind: "path",
         entryType: match.entryType,
         path: match.path,
         lineNumber: 1,
-        lines: '',
-        ranges: [],
+        lines: "",
+        ranges: []
       })),
-      truncated,
+      truncated
     };
   }
-
   async directPathMatchCandidate(root, query, includeIgnored = false) {
     if (!isLikelyPathQuery(query)) return null;
-    const candidatePath = normalizeSearchResultPath(String(query || '').trim().replace(/^\.\/+/, ''));
-    if (!candidatePath || candidatePath.includes('\0') || isSearchIgnoredRelativePath(candidatePath, includeIgnored)) return null;
+    const candidatePath = normalizeSearchResultPath(String(query || "").trim().replace(/^\.\/+/, ""));
+    if (!candidatePath || candidatePath.includes("\0") || isSearchIgnoredRelativePath(candidatePath, includeIgnored)) return null;
     try {
       const { target, relativePath } = await this.resolvePath(root, candidatePath);
       if (!relativePath || isSearchIgnoredRelativePath(relativePath, includeIgnored)) return null;
       const stat = await fsp.stat(target);
       if (!stat.isFile()) return null;
       return {
-        kind: 'path',
-        entryType: 'file',
+        kind: "path",
+        entryType: "file",
         path: relativePath,
         lineNumber: 1,
-        lines: '',
-        ranges: [],
+        lines: "",
+        ranges: []
       };
     } catch {
       return null;
     }
   }
-
   async resolveRoot(workspaceRoot) {
-    if (typeof workspaceRoot !== 'string' || !workspaceRoot.trim()) {
-      throw new WorkspaceFileError('workspace root is required', 400);
+    if (typeof workspaceRoot !== "string" || !workspaceRoot.trim()) {
+      throw new WorkspaceFileError("workspace root is required", 400);
     }
-
     let stat;
     try {
       stat = await fsp.stat(workspaceRoot);
     } catch {
-      throw new WorkspaceFileError('workspace not found', 404);
+      throw new WorkspaceFileError("workspace not found", 404);
     }
-
     if (!stat.isDirectory()) {
-      throw new WorkspaceFileError('workspace must be a directory', 400);
+      throw new WorkspaceFileError("workspace must be a directory", 400);
     }
-
     return fsp.realpath(workspaceRoot);
   }
-
-  async resolvePath(workspaceRoot, userPath = '', options = {}) {
+  async resolvePath(workspaceRoot, userPath = "", options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const normalized = normalizeUserPath(userPath);
     const target = path.resolve(root, normalized);
     const requestedRelativePath = relativeFromRoot(root, target);
-
     if (!isInside(root, target)) {
-      throw new WorkspaceFileError('path must stay inside the workspace', 403);
+      throw new WorkspaceFileError("path must stay inside the workspace", 403);
     }
-
     if (options.allowMissing) {
       const parent = await fsp.realpath(path.dirname(target)).catch(() => null);
       if (!parent || !isInside(root, parent)) {
-        throw new WorkspaceFileError('parent path must stay inside the workspace', 403);
+        throw new WorkspaceFileError("parent path must stay inside the workspace", 403);
       }
       return {
         root,
         target,
         relativePath: requestedRelativePath,
         actualRelativePath: requestedRelativePath,
+        external: false,
+        readOnly: false,
+        symbolicLink: false
       };
     }
-
     let realTarget;
     try {
       realTarget = await fsp.realpath(target);
     } catch {
-      throw new WorkspaceFileError('path not found', 404);
+      throw new WorkspaceFileError("path not found", 404);
     }
-
     const external = !isInside(root, realTarget);
     if (external && !isInsideAnyRoot(options.allowedExternalRoots, realTarget)) {
-      throw new WorkspaceFileError('symlink target is outside allowed workspaces', 403);
+      throw new WorkspaceFileError("symlink target is outside allowed workspaces", 403);
     }
-
     const requestedStat = await fsp.lstat(target).catch(() => null);
-
     return {
       root,
       target: realTarget,
       relativePath: requestedRelativePath,
-      actualRelativePath: external ? '' : relativeFromRoot(root, realTarget),
+      actualRelativePath: external ? "" : relativeFromRoot(root, realTarget),
       external,
       readOnly: external,
-      symbolicLink: Boolean(requestedStat && requestedStat.isSymbolicLink()),
+      symbolicLink: Boolean(requestedStat && requestedStat.isSymbolicLink())
     };
   }
-
   async resolveEntryPath(workspaceRoot, userPath) {
     const root = await this.resolveRoot(workspaceRoot);
     const normalized = normalizeUserPath(userPath);
     const target = path.resolve(root, normalized);
     const relativePath = relativeFromRoot(root, target);
     if (!relativePath) {
-      throw new WorkspaceFileError('workspace root cannot be changed', 400);
+      throw new WorkspaceFileError("workspace root cannot be changed", 400);
     }
     if (!isInside(root, target)) {
-      throw new WorkspaceFileError('path must stay inside the workspace', 403);
+      throw new WorkspaceFileError("path must stay inside the workspace", 403);
     }
     try {
       await fsp.lstat(target);
     } catch {
-      throw new WorkspaceFileError('path not found', 404);
+      throw new WorkspaceFileError("path not found", 404);
     }
     const realParent = await fsp.realpath(path.dirname(target)).catch(() => null);
     if (!realParent || !isInside(root, realParent)) {
-      throw new WorkspaceFileError('symlink target is read-only', 403);
+      throw new WorkspaceFileError("symlink target is read-only", 403);
     }
     return { root, target, relativePath };
   }
-
-  async listTree(workspaceRoot, userPath = '', options = {}) {
+  async listTree(workspaceRoot, userPath = "", options = {}) {
     const root = await this.waitForWorkspaceMutations(workspaceRoot);
     const { target, relativePath, external: parentExternal = false } = await this.resolvePath(root, userPath, options);
     const stat = await fsp.stat(target);
     if (!stat.isDirectory()) {
-      throw new WorkspaceFileError('path must be a directory', 400);
+      throw new WorkspaceFileError("path must be a directory", 400);
     }
-
     const entries = await fsp.readdir(target, { withFileTypes: true });
-    const visibleEntries = entries.filter(entry => !TREE_HIDDEN_NAMES.has(entry.name));
+    const visibleEntries = entries.filter((entry) => !TREE_HIDDEN_NAMES.has(entry.name));
     const [{ value: gitStatusByPath, pending: gitStatusPending }, ignoredPaths] = await Promise.all([
       this.getGitStatusForTree(root),
-      this.loadGitIgnoredPaths(root, visibleEntries.map(entry => joinRelativePath(relativePath, entry.name))),
+      this.loadGitIgnoredPaths(root, visibleEntries.map((entry) => joinRelativePath(relativePath, entry.name)))
     ]);
     const descendantGitStatusByPath = buildDescendantGitStatusByDirectory(gitStatusByPath);
-    const items = await Promise.all(visibleEntries
-      .map(async (entry) => {
-        const absolute = path.join(target, entry.name);
-        let entryStat;
+    const items = await Promise.all(visibleEntries.map(async (entry) => {
+      const absolute = path.join(target, entry.name);
+      let entryStat;
+      try {
+        entryStat = await fsp.lstat(absolute);
+      } catch (caught) {
+        const error = processError(caught);
+        if (error && error.code === "ENOENT") return null;
+        throw error;
+      }
+      const itemPath = joinRelativePath(relativePath, entry.name);
+      let type = entryStat.isDirectory() ? "directory" : entryStat.isFile() ? "file" : "other";
+      let symbolicLink = false;
+      let external = parentExternal;
+      let readOnly = parentExternal;
+      let linkTarget = "";
+      let linkError = "";
+      let targetStat = entryStat;
+      if (entryStat.isSymbolicLink()) {
+        symbolicLink = true;
         try {
-          entryStat = await fsp.lstat(absolute);
-        } catch (error) {
-          if (error && error.code === 'ENOENT') return null;
-          throw error;
-        }
-        const itemPath = joinRelativePath(relativePath, entry.name);
-        let type = entryStat.isDirectory() ? 'directory' : entryStat.isFile() ? 'file' : 'other';
-        let symbolicLink = false;
-        let external = parentExternal;
-        let readOnly = parentExternal;
-        let linkTarget = '';
-        let linkError = '';
-        let targetStat = entryStat;
-        if (entryStat.isSymbolicLink()) {
-          symbolicLink = true;
-          try {
-            linkTarget = await fsp.realpath(absolute);
-            external = !isInside(root, linkTarget);
-            if (external && !isInsideAnyRoot(options.allowedExternalRoots, linkTarget)) {
-              type = 'symlink';
-              linkError = 'outside-allowed-roots';
-            } else {
-              targetStat = await fsp.stat(linkTarget);
-              type = targetStat.isDirectory() ? 'directory' : targetStat.isFile() ? 'file' : 'other';
-              readOnly = external;
-            }
-          } catch (error) {
-            type = 'symlink';
-            linkError = error && error.code === 'ENOENT' ? 'broken' : 'unavailable';
+          linkTarget = await fsp.realpath(absolute);
+          external = !isInside(root, linkTarget);
+          if (external && !isInsideAnyRoot(options.allowedExternalRoots, linkTarget)) {
+            type = "symlink";
+            linkError = "outside-allowed-roots";
+          } else {
+            targetStat = await fsp.stat(linkTarget);
+            type = targetStat.isDirectory() ? "directory" : targetStat.isFile() ? "file" : "other";
+            readOnly = external;
           }
+        } catch (caught) {
+          const error = processError(caught);
+          type = "symlink";
+          linkError = error && error.code === "ENOENT" ? "broken" : "unavailable";
         }
-        const directGitStatus = gitStatusByPath.get(itemPath);
-        let descendantGitStatus = null;
-        if (type === 'directory' && !external) {
-          descendantGitStatus = descendantGitStatusByPath.get(itemPath) || null;
-        }
-
-        return {
-          name: entry.name,
-          path: itemPath,
-          type,
-          size: targetStat.size,
-          mtimeMs: targetStat.mtimeMs,
-          version: workspaceEntryVersion(entryStat),
-          ...(symbolicLink ? { symbolicLink: true } : {}),
-          ...(external ? { external: true } : {}),
-          ...(readOnly ? { readOnly: true } : {}),
-          ...(linkTarget ? { linkTarget } : {}),
-          ...(linkError ? { linkError } : {}),
-          ...(ignoredPaths.has(itemPath) ? { ignored: true } : {}),
-          ...(directGitStatus ? {
-            gitStatus: directGitStatus.kind,
-            gitStatusLabel: directGitStatus.label,
-          } : {}),
-          ...(descendantGitStatus ? {
-            descendantGitStatus: descendantGitStatus.kind,
-          } : {}),
-        };
-      }));
+      }
+      const directGitStatus = gitStatusByPath.get(itemPath);
+      let descendantGitStatus = null;
+      if (type === "directory" && !external) {
+        descendantGitStatus = descendantGitStatusByPath.get(itemPath) || null;
+      }
+      return {
+        name: entry.name,
+        path: itemPath,
+        type,
+        size: targetStat.size,
+        mtimeMs: targetStat.mtimeMs,
+        version: workspaceEntryVersion(entryStat),
+        ...symbolicLink ? { symbolicLink: true } : {},
+        ...external ? { external: true } : {},
+        ...readOnly ? { readOnly: true } : {},
+        ...linkTarget ? { linkTarget } : {},
+        ...linkError ? { linkError } : {},
+        ...ignoredPaths.has(itemPath) ? { ignored: true } : {},
+        ...directGitStatus ? {
+          gitStatus: directGitStatus.kind,
+          gitStatusLabel: directGitStatus.label
+        } : {},
+        ...descendantGitStatus ? {
+          descendantGitStatus: descendantGitStatus.kind
+        } : {}
+      };
+    }));
     const visibleItems = items.filter(Boolean);
-
     visibleItems.sort((a, b) => {
-      if (a.type === 'directory' && b.type !== 'directory') return -1;
-      if (a.type !== 'directory' && b.type === 'directory') return 1;
+      if (a.type === "directory" && b.type !== "directory") return -1;
+      if (a.type !== "directory" && b.type === "directory") return 1;
       return a.name.localeCompare(b.name);
     });
-
     return {
       path: relativePath,
       items: visibleItems,
-      gitStatusPending,
+      gitStatusPending
     };
   }
-
   invalidateGitStatus(root) {
     if (root) this.gitStatusCache.delete(root);
   }
-
   async loadGitStatusByPath(root, options = {}) {
-    const untrackedFiles = options.untrackedFiles || 'normal';
+    const untrackedFiles = options.untrackedFiles || "normal";
     try {
       const { stdout } = await this.execFile(this.gitPath, [
-        'status',
-        '--porcelain=v1',
-        '-z',
+        "status",
+        "--porcelain=v1",
+        "-z",
         `--untracked-files=${untrackedFiles}`,
-        '--ignored=no',
-        ...gitStatusExcludePathspecArgs(),
-      ], { cwd: root, timeout: options.timeoutMs ?? this.gitStatusTimeoutMs });
+        "--ignored=no",
+        ...gitStatusExcludePathspecArgs()
+      ], { cwd: root, timeout: Number(options.timeoutMs) || this.gitStatusTimeoutMs });
       return parseGitStatus(stdout);
-    } catch (error) {
-      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' && options.allowPartial === true) {
-        const partialOutput = String(error.stdout || '');
-        const lastCompleteRecord = partialOutput.lastIndexOf('\0');
-        const statusByPath = parseGitStatus(lastCompleteRecord >= 0
-          ? partialOutput.slice(0, lastCompleteRecord + 1)
-          : '');
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" && options.allowPartial === true) {
+        const partialOutput = String(error.stdout || "");
+        const lastCompleteRecord = partialOutput.lastIndexOf("\0");
+        const statusByPath = parseGitStatus(lastCompleteRecord >= 0 ? partialOutput.slice(0, lastCompleteRecord + 1) : "");
         statusByPath.truncated = true;
         return statusByPath;
       }
-      if (error.code === 'ENOENT') {
+      if (error.code === "ENOENT") {
         if (options.throwOnError === true) {
-          throw new WorkspaceFileError('git is not installed', 501);
+          throw new WorkspaceFileError("git is not installed", 501);
         }
-        return new Map();
+        return /* @__PURE__ */ new Map();
       }
-      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
-        throw new WorkspaceFileError('git status timed out', 504);
+      if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+        throw new WorkspaceFileError("git status timed out", 504);
       }
-      if (error.stderr && /not a git repository/i.test(error.stderr)) return new Map();
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) return /* @__PURE__ */ new Map();
       if (options.throwOnError === true) {
-        throw new WorkspaceFileError(error.stderr || 'git status failed', 500);
+        throw new WorkspaceFileError(String(error.stderr || "git status failed"), 500);
       }
-      return new Map();
+      return /* @__PURE__ */ new Map();
     }
   }
-
   async loadGitIgnoredPaths(root, relativePaths) {
-    const paths = Array.from(new Set(relativePaths
-      .map(normalizeGitStatusPath)
-      .filter(Boolean)));
-    if (paths.length === 0) return new Set();
-
+    const paths = Array.from(new Set(relativePaths.map(normalizeGitStatusPath).filter(Boolean)));
+    if (paths.length === 0) return /* @__PURE__ */ new Set();
     try {
       const { stdout } = await this.execFile(this.gitPath, [
-        'check-ignore',
-        '--',
-        ...paths,
+        "check-ignore",
+        "--",
+        ...paths
       ], { cwd: root });
-      return new Set(stdout
-        .split(/\r?\n/)
-        .map(normalizeGitStatusPath)
-        .filter(Boolean));
+      return new Set(String(stdout).split(/\r?\n/).map(normalizeGitStatusPath).filter(Boolean));
     } catch {
-      return new Set();
+      return /* @__PURE__ */ new Set();
     }
   }
-
   async loadGitStatusForPath(root, relativePath) {
     const normalizedPath = normalizeGitStatusPath(relativePath);
     if (!normalizedPath) return null;
-
     try {
       const { stdout } = await this.execFile(this.gitPath, [
-        'status',
-        '--porcelain=v1',
-        '-z',
-        '--untracked-files=normal',
-        '--ignored=no',
-        '--',
-        normalizedPath,
+        "status",
+        "--porcelain=v1",
+        "-z",
+        "--untracked-files=normal",
+        "--ignored=no",
+        "--",
+        normalizedPath
       ], { cwd: root });
       return parseGitStatus(stdout).get(normalizedPath) || null;
-    } catch (error) {
-      if (error.code === 'ENOENT') return null;
-      if (error.stderr && /not a git repository/i.test(error.stderr)) return null;
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ENOENT") return null;
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) return null;
       return null;
     }
   }
-
   async getGitStatusByPath(root) {
     if (this.gitStatusCacheTtlMs > 0) {
       const now = Date.now();
@@ -1850,11 +1765,10 @@ class WorkspaceFileService {
       if (cached?.promise) {
         return cached.promise;
       }
-
       const promise = this.loadGitStatusByPath(root).then((value) => {
         this.gitStatusCache.set(root, {
           value,
-          expiresAt: Date.now() + this.gitStatusCacheTtlMs,
+          expiresAt: Date.now() + this.gitStatusCacheTtlMs
         });
         return value;
       }, (error) => {
@@ -1863,113 +1777,101 @@ class WorkspaceFileService {
       });
       this.gitStatusCache.set(root, {
         promise,
-        expiresAt: now + this.gitStatusCacheTtlMs,
+        expiresAt: now + this.gitStatusCacheTtlMs
       });
       return promise;
     }
-
     return this.loadGitStatusByPath(root);
   }
-
   async getGitStatusForTree(root) {
     const cached = this.gitStatusCache.get(root);
     if (cached?.value) {
       return { value: cached.value, pending: false };
     }
-
     const promise = this.getGitStatusByPath(root);
     if (this.gitStatusInlineTimeoutMs <= 0) {
       return { value: await promise, pending: false };
     }
-
     const result = await Promise.race([
       promise,
-      new Promise(resolve => setTimeout(() => resolve(TIMEOUT), this.gitStatusInlineTimeoutMs)),
+      new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), this.gitStatusInlineTimeoutMs))
     ]);
-
     if (result === TIMEOUT) {
-      return { value: new Map(), pending: true };
+      return { value: /* @__PURE__ */ new Map(), pending: true };
     }
-
     return { value: result, pending: false };
   }
-
   async getGitStatusForPath(root, relativePath) {
     const normalizedPath = normalizeGitStatusPath(relativePath);
     if (!normalizedPath) return null;
-
     const cached = this.gitStatusCache.get(root);
     if (cached?.value) {
       return cached.value.get(normalizedPath) || null;
     }
-
     return this.loadGitStatusForPath(root, normalizedPath);
   }
-
   async gitBranch(workspaceRoot) {
     const root = await this.resolveRoot(workspaceRoot);
     try {
-      const { stdout } = await this.execFile(this.gitPath, ['-C', root, 'branch', '--show-current'], {
+      const { stdout } = await this.execFile(this.gitPath, ["-C", root, "branch", "--show-current"], {
         timeout: 1500,
-        maxBuffer: 64 * 1024,
+        maxBuffer: 64 * 1024
       });
-      return String(stdout || '').trim();
+      return String(stdout || "").trim();
     } catch {
-      return '';
+      return "";
     }
   }
-
   async gitHistory(workspaceRoot, options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const limit = normalizeGitHistoryLimit(options.limit);
     const skip = normalizeGitHistorySkip(options.skip);
-    const scope = options.scope === 'all' ? 'all' : 'current';
-    let branch = '';
+    const scope = options.scope === "all" ? "all" : "current";
+    let branch = "";
     try {
       branch = await this.gitBranch(root);
-      await this.execFile(this.gitPath, ['-C', root, 'rev-parse', '--is-inside-work-tree'], {
+      await this.execFile(this.gitPath, ["-C", root, "rev-parse", "--is-inside-work-tree"], {
         timeout: 1500,
-        maxBuffer: 64 * 1024,
+        maxBuffer: 64 * 1024
       });
-    } catch (error) {
-      if (error.code === 'ENOENT') throw new WorkspaceFileError('git is not installed', 501);
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ENOENT") throw new WorkspaceFileError("git is not installed", 501);
       if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
-        return { isGitRepo: false, branch: '', head: '', scope, items: [], hasMore: false, nextSkip: null };
+        return { isGitRepo: false, branch: "", head: "", scope, items: [], hasMore: false, nextSkip: null };
       }
-      throw new WorkspaceFileError(error.stderr || 'git history failed', 500);
+      throw new WorkspaceFileError(String(error.stderr || "git history failed"), 500);
     }
-
-    let head = '';
+    let head = "";
     try {
-      const result = await this.execFile(this.gitPath, ['-C', root, 'rev-parse', '--verify', 'HEAD'], {
+      const result = await this.execFile(this.gitPath, ["-C", root, "rev-parse", "--verify", "HEAD"], {
         timeout: 1500,
-        maxBuffer: 64 * 1024,
+        maxBuffer: 64 * 1024
       });
-      head = String(result.stdout || '').trim();
-    } catch (error) {
+      head = String(result.stdout || "").trim();
+    } catch (caught) {
+      const error = processError(caught);
       if (error.stderr && /(needed a single revision|unknown revision|bad revision|ambiguous argument)/i.test(String(error.stderr))) {
-        return { isGitRepo: true, branch, head: '', scope, items: [], hasMore: false, nextSkip: null };
+        return { isGitRepo: true, branch, head: "", scope, items: [], hasMore: false, nextSkip: null };
       }
-      throw new WorkspaceFileError(error.stderr || 'git history failed', 500);
+      throw new WorkspaceFileError(String(error.stderr || "git history failed"), 500);
     }
-
     try {
-      const revisionArgs = scope === 'all'
-        ? ['HEAD', '--branches', '--tags', '--remotes']
-        : ['--first-parent', 'HEAD'];
+      const revisionArgs = scope === "all" ? ["HEAD", "--branches", "--tags", "--remotes"] : ["--first-parent", "HEAD"];
       const { stdout } = await this.execFile(this.gitPath, [
-        '-C', root,
-        'log',
-        '-z',
-        '--date-order',
-        '--decorate=full',
-        '--format=%H%x00%P%x00%an%x00%ae%x00%aI%x00%s%x00%B%x00%D',
+        "-C",
+        root,
+        "log",
+        "-z",
+        "--date-order",
+        "--decorate=full",
+        "--format=%H%x00%P%x00%an%x00%ae%x00%aI%x00%s%x00%B%x00%D",
         `--max-count=${limit + 1}`,
         `--skip=${skip}`,
-        ...revisionArgs,
+        ...revisionArgs
       ], {
         timeout: this.gitHistoryTimeoutMs,
-        maxBuffer: this.gitHistoryMaxBuffer,
+        maxBuffer: this.gitHistoryMaxBuffer
       });
       const parsed = parseGitHistoryLog(stdout);
       const hasMore = parsed.length > limit;
@@ -1981,65 +1883,67 @@ class WorkspaceFileService {
         scope,
         items,
         hasMore,
-        nextSkip: hasMore ? skip + items.length : null,
+        nextSkip: hasMore ? skip + items.length : null
       };
-    } catch (error) {
-      if (error.code === 'ENOENT') throw new WorkspaceFileError('git is not installed', 501);
-      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
-        throw new WorkspaceFileError('git history timed out', 504);
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ENOENT") throw new WorkspaceFileError("git is not installed", 501);
+      if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+        throw new WorkspaceFileError("git history timed out", 504);
       }
-      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
-        throw new WorkspaceFileError('git history output is too large', 413);
+      if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+        throw new WorkspaceFileError("git history output is too large", 413);
       }
       if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
-        return { isGitRepo: false, branch: '', head: '', scope, items: [], hasMore: false, nextSkip: null };
+        return { isGitRepo: false, branch: "", head: "", scope, items: [], hasMore: false, nextSkip: null };
       }
-      throw new WorkspaceFileError(error.stderr || 'git history failed', 500);
+      throw new WorkspaceFileError(String(error.stderr || "git history failed"), 500);
     }
   }
-
   async gitHistoryChanges(workspaceRoot, commitValue, parentValue, options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const commit = normalizeGitObjectId(commitValue);
-    const requestedParent = parentValue ? normalizeGitObjectId(parentValue, 'parent') : '';
-    const limit = Math.max(1, Math.min(2000, Number(options.limit) || DEFAULT_GIT_CHANGES_LIMIT));
-
+    const requestedParent = parentValue ? normalizeGitObjectId(parentValue, "parent") : "";
+    const limit = Math.max(1, Math.min(2e3, Number(options.limit) || DEFAULT_GIT_CHANGES_LIMIT));
     try {
       const { stdout: parentOutput } = await this.execFile(this.gitPath, [
-        '-C', root, 'rev-list', '--parents', '-n', '1', commit,
+        "-C",
+        root,
+        "rev-list",
+        "--parents",
+        "-n",
+        "1",
+        commit
       ], {
         timeout: this.gitHistoryTimeoutMs,
-        maxBuffer: 64 * 1024,
+        maxBuffer: 64 * 1024
       });
-      const revision = String(parentOutput || '').trim().split(/\s+/).filter(Boolean);
+      const revision = String(parentOutput || "").trim().split(/\s+/).filter(Boolean);
       if (!revision.length || revision[0].toLowerCase() !== commit) {
-        throw new WorkspaceFileError('commit was not found', 404);
+        throw new WorkspaceFileError("commit was not found", 404);
       }
-      const parentIds = revision.slice(1).map(value => value.toLowerCase());
+      const parentIds = revision.slice(1).map((value) => value.toLowerCase());
       if (requestedParent && !parentIds.includes(requestedParent)) {
-        throw new WorkspaceFileError('parent is not a parent of commit', 400);
+        throw new WorkspaceFileError("parent is not a parent of commit", 400);
       }
-      const parent = requestedParent || parentIds[0] || '';
+      const parent = requestedParent || parentIds[0] || "";
       let comparisonBase = parent;
       if (!comparisonBase) {
-        let objectFormat = 'sha1';
+        let objectFormat = "sha1";
         try {
-          const result = await this.execFile(this.gitPath, ['-C', root, 'rev-parse', '--show-object-format'], {
+          const result = await this.execFile(this.gitPath, ["-C", root, "rev-parse", "--show-object-format"], {
             timeout: 1500,
-            maxBuffer: 64 * 1024,
+            maxBuffer: 64 * 1024
           });
-          objectFormat = String(result.stdout || '').trim();
+          objectFormat = String(result.stdout || "").trim();
         } catch {
-          // Git versions without --show-object-format use SHA-1 repositories.
         }
         comparisonBase = gitEmptyTreeObjectId(objectFormat);
       }
-      const args = parent
-        ? ['-C', root, 'diff', '--name-status', '-z', '-M', parent, commit, '--']
-        : ['-C', root, 'diff-tree', '--root', '--no-commit-id', '--name-status', '-r', '-z', '-M', commit];
+      const args = parent ? ["-C", root, "diff", "--name-status", "-z", "-M", parent, commit, "--"] : ["-C", root, "diff-tree", "--root", "--no-commit-id", "--name-status", "-r", "-z", "-M", commit];
       const { stdout } = await this.execFile(this.gitPath, args, {
         timeout: this.gitHistoryTimeoutMs,
-        maxBuffer: this.gitHistoryMaxBuffer,
+        maxBuffer: this.gitHistoryMaxBuffer
       });
       const allItems = parseGitHistoryChanges(stdout);
       return {
@@ -2048,97 +1952,91 @@ class WorkspaceFileService {
         parent: parent || null,
         parentIds,
         items: allItems.slice(0, limit),
-        truncated: allItems.length > limit,
+        truncated: allItems.length > limit
       };
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (error instanceof WorkspaceFileError) throw error;
-      if (error.code === 'ENOENT') throw new WorkspaceFileError('git is not installed', 501);
-      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
-        throw new WorkspaceFileError('git commit changes timed out', 504);
+      if (error.code === "ENOENT") throw new WorkspaceFileError("git is not installed", 501);
+      if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+        throw new WorkspaceFileError("git commit changes timed out", 504);
       }
-      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
-        throw new WorkspaceFileError('git commit changes output is too large', 413);
+      if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+        throw new WorkspaceFileError("git commit changes output is too large", 413);
       }
       if (error.stderr && /(bad object|unknown revision|ambiguous argument|not a valid object name)/i.test(String(error.stderr))) {
-        throw new WorkspaceFileError('commit was not found', 404);
+        throw new WorkspaceFileError("commit was not found", 404);
       }
       if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
-        throw new WorkspaceFileError('workspace is not a git repository', 409);
+        throw new WorkspaceFileError("workspace is not a git repository", 409);
       }
-      throw new WorkspaceFileError(error.stderr || 'git commit changes failed', 500);
+      throw new WorkspaceFileError(String(error.stderr || "git commit changes failed"), 500);
     }
   }
-
   async changes(workspaceRoot, options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
-    const limit = Math.max(1, Math.min(2000, Number(options.limit) || DEFAULT_GIT_CHANGES_LIMIT));
+    const limit = Math.max(1, Math.min(2e3, Number(options.limit) || DEFAULT_GIT_CHANGES_LIMIT));
     const gitStatusByPath = await this.loadGitStatusByPath(root, {
       allowPartial: true,
       throwOnError: true,
-      untrackedFiles: 'all',
+      untrackedFiles: "all"
     });
     this.invalidateGitStatus(root);
-    const allItems = await Promise.all(Array.from(gitStatusByPath.entries())
-      .map(async ([filePath, status]) => ({
-        path: filePath,
-        name: path.posix.basename(filePath),
-        type: await workspaceEntryTypeForGitChange(root, filePath),
-        gitStatus: status.kind,
-        gitStatusLabel: status.label,
-        ...(status.previousPath ? { previousPath: status.previousPath } : {}),
-      })))
-    allItems
-      .sort((left, right) => (
-        gitStatusReviewRank(left.gitStatus) - gitStatusReviewRank(right.gitStatus)
-        || left.path.localeCompare(right.path)
-      ));
-
+    const allItems = await Promise.all(Array.from(gitStatusByPath.entries()).map(async ([filePath, status]) => ({
+      path: filePath,
+      name: path.posix.basename(filePath),
+      type: await workspaceEntryTypeForGitChange(root, filePath),
+      gitStatus: status.kind,
+      gitStatusLabel: status.label,
+      ...status.previousPath ? { previousPath: status.previousPath } : {}
+    })));
+    allItems.sort((left, right) => gitStatusReviewRank(left.gitStatus) - gitStatusReviewRank(right.gitStatus) || left.path.localeCompare(right.path));
+    const typedGitStatusByPath = gitStatusByPath;
     return {
       items: allItems.slice(0, limit),
-      truncated: gitStatusByPath.truncated === true || allItems.length > limit,
+      truncated: typedGitStatusByPath.truncated === true || allItems.length > limit
     };
   }
-
   async readFile(workspaceRoot, userPath, options = {}) {
     const { target, relativePath, external, readOnly, symbolicLink } = await this.resolvePath(workspaceRoot, userPath, options);
     const stat = await fsp.stat(target);
     if (!stat.isFile()) {
-      throw new WorkspaceFileError('path must be a file', 400);
+      throw new WorkspaceFileError("path must be a file", 400);
     }
     const preview = previewForPath(relativePath);
     if (preview) {
       if (stat.size > this.maxPreviewFileSize) {
-        throw new WorkspaceFileError('file is too large to preview', 413, { size: stat.size });
+        throw new WorkspaceFileError("file is too large to preview", 413, { size: stat.size });
       }
-      const buffer = await fsp.readFile(target);
+      const buffer2 = await fsp.readFile(target);
       return {
         path: relativePath,
-        content: '',
+        content: "",
         size: stat.size,
         mtimeMs: stat.mtimeMs,
-        sha1: sha1(buffer),
+        sha1: sha1(buffer2),
         binary: true,
         preview,
-        ...(symbolicLink ? { symbolicLink: true } : {}),
-        ...(external ? { external: true } : {}),
-        ...(readOnly ? { readOnly: true } : {}),
+        ...symbolicLink ? { symbolicLink: true } : {},
+        ...external ? { external: true } : {},
+        ...readOnly ? { readOnly: true } : {}
       };
     }
     if (await isProbablyBinaryFile(target)) {
       return {
         path: relativePath,
-        content: '',
+        content: "",
         size: stat.size,
         mtimeMs: stat.mtimeMs,
         sha1: metadataFileVersion(relativePath, stat),
         binary: true,
         preview: {
-          kind: 'binary',
-          mediaType: 'application/octet-stream',
+          kind: "binary",
+          mediaType: "application/octet-stream"
         },
-        ...(symbolicLink ? { symbolicLink: true } : {}),
-        ...(external ? { external: true } : {}),
-        ...(readOnly ? { readOnly: true } : {}),
+        ...symbolicLink ? { symbolicLink: true } : {},
+        ...external ? { external: true } : {},
+        ...readOnly ? { readOnly: true } : {}
       };
     }
     if (stat.size > this.maxFileSize) {
@@ -2149,41 +2047,39 @@ class WorkspaceFileService {
         mtimeMs: stat.mtimeMs,
         sha1: metadataFileVersion(relativePath, stat),
         preview: {
-          kind: 'large-text',
-          mediaType: 'text/plain',
-          truncated: true,
+          kind: "large-text",
+          mediaType: "text/plain",
+          truncated: true
         },
-        ...(symbolicLink ? { symbolicLink: true } : {}),
-        ...(external ? { external: true } : {}),
-        ...(readOnly ? { readOnly: true } : {}),
+        ...symbolicLink ? { symbolicLink: true } : {},
+        ...external ? { external: true } : {},
+        ...readOnly ? { readOnly: true } : {}
       };
     }
-
     const buffer = await fsp.readFile(target);
     return {
       path: relativePath,
-      content: buffer.toString('utf8'),
+      content: buffer.toString("utf8"),
       size: stat.size,
       mtimeMs: stat.mtimeMs,
       sha1: sha1(buffer),
-      ...(symbolicLink ? { symbolicLink: true } : {}),
-      ...(external ? { external: true } : {}),
-      ...(readOnly ? { readOnly: true } : {}),
+      ...symbolicLink ? { symbolicLink: true } : {},
+      ...external ? { external: true } : {},
+      ...readOnly ? { readOnly: true } : {}
     };
   }
-
   async readPreviewFile(workspaceRoot, userPath, options = {}) {
     const { target, relativePath, external, readOnly, symbolicLink } = await this.resolvePath(workspaceRoot, userPath, options);
     const stat = await fsp.stat(target);
     if (!stat.isFile()) {
-      throw new WorkspaceFileError('path must be a file', 400);
+      throw new WorkspaceFileError("path must be a file", 400);
     }
     const preview = previewForPath(relativePath, { includeTextImages: true });
     if (!preview) {
-      throw new WorkspaceFileError('file preview is not available', 415);
+      throw new WorkspaceFileError("file preview is not available", 415);
     }
     if (stat.size > this.maxPreviewFileSize) {
-      throw new WorkspaceFileError('file is too large to preview', 413, { size: stat.size });
+      throw new WorkspaceFileError("file is too large to preview", 413, { size: stat.size });
     }
     const buffer = await fsp.readFile(target);
     return {
@@ -2193,20 +2089,19 @@ class WorkspaceFileService {
       mtimeMs: stat.mtimeMs,
       sha1: sha1(buffer),
       preview,
-      ...(symbolicLink ? { symbolicLink: true } : {}),
-      ...(external ? { external: true } : {}),
-      ...(readOnly ? { readOnly: true } : {}),
+      ...symbolicLink ? { symbolicLink: true } : {},
+      ...external ? { external: true } : {},
+      ...readOnly ? { readOnly: true } : {}
     };
   }
-
   async readResourceFile(workspaceRoot, userPath, options = {}) {
     const { target, relativePath } = await this.resolvePath(workspaceRoot, userPath, options);
     const stat = await fsp.stat(target);
     if (!stat.isFile()) {
-      throw new WorkspaceFileError('path must be a file', 400);
+      throw new WorkspaceFileError("path must be a file", 400);
     }
     if (stat.size > this.maxPreviewFileSize) {
-      throw new WorkspaceFileError('file is too large to preview', 413, { size: stat.size });
+      throw new WorkspaceFileError("file is too large to preview", 413, { size: stat.size });
     }
     const buffer = await fsp.readFile(target);
     return {
@@ -2214,144 +2109,135 @@ class WorkspaceFileService {
       buffer,
       size: stat.size,
       mtimeMs: stat.mtimeMs,
-      sha1: sha1(buffer),
+      sha1: sha1(buffer)
     };
   }
-
   async blameCapability(workspaceRoot, userPath, options = {}) {
     const { root, target, relativePath, actualRelativePath, external } = await this.resolvePath(workspaceRoot, userPath, options);
-    const capability = (available, reason = '') => ({
-      isGitRepo: reason !== 'not-git-repo' && reason !== 'git-unavailable',
+    const capability = (available, reason = "") => ({
+      isGitRepo: reason !== "not-git-repo" && reason !== "git-unavailable",
       path: relativePath,
       available,
-      ...(reason ? { reason } : {}),
+      ...reason ? { reason } : {}
     });
     const stat = await fsp.stat(target);
     if (!stat.isFile()) {
-      throw new WorkspaceFileError('path must be a file', 400);
+      throw new WorkspaceFileError("path must be a file", 400);
     }
     if (external) {
-      return capability(false, 'external');
+      return capability(false, "external");
     }
     if (stat.size > this.maxFileSize) {
-      return capability(false, 'too-large');
+      return capability(false, "too-large");
     }
     if (await isProbablyBinaryFile(target)) {
-      return capability(false, 'binary');
+      return capability(false, "binary");
     }
-
     const gitPath = actualRelativePath || relativePath;
     const directGitStatus = await this.getGitStatusForPath(root, gitPath);
-    if (directGitStatus && ['added', 'deleted', 'renamed', 'untracked', 'conflicted'].includes(directGitStatus.kind)) {
+    if (directGitStatus && ["added", "deleted", "renamed", "untracked", "conflicted"].includes(directGitStatus.kind)) {
       return capability(false, directGitStatus.kind);
     }
-
     try {
       await this.execFile(this.gitPath, [
-        'ls-files',
-        '--error-unmatch',
-        '--',
-        gitPath,
+        "ls-files",
+        "--error-unmatch",
+        "--",
+        gitPath
       ], { cwd: root });
       return capability(true);
-    } catch (error) {
-      if (error.code === 'ENOENT') return capability(false, 'git-unavailable');
-      if (error.stderr && /not a git repository/i.test(error.stderr)) return capability(false, 'not-git-repo');
-      return capability(false, 'untracked');
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ENOENT") return capability(false, "git-unavailable");
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) return capability(false, "not-git-repo");
+      return capability(false, "untracked");
     }
   }
-
   async writeFile(workspaceRoot, userPath, content, options = {}) {
-    return this.runWorkspaceMutation(workspaceRoot, root => (
-      this.writeFileUnlocked(root, userPath, content, options)
-    ));
+    return this.runWorkspaceMutation(workspaceRoot, (root) => this.writeFileUnlocked(root, userPath, content, options));
   }
-
   async flushWorkspaceFileHandle(handle) {
     if (!this.flushWorkspaceWrites) return;
     try {
       await handle.datasync();
-    } catch (error) {
-      if (!['EINVAL', 'ENOSYS', 'ENOTSUP', 'EOPNOTSUPP'].includes(error?.code)) {
+    } catch (caught) {
+      const error = processError(caught);
+      if (!["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP"].includes(String(error.code))) {
         throw error;
       }
       this.flushWorkspaceWrites = false;
-      console.warn('Workspace file datasync is unsupported; disabling it for this server process:', error);
+      console.warn("Workspace file datasync is unsupported; disabling it for this server process:", error);
     }
   }
-
   async writeFileUnlocked(workspaceRoot, userPath, content, options = {}) {
-    if (typeof content !== 'string') {
-      throw new WorkspaceFileError('content must be a string', 400);
+    if (typeof content !== "string") {
+      throw new WorkspaceFileError("content must be a string", 400);
     }
-    if (Buffer.byteLength(content, 'utf8') > this.maxWriteSize) {
-      throw new WorkspaceFileError('file is too large to save', 413);
+    if (Buffer.byteLength(content, "utf8") > this.maxWriteSize) {
+      throw new WorkspaceFileError("file is too large to save", 413);
     }
-
     const { root, target, relativePath } = await this.resolvePath(workspaceRoot, userPath, { allowMissing: true });
     let writeTarget = target;
-    const baseSha1 = typeof options.baseSha1 === 'string' ? options.baseSha1 : '';
+    const baseSha1 = typeof options.baseSha1 === "string" ? options.baseSha1 : "";
     const overwrite = options.overwrite === true;
-    let currentMode = 0o666;
-    let currentSha1 = '';
+    let currentMode = 438;
+    let currentSha1 = "";
     let currentStat = null;
     let exists = false;
     let symbolicLink = false;
-
     try {
       const requestedStat = await fsp.lstat(target);
       symbolicLink = requestedStat.isSymbolicLink();
       const realTarget = await fsp.realpath(target);
       if (!isInside(root, realTarget)) {
-        throw new WorkspaceFileError('symlinks outside the workspace are not allowed', 403);
+        throw new WorkspaceFileError("symlinks outside the workspace are not allowed", 403);
       }
       writeTarget = realTarget;
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (error instanceof WorkspaceFileError) throw error;
-      if (error.code !== 'ENOENT') throw error;
+      if (error.code !== "ENOENT") throw error;
     }
-
     try {
       currentStat = await fsp.stat(writeTarget);
       if (!currentStat.isFile()) {
-        throw new WorkspaceFileError('path must be a file', 400);
+        throw new WorkspaceFileError("path must be a file", 400);
       }
       if (currentStat.size > this.maxFileSize) {
-        throw new WorkspaceFileError('existing file is too large to overwrite safely', 413, { size: currentStat.size });
+        throw new WorkspaceFileError("existing file is too large to overwrite safely", 413, { size: currentStat.size });
       }
       if (await isProbablyBinaryFile(writeTarget)) {
-        throw new WorkspaceFileError('binary files cannot be overwritten as text', 415);
+        throw new WorkspaceFileError("binary files cannot be overwritten as text", 415);
       }
       const currentBuffer = await fsp.readFile(writeTarget);
       currentSha1 = sha1(currentBuffer);
       currentMode = currentStat.mode;
       exists = true;
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (error instanceof WorkspaceFileError) throw error;
-      if (error.code !== 'ENOENT') throw error;
+      if (error.code !== "ENOENT") throw error;
     }
-
-    const desiredSha1 = sha1(Buffer.from(content, 'utf8'));
+    const desiredSha1 = sha1(Buffer.from(content, "utf8"));
     if (baseSha1 && currentSha1 && baseSha1 !== currentSha1 && !overwrite) {
       if (currentSha1 === desiredSha1) {
         return {
           path: relativePath,
           content,
-          size: Buffer.byteLength(content, 'utf8'),
+          size: Buffer.byteLength(content, "utf8"),
           mtimeMs: currentStat.mtimeMs,
           sha1: desiredSha1,
-          ...(symbolicLink ? { symbolicLink: true } : {}),
+          ...symbolicLink ? { symbolicLink: true } : {}
         };
       }
-      throw new WorkspaceFileError('file changed on disk', 409, {
+      throw new WorkspaceFileError("file changed on disk", 409, {
         path: relativePath,
-        currentSha1,
+        currentSha1
       });
     }
     if (baseSha1 && !exists && !overwrite) {
-      throw new WorkspaceFileError('file was deleted on disk', 409, { path: relativePath });
+      throw new WorkspaceFileError("file was deleted on disk", 409, { path: relativePath });
     }
-
     const tempPath = path.join(
       path.dirname(writeTarget),
       `.${path.basename(writeTarget)}.farming-${process.pid}-${crypto.randomUUID()}.tmp`
@@ -2359,189 +2245,171 @@ class WorkspaceFileService {
     let tempHandle = null;
     let committedStat = null;
     try {
-      tempHandle = await fsp.open(tempPath, 'wx', currentMode);
+      tempHandle = await fsp.open(tempPath, "wx", currentMode);
       await tempHandle.writeFile(content);
       await this.flushWorkspaceFileHandle(tempHandle);
       committedStat = await tempHandle.stat();
       await tempHandle.close();
       tempHandle = null;
       await fsp.rename(tempPath, writeTarget);
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (tempHandle) {
-        await tempHandle.close().catch(() => {});
+        await tempHandle.close().catch(() => {
+        });
       }
-      await fsp.unlink(tempPath).catch(unlinkError => {
-        if (unlinkError.code !== 'ENOENT') {
-          console.error('Failed to clean up workspace file temporary:', unlinkError);
+      await fsp.unlink(tempPath).catch((caughtUnlink) => {
+        const unlinkError = processError(caughtUnlink);
+        if (unlinkError.code !== "ENOENT") {
+          console.error("Failed to clean up workspace file temporary:", unlinkError);
         }
       });
       throw error;
     }
     this.invalidateGitStatus(root);
-
     return {
       path: relativePath,
       content,
-      size: Buffer.byteLength(content, 'utf8'),
+      size: Buffer.byteLength(content, "utf8"),
       mtimeMs: committedStat.mtimeMs,
       sha1: desiredSha1,
-      ...(symbolicLink ? { symbolicLink: true } : {}),
+      ...symbolicLink ? { symbolicLink: true } : {}
     };
   }
-
-  async moveEntry(workspaceRoot, sourcePath, targetDirectory = '', options = {}) {
-    return this.runWorkspaceMutation(workspaceRoot, root => (
-      this.moveEntryUnlocked(root, sourcePath, targetDirectory, options)
-    ));
+  async moveEntry(workspaceRoot, sourcePath, targetDirectory = "", options = {}) {
+    return this.runWorkspaceMutation(workspaceRoot, (root) => this.moveEntryUnlocked(root, sourcePath, targetDirectory, options));
   }
-
-  async moveEntryUnlocked(workspaceRoot, sourcePath, targetDirectory = '', options = {}) {
+  async moveEntryUnlocked(workspaceRoot, sourcePath, targetDirectory = "", options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const normalizedSource = normalizeUserPath(sourcePath);
     const normalizedTargetDirectory = normalizeUserPath(targetDirectory);
-
     if (!normalizedSource) {
-      throw new WorkspaceFileError('source path is required', 400);
+      throw new WorkspaceFileError("source path is required", 400);
     }
     if (shouldIgnorePath(normalizedSource) || shouldIgnorePath(normalizedTargetDirectory)) {
-      throw new WorkspaceFileError('ignored paths cannot be moved', 403);
+      throw new WorkspaceFileError("ignored paths cannot be moved", 403);
     }
-
     const source = await this.resolveEntryPath(workspaceRoot, normalizedSource);
     const targetDirectoryPath = path.resolve(root, normalizedTargetDirectory);
     let targetDirectoryRealPath;
     try {
       targetDirectoryRealPath = await fsp.realpath(targetDirectoryPath);
     } catch {
-      throw new WorkspaceFileError('target directory not found', 404);
+      throw new WorkspaceFileError("target directory not found", 404);
     }
     if (!isInside(root, targetDirectoryRealPath)) {
-      throw new WorkspaceFileError('target directory must stay inside the workspace', 403);
+      throw new WorkspaceFileError("target directory must stay inside the workspace", 403);
     }
-
     const targetDirectoryStat = await fsp.stat(targetDirectoryRealPath);
     if (!targetDirectoryStat.isDirectory()) {
-      throw new WorkspaceFileError('target path must be a directory', 400);
+      throw new WorkspaceFileError("target path must be a directory", 400);
     }
-
     const target = path.join(targetDirectoryRealPath, path.basename(source.target));
     const targetPath = relativeFromRoot(root, target);
     if (shouldIgnorePath(targetPath)) {
-      throw new WorkspaceFileError('ignored paths cannot be moved', 403);
+      throw new WorkspaceFileError("ignored paths cannot be moved", 403);
     }
-
     if (target === source.target) {
       return {
         sourcePath: source.relativePath,
         targetPath,
         sourceDirectory: parentDirectory(source.relativePath),
-        targetDirectory: normalizedTargetDirectory,
+        targetDirectory: normalizedTargetDirectory
       };
     }
-
     const sourceStat = await fsp.lstat(source.target);
     const sourceVersion = workspaceEntryVersion(sourceStat);
     if (options.expectedVersion && options.expectedVersion !== sourceVersion) {
-      throw new WorkspaceFileError('source changed on disk', 409, {
+      throw new WorkspaceFileError("source changed on disk", 409, {
         path: source.relativePath,
-        currentVersion: sourceVersion,
+        currentVersion: sourceVersion
       });
     }
     if (sourceStat.isDirectory() && isInside(source.target, target)) {
-      throw new WorkspaceFileError('directory cannot be moved into itself', 400);
+      throw new WorkspaceFileError("directory cannot be moved into itself", 400);
     }
-
     try {
       await fsp.lstat(target);
-      throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
-    } catch (error) {
+      throw new WorkspaceFileError("target path already exists", 409, { path: targetPath });
+    } catch (caught) {
+      const error = processError(caught);
       if (error instanceof WorkspaceFileError) throw error;
-      if (error.code !== 'ENOENT') throw error;
+      if (error.code !== "ENOENT") throw error;
     }
-
     await fsp.rename(source.target, target);
     const targetStat = await fsp.lstat(target);
     this.invalidateGitStatus(root);
-
     return {
       sourcePath: source.relativePath,
       targetPath,
       sourceDirectory: parentDirectory(source.relativePath),
       targetDirectory: normalizedTargetDirectory,
       sourceVersion,
-      targetVersion: workspaceEntryVersion(targetStat),
+      targetVersion: workspaceEntryVersion(targetStat)
     };
   }
-
-  async createEntry(workspaceRoot, parentPath = '', name, type = 'file', content = '') {
-    return this.runWorkspaceMutation(workspaceRoot, root => (
-      this.createEntryUnlocked(root, parentPath, name, type, content)
-    ));
+  async createEntry(workspaceRoot, parentPath = "", name, type = "file", content = "") {
+    return this.runWorkspaceMutation(workspaceRoot, (root) => this.createEntryUnlocked(root, parentPath, name, type, content));
   }
-
-  async createEntryUnlocked(workspaceRoot, parentPath = '', name, type = 'file', content = '') {
+  async createEntryUnlocked(workspaceRoot, parentPath = "", name, type = "file", content = "") {
     const root = await this.resolveRoot(workspaceRoot);
     const normalizedParentPath = normalizeUserPath(parentPath);
     const entryName = normalizeEntryName(name);
-    const entryType = type === 'directory' ? 'directory' : 'file';
-
+    const entryType = type === "directory" ? "directory" : "file";
     if (shouldIgnorePath(normalizedParentPath)) {
-      throw new WorkspaceFileError('ignored paths cannot be changed', 403);
+      throw new WorkspaceFileError("ignored paths cannot be changed", 403);
     }
-    if (entryType === 'file' && Buffer.byteLength(String(content || ''), 'utf8') > this.maxWriteSize) {
-      throw new WorkspaceFileError('file is too large to save', 413);
+    if (entryType === "file" && Buffer.byteLength(String(content || ""), "utf8") > this.maxWriteSize) {
+      throw new WorkspaceFileError("file is too large to save", 413);
     }
-
     const parentDirectoryPath = path.resolve(root, normalizedParentPath);
     let parentDirectoryRealPath;
     try {
       parentDirectoryRealPath = await fsp.realpath(parentDirectoryPath);
     } catch {
-      throw new WorkspaceFileError('parent directory not found', 404);
+      throw new WorkspaceFileError("parent directory not found", 404);
     }
     if (!isInside(root, parentDirectoryRealPath)) {
-      throw new WorkspaceFileError('parent directory must stay inside the workspace', 403);
+      throw new WorkspaceFileError("parent directory must stay inside the workspace", 403);
     }
-
     const parentStat = await fsp.stat(parentDirectoryRealPath);
     if (!parentStat.isDirectory()) {
-      throw new WorkspaceFileError('parent path must be a directory', 400);
+      throw new WorkspaceFileError("parent path must be a directory", 400);
     }
-
     const target = path.join(parentDirectoryRealPath, entryName);
     const targetPath = relativeFromRoot(root, target);
     if (shouldIgnorePath(targetPath)) {
-      throw new WorkspaceFileError('ignored paths cannot be changed', 403);
+      throw new WorkspaceFileError("ignored paths cannot be changed", 403);
     }
-
-    if (entryType === 'directory') {
+    if (entryType === "directory") {
       try {
         await fsp.mkdir(target);
-      } catch (error) {
-        if (error.code === 'EEXIST') {
-          throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
+      } catch (caught) {
+        const error = processError(caught);
+        if (error.code === "EEXIST") {
+          throw new WorkspaceFileError("target path already exists", 409, { path: targetPath });
         }
         throw error;
       }
-      const stat = await fsp.lstat(target);
+      const stat2 = await fsp.lstat(target);
       this.invalidateGitStatus(root);
       return {
         entry: {
           name: entryName,
           path: targetPath,
-          type: 'directory',
-          size: stat.size,
-          mtimeMs: stat.mtimeMs,
-          version: workspaceEntryVersion(stat),
-        },
+          type: "directory",
+          size: stat2.size,
+          mtimeMs: stat2.mtimeMs,
+          version: workspaceEntryVersion(stat2)
+        }
       };
     }
-
     try {
-      await fsp.writeFile(target, String(content || ''), { flag: 'wx' });
-    } catch (error) {
-      if (error.code === 'EEXIST') {
-        throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
+      await fsp.writeFile(target, String(content || ""), { flag: "wx" });
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "EEXIST") {
+        throw new WorkspaceFileError("target path already exists", 409, { path: targetPath });
       }
       throw error;
     }
@@ -2551,139 +2419,121 @@ class WorkspaceFileService {
       entry: {
         name: entryName,
         path: targetPath,
-        type: 'file',
+        type: "file",
         size: stat.size,
         mtimeMs: stat.mtimeMs,
-        version: workspaceEntryVersion(stat),
+        version: workspaceEntryVersion(stat)
       },
-      file: await this.readFile(workspaceRoot, targetPath),
+      file: await this.readFile(workspaceRoot, targetPath)
     };
   }
-
   async renameEntry(workspaceRoot, sourcePath, name, options = {}) {
-    return this.runWorkspaceMutation(workspaceRoot, root => (
-      this.renameEntryUnlocked(root, sourcePath, name, options)
-    ));
+    return this.runWorkspaceMutation(workspaceRoot, (root) => this.renameEntryUnlocked(root, sourcePath, name, options));
   }
-
   async renameEntryUnlocked(workspaceRoot, sourcePath, name, options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const normalizedSource = normalizeUserPath(sourcePath);
     const entryName = normalizeEntryName(name);
-
     if (!normalizedSource) {
-      throw new WorkspaceFileError('source path is required', 400);
+      throw new WorkspaceFileError("source path is required", 400);
     }
     if (shouldIgnorePath(normalizedSource)) {
-      throw new WorkspaceFileError('ignored paths cannot be changed', 403);
+      throw new WorkspaceFileError("ignored paths cannot be changed", 403);
     }
-
     const source = await this.resolveEntryPath(workspaceRoot, normalizedSource);
     const target = path.join(path.dirname(source.target), entryName);
     const targetPath = relativeFromRoot(root, target);
     if (shouldIgnorePath(targetPath)) {
-      throw new WorkspaceFileError('ignored paths cannot be changed', 403);
+      throw new WorkspaceFileError("ignored paths cannot be changed", 403);
     }
-
     if (target === source.target) {
       return {
         sourcePath: source.relativePath,
         targetPath,
         sourceDirectory: parentDirectory(source.relativePath),
-        targetDirectory: parentDirectory(targetPath),
+        targetDirectory: parentDirectory(targetPath)
       };
     }
-
     const sourceStat = await fsp.lstat(source.target);
     const sourceVersion = workspaceEntryVersion(sourceStat);
     if (options.expectedVersion && options.expectedVersion !== sourceVersion) {
-      throw new WorkspaceFileError('source changed on disk', 409, {
+      throw new WorkspaceFileError("source changed on disk", 409, {
         path: source.relativePath,
-        currentVersion: sourceVersion,
+        currentVersion: sourceVersion
       });
     }
-
     try {
       await fsp.lstat(target);
-      throw new WorkspaceFileError('target path already exists', 409, { path: targetPath });
-    } catch (error) {
+      throw new WorkspaceFileError("target path already exists", 409, { path: targetPath });
+    } catch (caught) {
+      const error = processError(caught);
       if (error instanceof WorkspaceFileError) throw error;
-      if (error.code !== 'ENOENT') throw error;
+      if (error.code !== "ENOENT") throw error;
     }
-
     await fsp.rename(source.target, target);
     const targetStat = await fsp.lstat(target);
     this.invalidateGitStatus(root);
-
     return {
       sourcePath: source.relativePath,
       targetPath,
       sourceDirectory: parentDirectory(source.relativePath),
       targetDirectory: parentDirectory(targetPath),
       sourceVersion,
-      targetVersion: workspaceEntryVersion(targetStat),
+      targetVersion: workspaceEntryVersion(targetStat)
     };
   }
-
   async deleteEntry(workspaceRoot, userPath, options = {}) {
-    return this.runWorkspaceMutation(workspaceRoot, root => (
-      this.deleteEntryUnlocked(root, userPath, options)
-    ));
+    return this.runWorkspaceMutation(workspaceRoot, (root) => this.deleteEntryUnlocked(root, userPath, options));
   }
-
   async deleteEntryUnlocked(workspaceRoot, userPath, options = {}) {
     const { root, target, relativePath } = await this.resolveEntryPath(workspaceRoot, userPath);
     if (!relativePath) {
-      throw new WorkspaceFileError('workspace root cannot be deleted', 400);
+      throw new WorkspaceFileError("workspace root cannot be deleted", 400);
     }
     if (shouldIgnorePath(relativePath)) {
-      throw new WorkspaceFileError('ignored paths cannot be changed', 403);
+      throw new WorkspaceFileError("ignored paths cannot be changed", 403);
     }
-
     const stat = await fsp.lstat(target);
     const version = workspaceEntryVersion(stat);
     if (options.expectedVersion && options.expectedVersion !== version) {
-      throw new WorkspaceFileError('entry changed on disk', 409, {
+      throw new WorkspaceFileError("entry changed on disk", 409, {
         path: relativePath,
-        currentVersion: version,
+        currentVersion: version
       });
     }
-    const type = stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : stat.isSymbolicLink() ? 'symlink' : 'other';
+    const type = stat.isDirectory() ? "directory" : stat.isFile() ? "file" : stat.isSymbolicLink() ? "symlink" : "other";
     if (stat.isDirectory()) {
       await fsp.rm(target, { recursive: true, force: false });
     } else {
       await fsp.unlink(target);
     }
     this.invalidateGitStatus(root);
-
     return {
       path: relativePath,
       parentDirectory: parentDirectory(relativePath),
       type,
-      version,
+      version
     };
   }
-
   async search(workspaceRoot, query, options = {}) {
-    if (typeof query !== 'string' || !query.trim()) {
-      throw new WorkspaceFileError('query is required', 400);
+    if (typeof query !== "string" || !query.trim()) {
+      throw new WorkspaceFileError("query is required", 400);
     }
-    const { root, relativePath } = await this.resolvePath(workspaceRoot, options.path || '');
+    const { root, relativePath } = await this.resolvePath(workspaceRoot, options.path || "");
     const limit = Math.max(1, Math.min(500, Number(options.limit) || this.searchLimit));
-    const searchPath = relativePath || '.';
-    const timeout = Math.max(1000, Number(options.timeoutMs) || this.searchTimeoutMs);
+    const searchPath = relativePath || ".";
+    const timeout = Math.max(1e3, Number(options.timeoutMs) || this.searchTimeoutMs);
     const includeIgnored = options.includeIgnored === true;
     const likelyPathQuery = isLikelyPathQuery(query);
-    const result = (matches, truncated) => ({
+    const result = (matches2, truncated) => ({
       query,
       path: searchPath,
-      matches,
+      matches: matches2,
       truncated,
-      timeoutMs: timeout,
+      timeoutMs: timeout
     });
     let pathMatchCandidates = [];
     let searchOutputTruncated = false;
-
     if (includeIgnored) {
       try {
         const directPathMatch = likelyPathQuery ? await this.directPathMatchCandidate(root, query, true) : null;
@@ -2692,14 +2542,14 @@ class WorkspaceFileService {
         }
         const ignoredPathSearch = await this.collectGitIgnoredPathMatchCandidates(root, searchPath, query, limit, timeout);
         return result(ignoredPathSearch.matches, ignoredPathSearch.truncated);
-      } catch (error) {
-        if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM' || error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+      } catch (caught) {
+        const error = processError(caught);
+        if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM" || error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
           return result([], true);
         }
         return result([], false);
       }
     }
-
     try {
       const directPathMatch = likelyPathQuery ? await this.directPathMatchCandidate(root, query) : null;
       if (directPathMatch) {
@@ -2709,101 +2559,98 @@ class WorkspaceFileService {
       const directoryNameSearch = await this.collectDirectoryNameMatchCandidates(root, searchPath, query, limit, timeout);
       pathMatchCandidates = dedupePathMatches([
         ...directoryNameSearch.matches,
-        ...pathSearch.matches,
+        ...pathSearch.matches
       ], limit);
       searchOutputTruncated = pathSearch.truncated || directoryNameSearch.truncated;
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new WorkspaceFileError('ripgrep is not installed', 501);
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ENOENT") {
+        throw new WorkspaceFileError("ripgrep is not installed", 501);
       }
-      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
+      if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
         searchOutputTruncated = true;
       }
       pathMatchCandidates = [];
     }
-
     if (pathMatchCandidates.length >= limit || pathMatchCandidates.length > 0 && likelyPathQuery) {
       return result(pathMatchCandidates, searchOutputTruncated || pathMatchCandidates.length >= limit);
     }
-
     const args = [
-      '--json',
-      '--color',
-      'never',
-      '--line-number',
-      '--column',
-      '--max-count',
+      "--json",
+      "--color",
+      "never",
+      "--line-number",
+      "--column",
+      "--max-count",
       String(Math.min(3, limit)),
-      '--hidden',
+      "--hidden",
       ...searchExcludeGlobArgs(),
-      '--',
+      "--",
       query,
-      searchPath,
+      searchPath
     ];
-
     let stdout;
     try {
       ({ stdout } = await this.execRipgrep(args, { cwd: root, timeout }));
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (error.code === 1) {
-        stdout = error.stdout || '';
-      } else if (error.code === 'ENOENT') {
-        throw new WorkspaceFileError('ripgrep is not installed', 501);
-      } else if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
-        stdout = error.stdout || '';
+        stdout = error.stdout || "";
+      } else if (error.code === "ENOENT") {
+        throw new WorkspaceFileError("ripgrep is not installed", 501);
+      } else if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+        stdout = error.stdout || "";
         searchOutputTruncated = true;
-      } else if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
-        stdout = error.stdout || '';
+      } else if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+        stdout = error.stdout || "";
         searchOutputTruncated = true;
       } else {
-        console.error('Workspace search command failed:', {
+        console.error("Workspace search command failed:", {
           code: error.code,
           signal: error.signal,
           message: error.message,
-          stderr: error.stderr,
+          stderr: error.stderr
         });
-        throw new WorkspaceFileError(error.stderr || 'search failed', 500);
+        throw new WorkspaceFileError(String(error.stderr || "search failed"), 500);
       }
     }
-
     const matches = [];
-    stdout.split('\n').filter(Boolean).forEach((line) => {
+    String(stdout).split("\n").filter(Boolean).forEach((line) => {
       let event;
       try {
         event = JSON.parse(line);
       } catch {
         return;
       }
-      if (event.type !== 'match') return;
-      const data = event.data || {};
-      const submatches = Array.isArray(data.submatches) ? data.submatches : [];
-      const resultPath = normalizeSearchResultPath(data.path && data.path.text ? data.path.text : '');
+      if (!isRecord(event) || event.type !== "match") return;
+      const data = isRecord(event.data) ? event.data : {};
+      const submatches = Array.isArray(data.submatches) ? data.submatches.filter(isRecord) : [];
+      const pathData = isRecord(data.path) ? data.path : {};
+      const linesData = isRecord(data.lines) ? data.lines : {};
+      const resultPath = normalizeSearchResultPath(pathData.text);
       if (!resultPath || isSearchIgnoredRelativePath(resultPath)) return;
       matches.push({
-        kind: 'content',
-        entryType: 'file',
+        kind: "content",
+        entryType: "file",
         path: resultPath,
         lineNumber: data.line_number,
-        lines: data.lines && data.lines.text ? data.lines.text.replace(/\n$/, '') : '',
-        ranges: submatches.map(match => ({
+        lines: typeof linesData.text === "string" ? linesData.text.replace(/\n$/, "") : "",
+        ranges: submatches.map((match) => ({
           start: match.start,
-          end: match.end,
-        })),
+          end: match.end
+        }))
       });
     });
-
     const combinedMatches = [];
-    pathMatchCandidates.forEach(match => {
+    pathMatchCandidates.forEach((match) => {
       combinedMatches.push(match);
     });
-    matches.forEach(match => {
+    matches.forEach((match) => {
       combinedMatches.push(match);
     });
-
     return result(combinedMatches.slice(0, limit), searchOutputTruncated || combinedMatches.length > limit);
   }
-
-  async diff(workspaceRoot, userPath = '', options = {}) {
+  async diff(workspaceRoot, userPath = "", options = {}) {
     const root = await this.resolveRoot(workspaceRoot);
     const normalized = normalizeUserPath(userPath);
     let target = null;
@@ -2816,7 +2663,8 @@ class WorkspaceFileService {
         target = resolved.target;
         relativePath = resolved.relativePath;
         gitRelativePath = resolved.actualRelativePath || resolved.relativePath;
-      } catch (error) {
+      } catch (caught) {
+        const error = processError(caught);
         if (error instanceof WorkspaceFileError && error.statusCode === 404) {
           targetMissing = true;
         } else {
@@ -2824,46 +2672,42 @@ class WorkspaceFileService {
         }
       }
     }
-    const args = ['-C', root, 'diff', ...gitDiffWhitespaceArgs(options.ignoreWhitespace), ...gitDiffContextArgs(options.context), 'HEAD', '--'];
+    const args = ["-C", root, "diff", ...gitDiffWhitespaceArgs(options.ignoreWhitespace), ...gitDiffContextArgs(options.context), "HEAD", "--"];
     if (normalized) args.push(gitRelativePath);
-
     try {
       const { stdout } = await this.execFile(this.gitPath, args, {
         cwd: root,
         timeout: this.diffTimeoutMs,
-        maxBuffer: this.diffMaxBuffer,
+        maxBuffer: this.diffMaxBuffer
       });
       const result = {
         isGitRepo: true,
         path: relativePath,
-        patch: stdout,
+        patch: stdout
       };
       if (!normalized) {
         return result;
       }
-
       if (targetMissing) {
-        const status = await this.getGitStatusForPath(root, gitRelativePath);
-        if (status?.kind !== 'deleted') {
-          throw new WorkspaceFileError('path not found', 404);
+        const status2 = await this.getGitStatusForPath(root, gitRelativePath);
+        if (status2?.kind !== "deleted") {
+          throw new WorkspaceFileError("path not found", 404);
         }
         const original = await this.execFile(this.gitPath, [
-          '-C',
+          "-C",
           root,
-          'show',
-          `HEAD:${gitRelativePath}`,
-        ], { cwd: root, encoding: 'buffer' });
-        const originalContent = Buffer.isBuffer(original.stdout)
-          ? original.stdout.toString('utf8')
-          : String(original.stdout || '');
+          "show",
+          `HEAD:${gitRelativePath}`
+        ], { cwd: root, encoding: "buffer" });
+        const originalContent2 = Buffer.isBuffer(original.stdout) ? original.stdout.toString("utf8") : String(original.stdout || "");
         return {
           ...result,
-          originalContent,
-          modifiedContent: '',
-          deleted: true,
+          originalContent: originalContent2,
+          modifiedContent: "",
+          deleted: true
         };
       }
-
+      if (!target) return result;
       const stat = await fsp.stat(target);
       if (!stat.isFile()) {
         return result;
@@ -2873,96 +2717,89 @@ class WorkspaceFileService {
           ...result,
           path: relativePath,
           binary: true,
-          size: stat.size,
+          size: stat.size
         };
       }
-
       const modifiedBuffer = await fsp.readFile(target);
       const gitStatusByPath = await this.loadGitStatusByPath(root);
       if (this.gitStatusCacheTtlMs > 0) {
         this.gitStatusCache.set(root, {
           value: gitStatusByPath,
-          expiresAt: Date.now() + this.gitStatusCacheTtlMs,
+          expiresAt: Date.now() + this.gitStatusCacheTtlMs
         });
       }
       const status = gitStatusByPath.get(normalizeGitStatusPath(gitRelativePath)) || null;
-      const originalGitPath = status?.kind === 'renamed' && status.previousPath
-        ? status.previousPath
-        : gitRelativePath;
-      let originalContent = '';
+      const originalGitPath = status?.kind === "renamed" && status.previousPath ? status.previousPath : gitRelativePath;
+      let originalContent = "";
       let untracked = false;
       try {
         const original = await this.execFile(this.gitPath, [
-          '-C',
+          "-C",
           root,
-          'show',
-          `HEAD:${originalGitPath}`,
-        ], { cwd: root, encoding: 'buffer' });
-        originalContent = Buffer.isBuffer(original.stdout)
-          ? original.stdout.toString('utf8')
-          : String(original.stdout || '');
-      } catch (error) {
+          "show",
+          `HEAD:${originalGitPath}`
+        ], { cwd: root, encoding: "buffer" });
+        originalContent = Buffer.isBuffer(original.stdout) ? original.stdout.toString("utf8") : String(original.stdout || "");
+      } catch (caught) {
+        const error = processError(caught);
         if (error.stderr && /(exists on disk, but not in|path .* exists on disk|does not exist in|not in HEAD|invalid object name)/i.test(String(error.stderr))) {
           untracked = true;
         } else {
           throw error;
         }
       }
-
       return {
         ...result,
         path: relativePath,
         originalContent,
-        modifiedContent: modifiedBuffer.toString('utf8'),
-        untracked,
+        modifiedContent: modifiedBuffer.toString("utf8"),
+        untracked
       };
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new WorkspaceFileError('git is not installed', 501);
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ENOENT") {
+        throw new WorkspaceFileError("git is not installed", 501);
       }
-      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
-        throw new WorkspaceFileError('git diff timed out', 504);
+      if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+        throw new WorkspaceFileError("git diff timed out", 504);
       }
-      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+      if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
         return {
           isGitRepo: true,
           path: relativePath,
-          patch: error.stdout || '',
-          truncated: true,
+          patch: error.stdout || "",
+          truncated: true
         };
       }
-      if (error.stderr && /not a git repository/i.test(error.stderr)) {
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
         return {
           isGitRepo: false,
           path: normalized,
-          patch: '',
+          patch: ""
         };
       }
-      throw new WorkspaceFileError(error.stderr || 'git diff failed', 500);
+      throw new WorkspaceFileError(String(error.stderr || "git diff failed"), 500);
     }
   }
-
-  async lineChanges(workspaceRoot, userPath, lineNumber, mode = 'working') {
+  async lineChanges(workspaceRoot, userPath, lineNumber, mode = "working") {
     const requestedLineNumber = Number(lineNumber);
     if (!Number.isInteger(requestedLineNumber) || requestedLineNumber < 1) {
-      throw new WorkspaceFileError('lineNumber must be a positive integer', 400);
+      throw new WorkspaceFileError("lineNumber must be a positive integer", 400);
     }
-    if (mode !== 'working' && mode !== 'previous') {
-      throw new WorkspaceFileError('mode must be working or previous', 400);
+    if (mode !== "working" && mode !== "previous") {
+      throw new WorkspaceFileError("mode must be working or previous", 400);
     }
-
     const { root, target, relativePath, actualRelativePath } = await this.resolvePath(workspaceRoot, userPath);
     const stat = await fsp.stat(target);
     if (!stat.isFile()) {
-      throw new WorkspaceFileError('path must be a file', 400);
+      throw new WorkspaceFileError("path must be a file", 400);
     }
     if (stat.size > this.maxFileSize) {
-      throw new WorkspaceFileError('file is too large to inspect line changes', 413, { size: stat.size });
+      throw new WorkspaceFileError("file is too large to inspect line changes", 413, { size: stat.size });
     }
     if (await isProbablyBinaryFile(target)) {
-      throw new WorkspaceFileError('binary files cannot be inspected as text', 415);
+      throw new WorkspaceFileError("binary files cannot be inspected as text", 415);
     }
-
     const gitRelativePath = actualRelativePath || relativePath;
     const baseResult = {
       isGitRepo: true,
@@ -2970,232 +2807,226 @@ class WorkspaceFileService {
       mode,
       lineNumber: requestedLineNumber,
       lookupLineNumber: requestedLineNumber,
-      targetSide: mode === 'working' ? 'working' : 'revision',
+      targetSide: mode === "working" ? "working" : "revision",
       available: false,
-      reason: '',
-      patch: '',
-      hunk: null,
+      reason: "",
+      patch: "",
+      hunk: null
     };
-
     try {
-      if (mode === 'working') {
+      if (mode === "working") {
         const directGitStatus = await this.getGitStatusForPath(root, gitRelativePath);
-        if (directGitStatus?.kind === 'untracked') {
-          const modifiedContent = await fsp.readFile(target, 'utf8');
-          const hunk = createAddedFileLineChangesHunk(modifiedContent, requestedLineNumber);
+        if (directGitStatus?.kind === "untracked") {
+          const modifiedContent = await fsp.readFile(target, "utf8");
+          const hunk3 = createAddedFileLineChangesHunk(modifiedContent, requestedLineNumber);
           return {
             ...baseResult,
-            available: Boolean(hunk),
-            reason: hunk ? '' : 'unchanged',
-            patch: hunk ? hunk.patch : '',
-            hunk,
+            available: Boolean(hunk3),
+            reason: hunk3 ? "" : "unchanged",
+            patch: hunk3 ? hunk3.patch : "",
+            hunk: hunk3
           };
         }
-
-        const { stdout } = await this.execFile(this.gitPath, [
-          '-C',
+        const { stdout: stdout2 } = await this.execFile(this.gitPath, [
+          "-C",
           root,
-          'diff',
-          '--unified=20',
-          'HEAD',
-          '--',
-          gitRelativePath,
+          "diff",
+          "--unified=20",
+          "HEAD",
+          "--",
+          gitRelativePath
         ], {
           cwd: root,
           timeout: this.diffTimeoutMs,
-          maxBuffer: this.diffMaxBuffer,
+          maxBuffer: this.diffMaxBuffer
         });
-        const hunk = selectUnifiedDiffHunk(stdout, 'new', requestedLineNumber);
+        const hunk2 = selectUnifiedDiffHunk(stdout2, "new", requestedLineNumber);
         return {
           ...baseResult,
-          available: Boolean(hunk),
-          reason: hunk ? '' : 'unchanged',
-          patch: hunk ? hunk.patch : '',
-          hunk,
+          available: Boolean(hunk2),
+          reason: hunk2 ? "" : "unchanged",
+          patch: hunk2 ? hunk2.patch : "",
+          hunk: hunk2
         };
       }
-
       const blame = await this.blame(workspaceRoot, userPath);
       if (!blame.isGitRepo) {
         return {
           ...baseResult,
           isGitRepo: false,
-          reason: 'not-git-repo',
+          reason: "not-git-repo"
         };
       }
-      const blameLine = blame.lines.find(line => line.lineNumber === requestedLineNumber);
+      const blameLine = blame.lines.find((line) => line.lineNumber === requestedLineNumber);
       if (!blameLine) {
         return {
           ...baseResult,
-          reason: 'line-not-found',
+          reason: "line-not-found"
         };
       }
       if (blameLine.uncommitted) {
         return {
           ...baseResult,
-          reason: 'uncommitted',
+          reason: "uncommitted",
           commit: {
             hash: blameLine.commit,
             shortHash: blameLine.shortCommit,
             author: blameLine.author,
             authorTimeIso: blameLine.authorTimeIso,
-            summary: blameLine.summary,
-          },
+            summary: blameLine.summary
+          }
         };
       }
-
       const { stdout } = await this.execFile(this.gitPath, [
-        '-C',
+        "-C",
         root,
-        'show',
-        '--format=',
-        '--unified=20',
+        "show",
+        "--format=",
+        "--unified=20",
         blameLine.commit,
-        '--',
-        gitRelativePath,
+        "--",
+        gitRelativePath
       ], {
         cwd: root,
         timeout: this.diffTimeoutMs,
-        maxBuffer: this.diffMaxBuffer,
+        maxBuffer: this.diffMaxBuffer
       });
-      const hunk = selectUnifiedDiffHunk(stdout, 'new', blameLine.originalLineNumber);
+      const hunk = selectUnifiedDiffHunk(stdout, "new", blameLine.originalLineNumber);
       return {
         ...baseResult,
         lookupLineNumber: blameLine.originalLineNumber,
         available: Boolean(hunk),
-        reason: hunk ? '' : 'not-found',
-        patch: hunk ? hunk.patch : '',
+        reason: hunk ? "" : "not-found",
+        patch: hunk ? hunk.patch : "",
         hunk,
         commit: {
           hash: blameLine.commit,
           shortHash: blameLine.shortCommit,
           author: blameLine.author,
           authorTimeIso: blameLine.authorTimeIso,
-          summary: blameLine.summary,
-        },
+          summary: blameLine.summary
+        }
       };
-    } catch (error) {
+    } catch (caught) {
+      const error = processError(caught);
       if (error instanceof WorkspaceFileError) {
-        if (mode === 'previous' && error.statusCode === 409) {
+        if (mode === "previous" && error.statusCode === 409) {
           return {
             ...baseResult,
-            reason: 'untracked',
+            reason: "untracked"
           };
         }
         throw error;
       }
-      if (error.code === 'ENOENT') {
-        throw new WorkspaceFileError('git is not installed', 501);
+      if (error.code === "ENOENT") {
+        throw new WorkspaceFileError("git is not installed", 501);
       }
-      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
-        throw new WorkspaceFileError('git line changes timed out', 504);
+      if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+        throw new WorkspaceFileError("git line changes timed out", 504);
       }
-      if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+      if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
         return {
           ...baseResult,
           available: false,
-          reason: 'truncated',
-          patch: error.stdout || '',
-          truncated: true,
+          reason: "truncated",
+          patch: error.stdout || "",
+          truncated: true
         };
       }
-      if (error.stderr && /not a git repository/i.test(error.stderr)) {
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
         return {
           ...baseResult,
           isGitRepo: false,
-          reason: 'not-git-repo',
+          reason: "not-git-repo"
         };
       }
-      if (mode === 'previous' && error.stderr && /(no such path|does not exist in|not in HEAD|path .* exists on disk|invalid object name)/i.test(String(error.stderr))) {
+      if (mode === "previous" && error.stderr && /(no such path|does not exist in|not in HEAD|path .* exists on disk|invalid object name)/i.test(String(error.stderr))) {
         return {
           ...baseResult,
-          reason: 'not-found',
+          reason: "not-found"
         };
       }
-      throw new WorkspaceFileError(error.stderr || 'git line changes failed', 500);
+      throw new WorkspaceFileError(String(error.stderr || "git line changes failed"), 500);
     }
   }
-
   async blame(workspaceRoot, userPath) {
     const { root, target, relativePath, actualRelativePath } = await this.resolvePath(workspaceRoot, userPath);
     const stat = await fsp.stat(target);
     if (!stat.isFile()) {
-      throw new WorkspaceFileError('path must be a file', 400);
+      throw new WorkspaceFileError("path must be a file", 400);
     }
     if (stat.size > this.maxFileSize) {
-      throw new WorkspaceFileError('file is too large to blame', 413, { size: stat.size });
+      throw new WorkspaceFileError("file is too large to blame", 413, { size: stat.size });
     }
     if (await isProbablyBinaryFile(target)) {
-      throw new WorkspaceFileError('binary files cannot be blamed as text', 415);
+      throw new WorkspaceFileError("binary files cannot be blamed as text", 415);
     }
-
     try {
       const { stdout } = await this.execFile(this.gitPath, [
-        'blame',
-        '--line-porcelain',
-        '--',
-        actualRelativePath || relativePath,
+        "blame",
+        "--line-porcelain",
+        "--",
+        actualRelativePath || relativePath
       ], { cwd: root, timeout: this.blameTimeoutMs });
       return {
         isGitRepo: true,
         path: relativePath,
-        lines: parseGitBlamePorcelain(stdout),
+        lines: parseGitBlamePorcelain(stdout)
       };
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new WorkspaceFileError('git is not installed', 501);
+    } catch (caught) {
+      const error = processError(caught);
+      if (error.code === "ENOENT") {
+        throw new WorkspaceFileError("git is not installed", 501);
       }
-      if (error.code === 'ETIMEDOUT' || error.signal === 'SIGTERM') {
-        throw new WorkspaceFileError('git blame timed out', 504);
+      if (error.code === "ETIMEDOUT" || error.signal === "SIGTERM") {
+        throw new WorkspaceFileError("git blame timed out", 504);
       }
-      if (error.stderr && /not a git repository/i.test(error.stderr)) {
+      if (error.stderr && /not a git repository/i.test(String(error.stderr))) {
         return {
           isGitRepo: false,
           path: relativePath,
-          lines: [],
+          lines: []
         };
       }
-      if (error.stderr && /(no such path|no such ref|does not exist in|not in HEAD|no such file)/i.test(error.stderr)) {
-        throw new WorkspaceFileError('file is not tracked by git', 409, { path: relativePath });
+      if (error.stderr && /(no such path|no such ref|does not exist in|not in HEAD|no such file)/i.test(String(error.stderr))) {
+        throw new WorkspaceFileError("file is not tracked by git", 409, { path: relativePath });
       }
-      throw new WorkspaceFileError(error.stderr || 'git blame failed', 500);
+      throw new WorkspaceFileError(String(error.stderr || "git blame failed"), 500);
     }
   }
-
   async subscribe(workspaceRoot, callback) {
-    if (this.disposed) return async () => {};
+    if (this.disposed) return async () => {
+    };
     const lifecycleGeneration = this.watcherLifecycleGeneration;
     const root = await this.resolveRoot(workspaceRoot);
-    if (this.disposed || this.watcherLifecycleGeneration !== lifecycleGeneration) return async () => {};
+    if (this.disposed || this.watcherLifecycleGeneration !== lifecycleGeneration) return async () => {
+    };
     const watchRoot = path.resolve(workspaceRoot);
     let record = this.watchers.get(root);
-
     if (!record) {
-      const subscribers = new Set();
+      const subscribers = /* @__PURE__ */ new Set();
       const generation = this.watcherSubscriptionGeneration + 1;
       this.watcherSubscriptionGeneration = generation;
-
       const emit = (eventType, absolutePath) => {
-        const relative = relativeFromRoot(watchRoot, absolutePath);
+        const relative = relativeFromRoot(watchRoot, String(absolutePath));
         if (shouldHidePath(relative)) return;
         this.invalidateGitStatus(root);
         subscribers.forEach((subscriber) => {
           subscriber({
             type: eventType,
-            path: relative,
+            path: relative
           });
         });
       };
-
-      const emitError = (error) => {
+      const emitError = (caught) => {
+        const error = processError(caught);
         subscribers.forEach((subscriber) => {
           subscriber({
-            type: 'error',
-            message: error.message,
+            type: "error",
+            message: error.message
           });
         });
       };
-
       record = {
         watcher: null,
         subscribers,
@@ -3203,62 +3034,56 @@ class WorkspaceFileService {
         cancelled: false,
         cancelInitialization: null,
         closePromise: null,
-        ready: null,
+        ready: null
       };
       this.watchers.set(root, record);
+      const initializingRecord = record;
       record.ready = (async () => {
         const configuredIgnored = this.watchOptions.ignored;
         const ignored = (candidatePath) => {
-          const relative = path.relative(watchRoot, candidatePath);
+          const candidate = String(candidatePath);
+          const relative = path.relative(watchRoot, candidate);
           if (shouldHidePath(relative)) return true;
-          if (typeof configuredIgnored === 'function') return configuredIgnored(candidatePath);
-          if (configuredIgnored instanceof RegExp) return configuredIgnored.test(candidatePath);
+          if (typeof configuredIgnored === "function") return Boolean(configuredIgnored(candidate));
+          if (configuredIgnored instanceof RegExp) return configuredIgnored.test(candidate);
           if (Array.isArray(configuredIgnored)) {
-            return configuredIgnored.some(pattern => (
-              pattern instanceof RegExp ? pattern.test(candidatePath) : String(candidatePath).includes(String(pattern))
-            ));
+            return configuredIgnored.some((pattern) => pattern instanceof RegExp ? pattern.test(candidate) : candidate.includes(String(pattern)));
           }
           return false;
         };
         const chokidar = await loadChokidar();
-        if (
-          record.cancelled
-          || this.watchers.get(root)?.generation !== generation
-        ) return false;
+        if (initializingRecord.cancelled || this.watchers.get(root)?.generation !== generation) return false;
         const watcher = chokidar.watch(watchRoot, {
           ignoreInitial: true,
           depth: this.watchDepth,
           ...this.watchOptions,
-          ignored,
+          ignored
         });
-        record.watcher = watcher;
-
-        ['add', 'change', 'unlink', 'addDir', 'unlinkDir'].forEach((eventType) => {
-          watcher.on(eventType, filePath => emit(eventType, filePath));
+        initializingRecord.watcher = watcher;
+        ["add", "change", "unlink", "addDir", "unlinkDir"].forEach((eventType) => {
+          watcher.on(eventType, (filePath) => emit(eventType, filePath));
         });
-        watcher.on('error', emitError);
-        const initialized = await new Promise(resolve => {
+        watcher.on("error", emitError);
+        const initialized2 = await new Promise((resolve) => {
           let settled = false;
-          const finish = value => {
+          const finish = (value) => {
             if (settled) return;
             settled = true;
             resolve(value);
           };
-          watcher.once('ready', () => finish(true));
-          record.cancelInitialization = () => finish(false);
+          watcher.once("ready", () => finish(true));
+          initializingRecord.cancelInitialization = () => finish(false);
         });
-        record.cancelInitialization = null;
-        return initialized
-          && !record.cancelled
-          && this.watchers.get(root)?.generation === generation;
+        initializingRecord.cancelInitialization = null;
+        return initialized2 && !initializingRecord.cancelled && this.watchers.get(root)?.generation === generation;
       })();
     }
-
     record.subscribers.add(callback);
     let initialized = false;
     try {
-      initialized = await record.ready;
-    } catch (error) {
+      initialized = await (record.ready ?? Promise.resolve(false));
+    } catch (caught) {
+      const error = processError(caught);
       record.subscribers.delete(callback);
       if (record.subscribers.size === 0 && this.watchers.get(root)?.generation === record.generation) {
         this.watchers.delete(root);
@@ -3268,20 +3093,17 @@ class WorkspaceFileService {
     }
     if (!initialized) {
       record.subscribers.delete(callback);
-      return async () => {};
+      return async () => {
+      };
     }
     return async () => {
       if (!record.subscribers.delete(callback)) return;
-      if (
-        record.subscribers.size === 0
-        && this.watchers.get(root)?.generation === record.generation
-      ) {
+      if (record.subscribers.size === 0 && this.watchers.get(root)?.generation === record.generation) {
         this.watchers.delete(root);
         await this.closeWorkspaceWatcherRecord(record);
       }
     };
   }
-
   async closeWorkspaceWatcherRecord(record) {
     if (record.closePromise) return record.closePromise;
     record.cancelled = true;
@@ -3290,40 +3112,39 @@ class WorkspaceFileService {
       await record.ready?.catch(() => false);
       if (!record.watcher) return;
       const closeResult = record.watcher.close();
-      if (closeResult && typeof closeResult.then === 'function') await closeResult;
+      if (closeResult && typeof closeResult.then === "function") await closeResult;
     })();
     return record.closePromise;
   }
-
   async dispose() {
     const watchers = Array.from(this.watchers.values());
     this.watchers.clear();
     this.disposed = true;
     this.watcherLifecycleGeneration += 1;
     this.gitStatusCache.clear();
-    await Promise.all(watchers.map(record => this.closeWorkspaceWatcherRecord(record)));
+    await Promise.all(watchers.map((record) => this.closeWorkspaceWatcherRecord(record)));
     if (this.ownsCommandRunner) {
       this.commandRunner.dispose();
     }
   }
 }
-
-module.exports = {
-  WorkspaceFileService,
-  WorkspaceFileError,
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   DEFAULT_MAX_FILE_SIZE,
   DEFAULT_MAX_WRITE_SIZE,
   DEFAULT_WATCH_DEPTH,
-  isPackagedRuntime,
-  parseGitBlamePorcelain,
-  parseUnifiedDiffRows,
+  WorkspaceFileError,
+  WorkspaceFileService,
   createAddedFileLineChangesHunk,
-  parseUnifiedDiffHunks,
-  selectUnifiedDiffHunk,
-  resolveCommandRunnerNodePath,
+  isPackagedRuntime,
   normalizeGitHistoryLimit,
   normalizeGitHistorySkip,
+  parseGitBlamePorcelain,
   parseGitHistoryChanges,
   parseGitHistoryLog,
   parseGitHistoryReferences,
-};
+  parseUnifiedDiffHunks,
+  parseUnifiedDiffRows,
+  resolveCommandRunnerNodePath,
+  selectUnifiedDiffHunk
+});