token-goat 2.9.28 → 2.9.30

package/dist/{token-goat-chunk-HXNAC4ZF.mjs → token-goat-chunk-AFLYLHDH.mjs}

@@ -1,37 +1,42 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
+import {
+  sanitizeFtsQuery
+} from "./token-goat-chunk-HYBFA5X3.mjs";
 import {
   DEFAULT_MAX_AGE_MS,
   blobPath,
   isBlobStale,
   loadBlob,
   storeBlob
-} from "./token-goat-chunk-BJBRGPBX.mjs";
+} from "./token-goat-chunk-ARDNEC2U.mjs";
 import {
-  hasUnquotedOperator
-} from "./token-goat-chunk-4RN64ZND.mjs";
+  getDb
+} from "./token-goat-chunk-VL3YIFHZ.mjs";
 import {
   redactSecrets
-} from "./token-goat-chunk-MVSWBNMD.mjs";
-import {
-  sanitizeFtsQuery
-} from "./token-goat-chunk-HUDC5GS5.mjs";
-import {
-  getDb
-} from "./token-goat-chunk-M56BWPBN.mjs";
+} from "./token-goat-chunk-4FVIAHSI.mjs";
 import {
   shortFingerprint
-} from "./token-goat-chunk-CC2PYJM7.mjs";
+} from "./token-goat-chunk-7IN2MKDS.mjs";
 import {
   registerReset
-} from "./token-goat-chunk-EEIDFMEM.mjs";
+} from "./token-goat-chunk-YZAAZU2S.mjs";
 import {
-  globalDbPath,
   runGit
-} from "./token-goat-chunk-L45ZQRT7.mjs";
+} from "./token-goat-chunk-GOLEOXZP.mjs";
 import {
   normalizePath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  globalDbPath
+} from "./token-goat-chunk-VES7EL7O.mjs";
+import {
+  hasUnquotedOperator
+} from "./token-goat-chunk-KWPNJBDH.mjs";
+import {
+  stripAnsiEscapes
+} from "./token-goat-chunk-HAVAOB3S.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -138,7 +143,7 @@ var BUILD_COMMAND_PATTERNS = [
   /^\s*(?:gradle|\.\/gradlew|gradlew)\b/i,
   // Python / pip
   /^\s*pip\s+(install|freeze)\b/i,
-  // npm audit / npm outdated — read-only reporting commands with no side effects, safe to cache/recall. Each resolves a `lockfile`-scoped fingerprint via bash_output_cache.ts's isNpmAuditCommand/isNpmOutdatedCommand, but that fingerprinting never actually ran outside their own unit tests until this entry, since neither subcommand was recognized by isBuildCommand (the generic cache-reachability gate in hooks_bash.ts). `npm install`/`npm ci`/`npm list`/`npm ls` are deliberately left out — see the negative-case test in lang_patterns.test.ts.
+  // npm audit / npm outdated — read-only reporting commands with no side effects, safe to cache/recall. Each resolves a `lockfile`-scoped fingerprint via bash_output_cache.ts's isNpmAuditCommand/isNpmOutdatedCommand, but that fingerprinting never actually ran outside their own unit tests until this entry, since neither subcommand was recognized by isBuildCommand (the generic cache-reachability gate in hooks_bash.ts and hooks_bash_post.ts). `npm install`/`npm ci`/`npm list`/`npm ls` are deliberately left out — see the negative-case test in lang_patterns.test.ts.
   /^\s*npm\s+(audit|outdated)\b/i,
   // Poetry
   /^\s*poetry\s+(install|update)\b/i,
@@ -223,6 +228,8 @@ var TEST_RUNNER_COMMAND_PATTERNS = [
   /^go test(?:\s|$)/i,
   // Rust / Cargo
   /^cargo test(?:\s|$)/i,
+  // dotnet test
+  /^\s*dotnet\s+test(?:\s|$)/i,
   // npm test / npm run test
   /^npm (?:test|run test)(?:\s|$)/i,
   // yarn test / yarn run test / pnpm test / pnpm run test
@@ -231,6 +238,20 @@ var TEST_RUNNER_COMMAND_PATTERNS = [
 function isTestRunnerCommand(cmd) {
   return TEST_RUNNER_COMMAND_PATTERNS.some((re) => re.test(cmd));
 }
+var DEV_SERVER_COMMAND_PATTERNS = [
+  { pattern: /^(?:npx\s+)?next dev/, recallHint: '--tail 30 --grep "error|warn|ready|compiled"' },
+  { pattern: /^(?:npx\s+)?next build/, recallHint: '--grep "error|warn|Failed|\u2713"' },
+  // vite ends at whitespace or the end of the command, not at a word boundary, which a hyphen satisfies: vite-node is another tool, so it is neither recalled nor fingerprinted as a dev server.
+  { pattern: /^(?:npx\s+)?vite(?:\s|$)/, recallHint: '--tail 20 --grep "error|warn|ready"' },
+  // nuxt dev ends the same way: `nuxt devtools enable` is another nuxt command.
+  { pattern: /^(?:npx\s+)?nuxt dev(?:\s|$)/, recallHint: '--tail 30 --grep "error|warn|ready"' },
+  { pattern: /^(?:npx\s+)?remix dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
+  { pattern: /^(?:npx\s+)?astro dev/, recallHint: '--tail 20 --grep "error|warn|ready"' }
+];
+function isDevServerCommand(cmd) {
+  const trimmed = cmd.trim();
+  return DEV_SERVER_COMMAND_PATTERNS.some(({ pattern }) => pattern.test(trimmed));
+}
 var MONITORING_COMMAND_PATTERNS = [
   // GitHub CI
   { pattern: /^gh run (?:watch|view|list)/, recallHint: '--grep "fail|error|pass|\u2713|\u2717|conclusion"' },
@@ -240,16 +261,10 @@ var MONITORING_COMMAND_PATTERNS = [
   { pattern: /^gh pr list/, recallHint: '--grep "OPEN|DRAFT|MERGED|#"' },
   { pattern: /^gh issue view/, recallHint: '--grep "state|title|label|OPEN|CLOSED"' },
   { pattern: /^gh workflow (?:run|list|view)/, recallHint: '--grep "completed|failed|in_progress"' },
-  // Dev servers (Next, Vite, Nuxt, Remix, Astro)
-  { pattern: /^(?:npx\s+)?next dev/, recallHint: '--tail 30 --grep "error|warn|ready|compiled"' },
-  { pattern: /^(?:npx\s+)?next build/, recallHint: '--grep "error|warn|Failed|\u2713"' },
-  { pattern: /^(?:npx\s+)?vite\b(?:\s+dev|\s+build|\s+preview)?/, recallHint: '--tail 20 --grep "error|warn|ready"' },
-  { pattern: /^(?:npx\s+)?nuxt dev/, recallHint: '--tail 30 --grep "error|warn|ready"' },
-  { pattern: /^(?:npx\s+)?remix dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
-  { pattern: /^(?:npx\s+)?astro dev/, recallHint: '--tail 20 --grep "error|warn|ready"' },
-  // Test watchers
-  { pattern: /^(?:npx\s+)?vitest(?:\s+run|\s+watch)?/, recallHint: '--grep "FAIL|PASS|Error|\u2713|\u2717"' },
-  { pattern: /^(?:npx\s+)?jest(?:\s+--watch)?/, recallHint: '--grep "FAIL|PASS|Error|Tests:"' },
+  ...DEV_SERVER_COMMAND_PATTERNS,
+  // Test watchers. jest and vitest must be followed by whitespace or the end of the command, as in TEST_RUNNER_COMMAND_PATTERNS, not merely by a word boundary: a cached run goes stale only through the git fingerprint isTestRunnerCommand grants, and a longer name (jest-codemods, vitest-preview) is another tool that predicate rejects.
+  { pattern: /^(?:npx\s+)?vitest(?:\s|$)/, recallHint: '--grep "FAIL|PASS|Error|\u2713|\u2717"' },
+  { pattern: /^(?:npx\s+)?jest(?:\s|$)/, recallHint: '--grep "FAIL|PASS|Error|Tests:"' },
   { pattern: /^pytest(?:\s|$)/, recallHint: '--grep "FAILED|PASSED|ERROR|passed|failed"' },
   { pattern: /^(?:cargo\s+test|cargo\s+watch)/, recallHint: '--grep "FAILED|ok|error\\["' },
   { pattern: /^go test/, recallHint: '--grep "FAIL|ok|---"' },
@@ -266,7 +281,8 @@ var MONITORING_COMMAND_PATTERNS = [
   { pattern: /^(?:npx\s+)?prettier(?:\s|$)/, recallHint: '--grep "unchanged|reformatted|error"' },
   { pattern: /^npx\s+tsc(?:\s|$)/, recallHint: '--grep "error TS|Cannot find|Type "' },
   { pattern: /^ruff(?:\s|$)/, recallHint: '--grep "error|warning|Found"' },
-  { pattern: /^(?:cargo\s+)?clippy/, recallHint: '--grep "error\\[|warning\\["' },
+  // Ends the same way: clippy-driver is clippy's rustc wrapper, run without cargo, so isBuildCommand gives it no fingerprint to go stale by.
+  { pattern: /^(?:cargo\s+)?clippy(?:\s|$)/, recallHint: '--grep "error\\[|warning\\["' },
   // git diff (full diff output — can be very large; excludes --stat which is small)
   { pattern: /^git diff(?!\s+--stat)(?:\s+HEAD)?(?:\s|$)/, recallHint: '--grep "@@|\\+\\+\\+|---|diff --git"' },
   { pattern: /^git diff\s+--cached(?!\s+--stat)/, recallHint: '--grep "@@|\\+\\+\\+|---|diff --git"' },
@@ -345,7 +361,8 @@ function indexRecallEntry(cacheType, id, label, content, storedAt) {
          label = excluded.label,
          content = excluded.content,
          stored_at = excluded.stored_at`
-    ).run({ cacheType, id, label, content, storedAt });
+      // Stripped so a query spanning a colour boundary matches the text a reader sees; the cached blob itself stays raw.
+    ).run({ cacheType, id, label: stripAnsiEscapes(label), content: stripAnsiEscapes(content), storedAt });
   } catch {
   }
   pruneCacheRecallRows();
@@ -371,7 +388,7 @@ function hasFtsTable() {
   return _ftsAvailable;
 }
 function buildSnippet(content, query, maxLen = 160) {
-  const flat = content.replace(/\s+/g, " ").trim();
+  const flat = stripAnsiEscapes(content).replace(/\s+/g, " ").trim();
   const tokens = query.split(/\s+/).filter(Boolean);
   let idx = -1;
   const lowerFlat = flat.toLowerCase();
@@ -489,7 +506,6 @@ var COMMAND_PATTERNS = {
   envProbe: /^\s*(?:node\s+(?:-v|--version)|npm\s+(?:-v|--version)|python3?\s+(?:(?:-V)\b|--?version)|git\s+--version|uv\s+--version|go\s+version|rustc\s+--version|cargo\s+--version|java\s+--version|ruby\s+--version|gem\s+--version|php\s+--version|which\b|where\b)/i,
   npx: /^(?!.*\b(?:install|add|remove|uninstall|i|rm|update|upgrade|set|get|publish|link|ci|audit|shrinkwrap|dedupe|prune|rebuild)\b)\s*npx\s+(?:--?yes\s+)?/i,
   gitPush: /^\s*git\s+push\b/i,
-  testRunner: /^\s*(?:npx\s+)?(?:pytest|vitest|jest|go\s+test)\b/i,
   lintCommand: /^\s*(?:(?:npx\s+)?eslint|(?:uv\s+run\s+)?ruff)\b/i,
   npmRunScript: /^\s*npm\s+run(?:-script)?\b/i,
   catCommand: /^\s*cat\b/i
@@ -515,7 +531,6 @@ var isNpmInstallCommand = (cmd) => isCommandOfType(cmd, "npmInstall");
 var isNpmAuditCommand = (cmd) => isCommandOfType(cmd, "npmAudit");
 var isNpmOutdatedCommand = (cmd) => isCommandOfType(cmd, "npmOutdated");
 var isGitPushCommand = (cmd) => isCommandOfType(cmd, "gitPush");
-var isTestRunnerCommand2 = (cmd) => isCommandOfType(cmd, "testRunner");
 var isLintCommand = (cmd) => isCommandOfType(cmd, "lintCommand");
 var isNpmRunScriptCommand = (cmd) => isCommandOfType(cmd, "npmRunScript");
 var isCatCommand = (cmd) => isCommandOfType(cmd, "catCommand");
@@ -661,7 +676,7 @@ function bashOutputIdSync(command, output, cwd = null) {
 }
 function computeBashFingerprints(command, cwd) {
   const fingerprints = {};
-  if (cwd && (isGitMutableCommand(command) || isGitPushCommand(command) || isTestRunnerCommand2(command) || isLintCommand(command) || isBuildCommand(command) || isNpmRunScriptCommand(command))) {
+  if (cwd && (isGitMutableCommand(command) || isGitPushCommand(command) || isTestRunnerCommand(command) || isLintCommand(command) || isBuildCommand(command) || isDevServerCommand(command) || isNpmRunScriptCommand(command))) {
     const fp = gitStateFingerprintSync(cwd);
     if (fp) fingerprints.git = fp;
   }
@@ -846,7 +861,7 @@ function getBashOutput(id) {
 }
 registerReset(() => {
   _byId = /* @__PURE__ */ new Map();
-});
+}, { perRequest: true });
 
 export {
   isLockFile,

package/dist/token-goat-chunk-AM5V6GSX.mjs

@@ -0,0 +1,367 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  MSYS_PATH_RE,
+  WSL_PATH_RE,
+  expandShortPath,
+  isUncOrDevicePath,
+  lowercaseDriveLetter,
+  normalizeDarwinSystemAlias
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/path_containment.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isCaseInsensitiveFs() {
+  const o = process.env["TOKEN_GOAT_CASE_INSENSITIVE_FS"];
+  if (o === "1") return true;
+  if (o === "0") return false;
+  return process.platform === "win32" || process.platform === "darwin";
+}
+function foldPath(p) {
+  return isCaseInsensitiveFs() ? foldCase(p) : p;
+}
+function isNodeModulesPath(p) {
+  const check = foldPath(p);
+  return check.includes("/node_modules/") || check.includes("\\node_modules\\");
+}
+function foldCase(s) {
+  return s.toLowerCase();
+}
+function foldCaseForContainment(s) {
+  return s.replace(/[A-Z]/g, (c) => c.toLowerCase());
+}
+function foldPathForContainment(p) {
+  return isCaseInsensitiveFs() ? foldCaseForContainment(p) : p;
+}
+var CYGWIN_PREFIX_RE = /^\/cygdrive\/([a-zA-Z])\/(.*)$/s;
+function normalizeShellDrivePrefix(posixStr) {
+  let m = WSL_PATH_RE.exec(posixStr);
+  if (m) {
+    return `${m[1].toLowerCase()}:/${m[2]}`;
+  }
+  m = CYGWIN_PREFIX_RE.exec(posixStr);
+  if (m) {
+    return `${m[1].toLowerCase()}:/${m[2]}`;
+  }
+  m = MSYS_PATH_RE.exec(posixStr);
+  if (m) {
+    return `${m[1].toLowerCase()}:${m[2] ?? "/"}`;
+  }
+  return posixStr;
+}
+function canonicalize(inputPath, baseDir) {
+  const pathStr = typeof inputPath === "string" ? inputPath : inputPath.pathname;
+  const isWin32 = process.platform === "win32";
+  const base = baseDir ?? process.cwd();
+  const slashed = pathStr.replace(/\\/g, "/");
+  let pre = isWin32 ? normalizeShellDrivePrefix(slashed) : slashed;
+  if (pre !== slashed) {
+    pre = (isWin32 ? path.win32.resolve : path.resolve)(base, pre);
+  } else {
+    pre = (isWin32 ? path.win32.resolve : path.resolve)(base, pathStr);
+  }
+  let normalized = pre.replace(/\\/g, "/");
+  if (isWin32) {
+    normalized = normalizeShellDrivePrefix(normalized);
+  }
+  normalized = expandShortPath(normalized);
+  normalized = normalizeDarwinSystemAlias(normalized);
+  normalized = lowercaseDriveLetter(normalized);
+  return normalized;
+}
+var UNRESOLVABLE_PATH = "unresolvable-link-chain";
+var MAX_LINK_HOPS = 40;
+var MAX_RESOLVE_PATH_BYTES = 4096;
+var MAX_WALK_SEGMENTS = MAX_RESOLVE_PATH_BYTES * (MAX_LINK_HOPS + 1);
+function rootAndSegments(p) {
+  const parts = p.replace(/\\/g, "/").split("/");
+  const up = parts.indexOf("..");
+  const head = up === -1 ? parts.join("/") : parts.slice(0, up).join("/");
+  const canon = canonicalize(head === "" ? "." : head);
+  const m = /^(\/\/[^/]+\/[^/]+|[a-z]:\/|\/)/i.exec(canon);
+  const root = m === null ? "/" : m[1];
+  const rest = canon.slice(root.length).split("/");
+  return { root, segs: up === -1 ? rest : [...rest, ...parts.slice(up)] };
+}
+function joinSegment(base, seg) {
+  return base.endsWith("/") ? base + seg : `${base}/${seg}`;
+}
+function parentSegment(base, root) {
+  const cut = base.lastIndexOf("/");
+  return cut < root.length ? root : base.slice(0, cut);
+}
+var DRIVE_RELATIVE_PATH = /^[a-z]:(?![\\/])/i;
+function linkTarget(link) {
+  const raw = link.replace(/\\/g, "/").replace(/^\/\/\?\/(UNC\/)?/i, (_m, unc) => unc === void 0 ? "" : "//");
+  if (!/^(\/\/[^/]+\/|[a-z]:\/|\/)/i.test(raw)) return { root: null, segs: raw.split("/") };
+  const abs = rootAndSegments(raw);
+  return { root: abs.root, segs: abs.segs };
+}
+function resolveThroughLinks(p) {
+  if (Buffer.byteLength(p, "utf8") > MAX_RESOLVE_PATH_BYTES) return UNRESOLVABLE_PATH;
+  const start = rootAndSegments(p);
+  let root = start.root;
+  let base = root;
+  const stack = start.segs.slice().reverse();
+  let hops = 0;
+  let walked = 0;
+  while (stack.length > 0) {
+    if (++walked > MAX_WALK_SEGMENTS) return UNRESOLVABLE_PATH;
+    const seg = stack.pop();
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      base = parentSegment(base, root);
+      continue;
+    }
+    const candidate = joinSegment(base, seg);
+    if (Buffer.byteLength(candidate, "utf8") > MAX_RESOLVE_PATH_BYTES) return UNRESOLVABLE_PATH;
+    let link = null;
+    try {
+      if (fs.lstatSync(candidate).isSymbolicLink()) link = fs.readlinkSync(candidate);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") return UNRESOLVABLE_PATH;
+      link = null;
+    }
+    if (link === null) {
+      base = candidate;
+      continue;
+    }
+    if (++hops > MAX_LINK_HOPS) return UNRESOLVABLE_PATH;
+    if (DRIVE_RELATIVE_PATH.test(link)) return UNRESOLVABLE_PATH;
+    const target = linkTarget(link);
+    if (target.root !== null) {
+      if (!isUncOrDevicePath(root) && isUncOrDevicePath(target.root)) return UNRESOLVABLE_PATH;
+      root = target.root;
+      base = target.root;
+    }
+    for (let i = target.segs.length - 1; i >= 0; i--) stack.push(target.segs[i]);
+  }
+  return base;
+}
+function normalizeForFs(p) {
+  return process.platform === "darwin" ? p.normalize("NFC") : p;
+}
+function escapesOntoNetworkThroughLinks(target, cwd) {
+  if (isUncOrDevicePath(target)) return true;
+  let absolute;
+  try {
+    absolute = path.resolve(cwd ?? process.cwd(), target);
+  } catch {
+    return true;
+  }
+  if (isUncOrDevicePath(absolute)) return true;
+  const resolved = resolveThroughLinks(absolute);
+  return resolved === UNRESOLVABLE_PATH || isUncOrDevicePath(resolved);
+}
+function isInsideRoot(target, root) {
+  if (reachesForeignShare(target, root)) return false;
+  const rt = resolveThroughLinks(target);
+  const rr = resolveThroughLinks(root);
+  if (rt === UNRESOLVABLE_PATH || rr === UNRESOLVABLE_PATH) return false;
+  const nt = normalizeForFs(rt);
+  const nr = normalizeForFs(rr);
+  const t = foldPathForContainment(nt);
+  const r = foldPathForContainment(nr);
+  if (t !== r && !t.startsWith(r.endsWith("/") ? r : r + "/")) return false;
+  if (nt.slice(0, nr.length) === nr) return true;
+  return sameDirectory(nt.slice(0, nr.length), nr);
+}
+function isNetworkPath(p, platform = process.platform) {
+  return networkShareRoot(p, platform) !== null;
+}
+function networkShareRoot(p, platform = process.platform) {
+  if (platform !== "win32") return null;
+  const device = /^[\\/]{2}([?.][\\/])?/.exec(p);
+  if (device === null) return null;
+  let rest = p.slice(device[0].length);
+  if (device[1] !== void 0) {
+    const unc = /^UNC[\\/]/i.exec(rest);
+    if (unc === null) return null;
+    rest = rest.slice(unc[0].length);
+  }
+  const [host = "", share = ""] = rest.split(/[\\/]/);
+  return `//${foldCase(host)}/${foldCase(share)}`;
+}
+function reachesForeignShare(target, root, platform = process.platform) {
+  const share = networkShareRoot(target, platform);
+  return share !== null && share !== networkShareRoot(root, platform);
+}
+function sameDirectory(a, b, platform = process.platform) {
+  if (isNetworkPath(a, platform) || isNetworkPath(b, platform)) return false;
+  let canonicalRoot;
+  try {
+    canonicalRoot = fs.realpathSync.native(b);
+  } catch {
+    return true;
+  }
+  try {
+    return fs.realpathSync.native(a) === canonicalRoot;
+  } catch {
+    return false;
+  }
+}
+
+// src/process_util.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+import { existsSync, realpathSync as realpathSync2, statSync } from "node:fs";
+import * as path2 from "node:path";
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function windowsCmdQuoteArg(arg) {
+  if (arg === "") return '""';
+  if (arg[0] === '"' && arg[arg.length - 1] === '"') {
+    throw new Error(`windowsCmdQuoteArg: cannot faithfully encode an argument that both starts and ends with a literal double quote for cmd.exe: ${JSON.stringify(arg)}`);
+  }
+  let out = "";
+  let inQuote = false;
+  let backslashes = 0;
+  const flushBackslashesPlain = () => {
+    if (backslashes > 0) {
+      out += "\\".repeat(backslashes);
+      backslashes = 0;
+    }
+  };
+  const flushBackslashesDoubled = () => {
+    out += "\\".repeat(backslashes * 2);
+    backslashes = 0;
+  };
+  const ensureQuoteOpen = () => {
+    if (!inQuote) {
+      flushBackslashesDoubled();
+      out += '"';
+      inQuote = true;
+    } else {
+      flushBackslashesPlain();
+    }
+  };
+  const ensureQuoteClosed = () => {
+    if (inQuote) {
+      flushBackslashesDoubled();
+      out += '"';
+      inQuote = false;
+    } else {
+      flushBackslashesPlain();
+    }
+  };
+  for (const ch of arg) {
+    if (ch === "\\") {
+      backslashes++;
+      continue;
+    }
+    if (ch === '"') {
+      flushBackslashesDoubled();
+      if (inQuote) {
+        out += '"';
+        inQuote = false;
+      }
+      out += '\\^"';
+      continue;
+    }
+    if (ch === "%" || ch === "!") {
+      ensureQuoteClosed();
+      out += `^${ch}`;
+      continue;
+    }
+    ensureQuoteOpen();
+    out += ch;
+  }
+  ensureQuoteClosed();
+  return out;
+}
+function quoteShellPath(value) {
+  if (process.platform === "win32") return `"${value}"`;
+  return `"${value.replace(/[\\$`"]/g, "\\$&")}"`;
+}
+function quotePosixShellWord(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function quotePowershellPath(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+var POWERSHELL_EXIT_SUFFIX = "; if (Get-Variable LASTEXITCODE -ErrorAction Ignore) { exit (Get-Variable LASTEXITCODE -ValueOnly) }; exit 1";
+function powershellHookLine(call) {
+  return `& ${call}${POWERSHELL_EXIT_SUFFIX}`;
+}
+function resolveOnPath(label) {
+  if (path2.isAbsolute(label)) return existsSync(label) ? label : null;
+  if (label.includes("/") || label.includes("\\")) return null;
+  const onWindows = process.platform === "win32";
+  const exts = onWindows ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((e) => e.trim() !== "") : [""];
+  let cwd;
+  try {
+    cwd = realpathSync2(process.cwd());
+  } catch {
+    cwd = path2.resolve(process.cwd());
+  }
+  for (const rawDir of (process.env["PATH"] ?? "").split(path2.delimiter)) {
+    const dir = rawDir.trim().replace(/^"|"$/g, "");
+    if (dir === "" || dir === ".") continue;
+    let resolvedDir;
+    try {
+      resolvedDir = realpathSync2(path2.resolve(dir));
+    } catch {
+      continue;
+    }
+    if (foldPath(resolvedDir) === foldPath(cwd)) continue;
+    for (const ext of exts) {
+      const candidate = path2.join(resolvedDir, label + ext);
+      try {
+        if (statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function spawnResolvedSync(resolved, args, options) {
+  if (!isWindows() || !/\.(?:cmd|bat)$/i.test(resolved)) return spawnSync(resolved, args, options);
+  const comspec = path2.join(process.env["SystemRoot"] ?? process.env["windir"] ?? "C:\\Windows", "System32", "cmd.exe");
+  const line = [resolved, ...args].map(windowsCmdQuoteArg).join(" ");
+  return spawnSync(existsSync(comspec) ? comspec : "cmd.exe", ["/d", "/s", "/c", `"${line}"`], { ...options, windowsVerbatimArguments: true });
+}
+function installEpipeGuard(streams) {
+  const targets = (streams ?? [process.stdout, process.stderr]).filter((s) => s !== void 0);
+  for (const stream of targets) {
+    stream.on("error", (err) => {
+      if (err.code === "EPIPE") {
+        process.exitCode = 0;
+        return;
+      }
+      throw err;
+    });
+  }
+  return targets;
+}
+
+export {
+  isCaseInsensitiveFs,
+  foldPath,
+  isNodeModulesPath,
+  foldCase,
+  foldCaseForContainment,
+  foldPathForContainment,
+  canonicalize,
+  escapesOntoNetworkThroughLinks,
+  isInsideRoot,
+  sleepSync,
+  isWindows,
+  quoteShellPath,
+  quotePosixShellWord,
+  quotePowershellPath,
+  powershellHookLine,
+  resolveOnPath,
+  spawnResolvedSync,
+  installEpipeGuard
+};