token-goat 2.9.28 → 2.9.30

package/dist/{token-goat-chunk-L45ZQRT7.mjs → token-goat-chunk-GOLEOXZP.mjs}

@@ -1,735 +1,497 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
-  MSYS_PATH_RE,
-  WSL_PATH_RE,
-  expandShortPath,
-  isUncOrDevicePath,
-  lowercaseDriveLetter,
-  normalizeDarwinSystemAlias,
+  foldPath,
+  isInsideRoot,
+  quotePowershellPath,
+  quoteShellPath,
+  sleepSync
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
   normalizePath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
-  compileGuardedRegex
-} from "./token-goat-chunk-GMOUBOX4.mjs";
+  dataDir,
+  ensureStorageRootPrivate,
+  isTokenGoatStorage
+} from "./token-goat-chunk-VES7EL7O.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
 
-// src/version.ts
+// src/bridges/created_configs.ts
 init_define_import_meta_env();
-import { createRequire } from "node:module";
-function resolveVersion() {
-  if (true) {
-    return "2.9.28";
-  }
-  const require2 = createRequire(import.meta.url);
-  const pkg = require2("../package.json");
-  return pkg.version ?? "0.0.0";
-}
-var VERSION = resolveVersion();
-function resolvePackageName() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const pkg = require2("../package.json");
-    if (typeof pkg.name === "string" && pkg.name !== "") return pkg.name;
-  } catch {
-  }
-  return "token-goat";
-}
-var PACKAGE_NAME = resolvePackageName();
-function resolveIssuesUrl() {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const pkg = require2("../package.json");
-    if (typeof pkg.bugs?.url === "string" && pkg.bugs.url !== "") return pkg.bugs.url;
-  } catch {
-  }
-  return "https://github.com/DFKHelper/token-goat/issues";
-}
-var ISSUES_URL = resolveIssuesUrl();
-var SUPPORT_EMAIL = "token-goat@dfkhelper.com";
-function supportRequestLine(what) {
-  return `To ask for ${what} support, open an issue at ${ISSUES_URL} or email ${SUPPORT_EMAIL}.`;
-}
+import * as fs from "fs";
+import * as path4 from "path";
+
+// src/util.ts
+init_define_import_meta_env();
+import { chmodSync, closeSync, constants as fsConstants, copyFileSync, existsSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync as readFileSync2, readlinkSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
+import * as path3 from "node:path";
 
-// src/constants.ts
+// src/bridges/project_scope_guard.ts
 init_define_import_meta_env();
-import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-function safeEnvDir(value) {
-  const stripped = value.trim();
-  if (stripped === "") return void 0;
-  if (!path.isAbsolute(stripped)) return void 0;
-  if (process.platform === "win32") {
-    const root = path.parse(stripped).root;
-    if (root === "" || root === "\\" || root === "/") return void 0;
-  }
-  return stripped;
-}
-function dataDirForHome(homeDir) {
-  const platform = process.platform;
-  if (platform === "win32") {
-    return path.join(homeDir, "AppData", "Local", "dfk-helper", "token-goat");
-  }
-  if (platform === "darwin") {
-    return path.join(homeDir, "Library", "Application Support", "token-goat");
-  }
-  return path.join(homeDir, ".local", "share", "token-goat");
-}
-function homeFallbackOrGuard() {
-  const inVitest = process.env["VITEST_WORKER_ID"] !== void 0 || process.env["VITEST"] === "true";
-  if (inVitest && process.env["VITEST_ALLOW_REAL_DATA_DIR"] !== "1") {
-    throw new Error(
-      "token-goat: refusing to resolve DATA_DIR against the real home directory inside a Vitest worker (LOCALAPPDATA/XDG_DATA_HOME is unset). This would read or write the developer's real global.db/config.toml. Set LOCALAPPDATA/XDG_DATA_HOME explicitly for this process, or VITEST_ALLOW_REAL_DATA_DIR=1 if this is an intentional mocked-home test."
-    );
-  }
-  return dataDirForHome(os.homedir());
-}
-function defaultDataDir() {
-  const platform = process.platform;
-  if (platform === "win32") {
-    const raw = process.env["LOCALAPPDATA"] ?? "";
-    const base2 = raw ? safeEnvDir(raw) : void 0;
-    if (base2 !== void 0) {
-      return path.join(base2, "dfk-helper", "token-goat");
-    }
-    return homeFallbackOrGuard();
-  }
-  if (platform === "darwin") {
-    const raw = process.env["XDG_DATA_HOME"] ?? "";
-    const base2 = raw ? safeEnvDir(raw) : void 0;
-    if (base2 !== void 0) {
-      return path.join(base2, "token-goat");
-    }
-    return homeFallbackOrGuard();
-  }
-  const xdg = process.env["XDG_DATA_HOME"] ?? "";
-  const base = xdg ? safeEnvDir(xdg) : void 0;
-  if (base !== void 0) {
-    return path.join(base, "token-goat");
-  }
-  return homeFallbackOrGuard();
-}
-var DATA_DIR = defaultDataDir();
-function dataDir() {
-  return DATA_DIR;
+function assertProjectScopeTarget(target, projectRoot) {
+  if (projectRoot === void 0) return;
+  if (isInsideRoot(target, projectRoot)) return;
+  throw new Error(
+    `refusing to touch ${target}: it resolves outside the project (${projectRoot}). A repository can check a config path in as a symlink to a private file, and installing over it would read and back up that file's contents into the working tree. Remove the link, or run the install with --user.`
+  );
 }
-var dataDirHardened = false;
-function ensureDataDirPrivate() {
-  if (dataDirHardened) return;
+var installProjectRoot;
+function withInstallScope(projectRoot, fn) {
+  const previous = installProjectRoot;
+  installProjectRoot = projectRoot === void 0 ? void 0 : path.resolve(projectRoot);
   try {
-    fs.mkdirSync(path.dirname(DATA_DIR), { recursive: true });
-    fs.mkdirSync(DATA_DIR, { recursive: true, mode: 448 });
-    if (process.platform !== "win32") {
-      const current = fs.statSync(DATA_DIR).mode & 511;
-      if ((current & 63) !== 0) fs.chmodSync(DATA_DIR, 448);
+    const result = fn();
+    if (typeof result?.then === "function") {
+      throw new Error(
+        "withInstallScope was given a function that returned a thenable. The install scope is held in a module-level variable and restored synchronously, so an async installer would run every write after its first await with containment already switched off. Make the installer synchronous, or move the scope to AsyncLocalStorage first."
+      );
     }
-    dataDirHardened = true;
-  } catch {
+    return result;
+  } finally {
+    installProjectRoot = previous;
   }
 }
-function tokenGoatHome() {
-  const override = safeEnvDir(process.env["TOKEN_GOAT_HOME"] ?? "");
-  if (override !== void 0) return override;
-  return path.join(os.homedir(), ".token-goat");
+function projectScopeRoot(opts) {
+  if (opts === void 0) return void 0;
+  if (opts.project !== true && opts.local !== true) return void 0;
+  return path.resolve(opts.projectRoot ?? process.cwd());
 }
-var hardenedHomes = /* @__PURE__ */ new Set();
-function ensureHomeDirPrivate() {
-  const home = tokenGoatHome();
-  if (hardenedHomes.has(home)) return;
-  try {
-    fs.mkdirSync(path.dirname(home), { recursive: true });
-    fs.mkdirSync(home, { recursive: true, mode: 448 });
-    if (process.platform !== "win32") {
-      const current = fs.statSync(home).mode & 511;
-      if ((current & 63) !== 0) fs.chmodSync(home, 448);
-    }
-    hardenedHomes.add(home);
-  } catch {
-  }
+function assertWriteInScope(target) {
+  const root = installProjectRoot;
+  if (root === void 0) return;
+  if (isTokenGoatStorage(target)) return;
+  assertProjectScopeTarget(target, root);
 }
-function isUnderRoot(child, parent) {
-  const rel = path.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
-}
-function isTokenGoatStorage(p) {
-  return isUnderRoot(p, DATA_DIR) || isUnderRoot(p, tokenGoatHome());
-}
-function ensureStorageRootPrivate(dir) {
-  if (isUnderRoot(dir, DATA_DIR)) ensureDataDirPrivate();
-  if (isUnderRoot(dir, tokenGoatHome())) ensureHomeDirPrivate();
-}
-function globalDbPath() {
-  return path.join(DATA_DIR, "global.db");
-}
-function configPath() {
-  return path.join(DATA_DIR, "config.toml");
-}
-var PROJECT_CONFIG_FILENAME = ".token-goat.toml";
-function projectConfigPath(projectRoot) {
-  return path.join(projectRoot, PROJECT_CONFIG_FILENAME);
-}
-var ENV_KEYS = {
-  COMPACT_ASSIST: "TOKEN_GOAT_COMPACT_ASSIST",
-  COMPACT_ASSIST_LEGACY: "TOKENWISE_COMPACT_ASSIST",
-  BASH_COMPRESS: "TOKEN_GOAT_BASH_COMPRESS",
-  SESSION_BRIEF: "TOKEN_GOAT_SESSION_BRIEF",
-  SKILL_PRESERVATION: "TOKEN_GOAT_SKILL_PRESERVATION",
-  ORPHAN_SWEEP: "TOKEN_GOAT_ORPHAN_SWEEP",
-  HINT_BUDGET: "TOKEN_GOAT_HINT_BUDGET",
-  HINT_JSON_SIDECAR: "TOKEN_GOAT_HINT_JSON_SIDECAR",
-  BASH_DEDUP_MIN_BYTES: "TOKEN_GOAT_BASH_DEDUP_MIN_BYTES",
-  WEB_DEDUP_MIN_BYTES: "TOKEN_GOAT_WEB_DEDUP_MIN_BYTES",
-  GREP_DEDUP_MIN_MATCHES: "TOKEN_GOAT_GREP_DEDUP_MIN_MATCHES",
-  GLOB_DEDUP_MIN_MATCHES: "TOKEN_GOAT_GLOB_DEDUP_MIN_MATCHES",
-  LARGE_READ_BYTES: "TOKEN_GOAT_LARGE_READ_BYTES",
-  REPOMAP_COMPACT_THRESHOLD: "TOKEN_GOAT_REPOMAP_COMPACT_THRESHOLD",
-  WEB_CACHE_MAX_FILES: "TOKEN_GOAT_WEB_CACHE_MAX_FILES",
-  WEB_CACHE_MAX_BYTES: "TOKEN_GOAT_WEB_CACHE_MAX_BYTES",
-  WEB_COMPRESS: "TOKEN_GOAT_WEB_COMPRESS",
-  BASH_CACHE_MIN_BYTES: "TOKEN_GOAT_BASH_CACHE_MIN_BYTES",
-  BASH_CACHE_MAX_FILES: "TOKEN_GOAT_BASH_CACHE_MAX_FILES",
-  BASH_CACHE_MAX_BYTES: "TOKEN_GOAT_BASH_CACHE_MAX_BYTES",
-  BASH_CACHE_MAX_BYTES_PER_OUTPUT: "TOKEN_GOAT_BASH_CACHE_MAX_BYTES_PER_OUTPUT",
-  WORKER_WATCHDOG: "TOKEN_GOAT_WORKER_WATCHDOG",
-  WORKER_MAX_POOL: "TOKEN_GOAT_WORKER_MAX_POOL",
-  COMPRESS_PROFILE: "TOKEN_GOAT_COMPRESS_PROFILE",
-  SKILL_COMPRESS: "TOKEN_GOAT_SKILL_COMPRESS",
-  SERVE_DIFF_ON_REREAD: "TOKEN_GOAT_SERVE_DIFF_ON_REREAD",
-  ELIDE_SERVED_LINES: "TOKEN_GOAT_ELIDE_SERVED_LINES",
-  OVERFLOW_GUARD: "TOKEN_GOAT_OVERFLOW_GUARD",
-  OVERFLOW_MAX_TOKENS: "TOKEN_GOAT_OVERFLOW_MAX_TOKENS",
-  HARNESS_OVERRIDE: "TOKEN_GOAT_HARNESS_OVERRIDE",
-  RECONCILE: "TOKEN_GOAT_RECONCILE",
-  RECONCILE_BUDGET_MS: "TOKEN_GOAT_RECONCILE_BUDGET_MS",
-  MCP_TOOLS: "TOKEN_GOAT_MCP_TOOLS"
-};
-var SYMBOL_BODY_CHAR_CAP = 128 * 1024;
-var SKELETON_SYMBOL_CAP = 5e3;
+function projectPathIsConsultable(target, projectRoot) {
+  return isInsideRoot(target, projectRoot);
+}
+
+// src/util.ts
+import { spawnSync } from "node:child_process";
 
-// src/path_containment.ts
+// src/regex_guard.ts
 init_define_import_meta_env();
-import * as fs2 from "node:fs";
-import * as path2 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 ? path2.win32.resolve : path2.resolve)(base, pre);
-  } else {
-    pre = (isWin32 ? path2.win32.resolve : path2.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 (fs2.lstatSync(candidate).isSymbolicLink()) link = fs2.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 = path2.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);
+var GROUP_PREFIX = String.raw`\((?:\?(?::|<?[=!]|<\w+>|[a-z]*(?:-[a-z]*)?:))?`;
+var NESTED_QUANTIFIER = new RegExp(GROUP_PREFIX + String.raw`[^()*+]*(?:[*+]|\{\d+,\d*\})[^()]*\)\s*(?:[*+]|\{\d+,\d*\})`);
+function hasNestedQuantifier(source) {
+  return NESTED_QUANTIFIER.test(source);
+}
+var PROBE_ALPHABETS = ["a", "0", "a0"];
+var PROBE_STEP = 4;
+var PROBE_MAX_LENGTH = 512;
+var PROBE_LENGTHS = Array.from({ length: PROBE_MAX_LENGTH / PROBE_STEP }, (_, i) => (i + 1) * PROBE_STEP);
+var PROJECTED_LINE_LENGTH = 1e4;
+var PROJECTION_BUDGET_MS = 1e3;
+var TIMING_SIGNAL_MS = 1;
+var PROBE_GROWTH_FACTOR = 12;
+function climbsBetweenRungs(previous, elapsed) {
+  return previous !== void 0 && elapsed > TIMING_SIGNAL_MS && elapsed > previous * PROBE_GROWTH_FACTOR;
+}
+var PROBE_TERMINATORS = ["!", "a", "0", " ", "\uFFFF", "\n", "\u2028"];
+var PROBE_BUDGET_MS = 25;
+var LINEAR_BY_CONSTRUCTION_EXCLUDES = /[*+?{|]/;
+var MAX_COUNTED_REPEAT = 8;
+var LITERAL_RUN_ATOM = /[^\\()[\]{}|^$*+?]/;
+var QUANTIFIER_AT = /^[*+?{]/;
+function timeMatch(re, input) {
+  const probe = new RegExp(re.source, re.flags.replace("g", ""));
+  const started = performance.now();
+  const matched = probe.test(input);
+  const first = performance.now() - started;
+  if (first <= TIMING_SIGNAL_MS) return { ms: first, matched };
+  const again = new RegExp(re.source, re.flags.replace("g", ""));
+  const restarted = performance.now();
+  again.test(input);
+  return { ms: Math.min(first, performance.now() - restarted), matched };
+}
+function confirmed(re, input, first) {
+  const again = timeMatch(re, input);
+  return again.ms < first.ms ? { ms: again.ms, matched: first.matched } : first;
+}
+function remeasuredForProjection(re, timings, inputs) {
+  const hi = timings.length - 1;
+  const hiLength = PROBE_LENGTHS[hi];
+  const lo = hiLength === void 0 ? -1 : PROBE_LENGTHS.findIndex((l) => l * 2 >= hiLength);
+  const out = [...timings];
+  for (const i of /* @__PURE__ */ new Set([lo, hi])) {
+    const input = inputs[i];
+    const ms = out[i];
+    if (input !== void 0 && ms !== void 0) out[i] = Math.min(ms, timeMatch(re, input).ms);
   }
-  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);
+  return out;
 }
-function sameDirectory(a, b, platform = process.platform) {
-  if (isNetworkPath(a, platform) || isNetworkPath(b, platform)) return false;
-  let canonicalRoot;
-  try {
-    canonicalRoot = fs2.realpathSync.native(b);
-  } catch {
-    return true;
-  }
+var ESCAPE_SAMPLES = {
+  s: " ",
+  S: "a",
+  d: "0",
+  D: "a",
+  w: "a",
+  W: "-",
+  t: "	",
+  n: "\n",
+  r: "\r",
+  f: "\f",
+  v: "\v",
+  "0": "\0",
+  b: "",
+  B: ""
+};
+var LOOKAROUND_AT = /^\(\?<?[=!]/;
+var CLASS_CANDIDATES = ["a", "0", " ", "x", "-", "!", "~", "	", "\n", "A", "\xE9", "\u03B1", "\u0434", "\u05D0", "\u0627", "\u4E2D", "\u3042", "\u{1F600}"];
+function firstMatch(source, flags, candidates) {
+  let re;
   try {
-    return fs2.realpathSync.native(a) === canonicalRoot;
+    re = new RegExp(source, flags);
   } catch {
-    return false;
-  }
-}
-
-// src/process_util.ts
-init_define_import_meta_env();
-import { existsSync, realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
-import * as path3 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;
+    return "";
+  }
+  for (const candidate of candidates) if (re.test(candidate)) return candidate;
+  return "";
+}
+function classEnd(source, start) {
+  let i = start + 1;
+  if (source[i] === "^") i++;
+  if (source[i] === "]") i++;
+  for (; i < source.length; i++) {
+    if (source[i] === "\\") {
+      i++;
+      continue;
     }
+    if (source[i] === "]") return i;
+  }
+  return -1;
+}
+var CLASS_SWEEP = [
+  ...Array.from({ length: 95 }, (_, i) => String.fromCharCode(32 + i)),
+  ...Array.from({ length: 1024 }, (_, i) => String.fromCharCode(160 + i * 63))
+];
+var SWEEP_TAILS = CLASS_SWEEP.flatMap((c, i) => {
+  const other = CLASS_SWEEP[(i + 1) % CLASS_SWEEP.length];
+  return [c.repeat(MAX_COUNTED_REPEAT + 1), c.repeat(MAX_COUNTED_REPEAT) + other];
+});
+var MAX_SWEEPS = 3;
+var SWEEP_BUDGET_MS = 150;
+var QUANTIFIED_GROUP = /\)\s*(?:[*+]|\{\d+(?:,\d*)?\})/;
+function sampleClass(cls) {
+  const named = sampleCharacters(cls.slice(1, -1));
+  return firstMatch(cls, "", [...named, ...CLASS_CANDIDATES]) || firstMatch(cls, "", CLASS_SWEEP);
+}
+function sampleCharacters(source) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (c) => {
+    if (c === "" || seen.has(c)) return;
+    seen.add(c);
+    out.push(c);
   };
-  const flushBackslashesDoubled = () => {
-    out += "\\".repeat(backslashes * 2);
-    backslashes = 0;
-  };
-  const ensureQuoteOpen = () => {
-    if (!inQuote) {
-      flushBackslashesDoubled();
-      out += '"';
-      inQuote = true;
-    } else {
-      flushBackslashesPlain();
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (c === "[") {
+      const end = classEnd(source, i);
+      if (end !== -1) {
+        push(sampleClass(source.slice(i, end + 1)));
+        i = end;
+        continue;
+      }
     }
-  };
-  const ensureQuoteClosed = () => {
-    if (inQuote) {
-      flushBackslashesDoubled();
-      out += '"';
-      inQuote = false;
-    } else {
-      flushBackslashesPlain();
+    if (c !== "\\") {
+      if (/[^\s()[\]{}|^$*+?.-]/.test(c)) push(c);
+      continue;
     }
-  };
-  for (const ch of arg) {
-    if (ch === "\\") {
-      backslashes++;
+    const next = source[i + 1] ?? "";
+    i++;
+    if (next >= "0" && next <= "7") {
+      let digits = /^[0-7]{1,3}/.exec(source.slice(i))[0];
+      if (parseInt(digits, 8) > 255) digits = digits.slice(0, 2);
+      push(String.fromCharCode(parseInt(digits, 8)));
+      if (digits.length === 1 && next !== "0") push(next);
+      i += digits.length - 1;
       continue;
     }
-    if (ch === '"') {
-      flushBackslashesDoubled();
-      if (inQuote) {
-        out += '"';
-        inQuote = false;
+    if (next === "x" || next === "u") {
+      if (next === "u" && source[i + 1] === "{") {
+        const close = source.indexOf("}", i + 2);
+        const digits2 = close === -1 ? "" : source.slice(i + 2, close);
+        if (/^[0-9a-fA-F]{1,6}$/.test(digits2)) {
+          push(String.fromCodePoint(parseInt(digits2, 16)));
+          i = close;
+        }
+        continue;
       }
-      out += '\\^"';
+      const width = next === "x" ? 2 : 4;
+      const digits = source.slice(i + 1, i + 1 + width);
+      i += width;
+      if (/^[0-9a-fA-F]+$/.test(digits) && digits.length === width) push(String.fromCharCode(parseInt(digits, 16)));
       continue;
     }
-    if (ch === "%" || ch === "!") {
-      ensureQuoteClosed();
-      out += `^${ch}`;
+    if (next === "c" && /[a-zA-Z]/.test(source[i + 1] ?? "")) {
+      push(String.fromCharCode(source[i + 1].toUpperCase().charCodeAt(0) % 32));
+      i++;
       continue;
     }
-    ensureQuoteOpen();
-    out += ch;
-  }
-  ensureQuoteClosed();
-  return out;
-}
-function quoteShellPath(value) {
-  if (process.platform === "win32") return `"${value}"`;
-  return `"${value.replace(/[\\$`"]/g, "\\$&")}"`;
-}
-function quotePowershellPath(value) {
-  return `'${value.replace(/'/g, "''")}'`;
-}
-function resolveOnPath(label) {
-  if (path3.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 = path3.resolve(process.cwd());
-  }
-  for (const rawDir of (process.env["PATH"] ?? "").split(path3.delimiter)) {
-    const dir = rawDir.trim().replace(/^"|"$/g, "");
-    if (dir === "" || dir === ".") continue;
-    let resolvedDir;
-    try {
-      resolvedDir = realpathSync2(path3.resolve(dir));
-    } catch {
-      continue;
-    }
-    if (foldPath(resolvedDir) === foldPath(cwd)) continue;
-    for (const ext of exts) {
-      const candidate = path3.join(resolvedDir, label + ext);
-      try {
-        if (statSync2(candidate).isFile()) return candidate;
-      } catch {
+    if ((next === "p" || next === "P") && source[i + 1] === "{") {
+      const close = source.indexOf("}", i + 2);
+      if (close !== -1) {
+        push(firstMatch(source.slice(i - 1, close + 1), "u", CLASS_CANDIDATES));
+        i = close;
+        continue;
       }
     }
+    const sample = ESCAPE_SAMPLES[next];
+    push(sample ?? next);
   }
-  return null;
-}
-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;
-}
-
-// src/encoding.ts
-init_define_import_meta_env();
-function stripBom(text) {
-  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
-}
-function detectSourceEncoding(buf) {
-  if (buf.length >= 4) {
-    if (buf[0] === 255 && buf[1] === 254 && buf[2] === 0 && buf[3] === 0) return "utf32le";
-    if (buf[0] === 0 && buf[1] === 0 && buf[2] === 254 && buf[3] === 255) return "utf32be";
-  }
-  if (buf.length >= 2) {
-    if (buf[0] === 255 && buf[1] === 254) return "utf16le";
-    if (buf[0] === 254 && buf[1] === 255) return "utf16be";
-  }
-  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) return "utf8-bom";
-  return "utf8";
-}
-function decodeSource(buf) {
-  switch (detectSourceEncoding(buf)) {
-    case "utf32le":
-      return decodeUtf32(buf.subarray(4), true);
-    case "utf32be":
-      return decodeUtf32(buf.subarray(4), false);
-    case "utf16le":
-      return buf.subarray(2).toString("utf16le");
-    case "utf16be":
-      return swap16(buf.subarray(2)).toString("utf16le");
-    case "utf8-bom":
-      return buf.subarray(3).toString("utf8");
-    default:
-      return buf.toString("utf8");
-  }
-}
-function encodeSource(text, encoding) {
-  switch (encoding) {
-    case "utf32le":
-      return Buffer.concat([Buffer.from([255, 254, 0, 0]), encodeUtf32(text, true)]);
-    case "utf32be":
-      return Buffer.concat([Buffer.from([0, 0, 254, 255]), encodeUtf32(text, false)]);
-    case "utf16le":
-      return Buffer.concat([Buffer.from([255, 254]), Buffer.from(text, "utf16le")]);
-    case "utf16be":
-      return Buffer.concat([Buffer.from([254, 255]), swap16(Buffer.from(text, "utf16le"))]);
-    case "utf8-bom":
-      return Buffer.concat([Buffer.from([239, 187, 191]), Buffer.from(text, "utf8")]);
-    default:
-      return Buffer.from(text, "utf8");
-  }
-}
-function swap16(buf) {
-  const out = Buffer.from(buf);
-  return out.subarray(0, out.length - out.length % 2).swap16();
-}
-function decodeUtf32(buf, littleEndian) {
-  const points = [];
-  for (let i = 0; i + 4 <= buf.length; i += 4) {
-    const cp = littleEndian ? buf.readUInt32LE(i) : buf.readUInt32BE(i);
-    points.push(cp > 1114111 || cp >= 55296 && cp <= 57343 ? 65533 : cp);
-  }
-  return String.fromCodePoint(...points);
-}
-function encodeUtf32(text, littleEndian) {
-  const points = [...text];
-  const out = Buffer.alloc(points.length * 4);
-  points.forEach((ch, i) => {
-    const cp = ch.codePointAt(0) ?? 65533;
-    if (littleEndian) out.writeUInt32LE(cp, i * 4);
-    else out.writeUInt32BE(cp, i * 4);
-  });
   return out;
 }
-
-// src/util.ts
-init_define_import_meta_env();
-import { spawn } from "node:child_process";
-import { chmodSync as chmodSync2, closeSync, constants as fsConstants, copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, readdirSync, readFileSync as readFileSync3, renameSync, rmdirSync, statSync as statSync3, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import * as path7 from "node:path";
-
-// src/bridges/created_configs.ts
-init_define_import_meta_env();
-import * as fs3 from "fs";
-import * as path4 from "path";
-function ledgerPath() {
-  return path4.join(dataDir(), "created-configs.json");
-}
-function keyOf(filePath) {
-  return normalizePath(path4.resolve(filePath));
-}
-function foldKey(key) {
-  return foldPath(key);
-}
-function readLedger() {
-  try {
-    const parsed = JSON.parse(fs3.readFileSync(ledgerPath(), "utf8"));
-    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
-  } catch {
-    return [];
-  }
-}
-function writeLedger(entries) {
-  try {
-    ensureDirSync(path4.dirname(ledgerPath()));
-    atomicWriteText(ledgerPath(), `${JSON.stringify(entries)}
-`);
-  } catch {
-  }
-}
-function recordCreatedConfig(filePath) {
-  const key = keyOf(filePath);
-  const entries = readLedger();
-  if (entries.some((entry) => foldKey(entry) === foldKey(key))) return;
-  writeLedger([...entries, key]);
-}
-function hasCreatedConfig(filePath) {
-  const key = foldKey(keyOf(filePath));
-  return readLedger().some((entry) => foldKey(entry) === key);
-}
-function takeCreatedConfig(filePath) {
-  const key = foldKey(keyOf(filePath));
-  const entries = readLedger();
-  if (!entries.some((entry) => foldKey(entry) === key)) return false;
-  writeLedger(entries.filter((entry) => foldKey(entry) !== key));
-  return true;
-}
-function recordCreatedBackup(backupPath) {
-  recordCreatedConfig(backupPath);
-}
-function forgetCreatedBackup(backupPath) {
-  takeCreatedConfig(backupPath);
-}
-function createdBackupsFor(configPath2) {
-  const prefix = foldKey(`${keyOf(configPath2)}.bak.`);
-  return readLedger().filter((entry) => foldKey(entry).startsWith(prefix)).sort();
-}
-function removeCreatedBackups(configPath2) {
-  const prefix = foldKey(`${keyOf(configPath2)}.bak.`);
-  const entries = readLedger();
-  const ours = entries.filter((entry) => foldKey(entry).startsWith(prefix));
-  if (ours.length === 0) return 0;
-  const failed = /* @__PURE__ */ new Set();
-  let removed = 0;
-  for (const target of ours) {
+var MAX_PATTERN_ALPHABETS = 12;
+function probeAlphabets(source) {
+  const samples = sampleCharacters(source);
+  const counts = /* @__PURE__ */ new Map();
+  for (const ch of source) counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  const counted = samples.map((c, i) => ({ c, i, n: counts.get(c) ?? 0 }));
+  counted.sort((a, b) => b.n - a.n || a.i - b.i);
+  const kept = counted.slice(0, MAX_PATTERN_ALPHABETS).map((s) => s.c);
+  const extra = kept.length > 1 ? [kept.join("")] : [];
+  return [...PROBE_ALPHABETS, ...kept, ...extra];
+}
+function growsExponentially(re) {
+  const relaxed = detune(re.source);
+  if (relaxed === null || !relaxed.hadLookaround) {
+    const cause = climbsPastBudget(re);
+    if (cause !== null) return cause;
+  }
+  if (relaxed === null) return null;
+  for (const body of relaxed.negativeBodies) {
+    let inner;
     try {
-      if (fs3.existsSync(target) && removeFileInScope(target)) {
-        removed++;
-      }
+      inner = new RegExp(body, re.flags);
     } catch {
-      failed.add(target);
+      continue;
     }
+    const innerCause = growsExponentially(inner);
+    if (innerCause !== null) return innerCause;
   }
-  writeLedger(entries.filter((entry) => !ours.includes(entry) || failed.has(entry)));
-  return removed;
-}
-
-// src/bridges/project_scope_guard.ts
-init_define_import_meta_env();
-import * as path5 from "node:path";
-function assertProjectScopeTarget(target, projectRoot) {
-  if (projectRoot === void 0) return;
-  if (isInsideRoot(target, projectRoot)) return;
-  throw new Error(
-    `refusing to touch ${target}: it resolves outside the project (${projectRoot}). A repository can check a config path in as a symlink to a private file, and installing over it would read and back up that file's contents into the working tree. Remove the link, or run the install with --user.`
-  );
-}
-var installProjectRoot;
-function withInstallScope(projectRoot, fn) {
-  const previous = installProjectRoot;
-  installProjectRoot = projectRoot === void 0 ? void 0 : path5.resolve(projectRoot);
+  let widened;
   try {
-    const result = fn();
-    if (typeof result?.then === "function") {
-      throw new Error(
-        "withInstallScope was given a function that returned a thenable. The install scope is held in a module-level variable and restored synchronously, so an async installer would run every write after its first await with containment already switched off. Make the installer synchronous, or move the scope to AsyncLocalStorage first."
-      );
+    widened = new RegExp(relaxed.source, re.flags);
+  } catch {
+    return null;
+  }
+  return growsExponentially(widened);
+}
+function climbsPastBudget(re) {
+  const probe = new RegExp(re.source, re.flags.replace("g", ""));
+  let sweptMs = 0;
+  let falsified = false;
+  for (const alphabet of probeAlphabets(re.source)) {
+    let sweeps = 0;
+    const body = (n) => alphabet.repeat(Math.ceil(n / alphabet.length)).slice(0, n);
+    const tail = PROBE_TERMINATORS.find((t) => !probe.test(body(PROBE_STEP) + t)) ?? PROBE_TERMINATORS[0];
+    const candidates = [tail, ...PROBE_TERMINATORS.filter((t) => t !== tail)];
+    let swept;
+    const timings = [];
+    const inputs = [];
+    let previous;
+    for (const length of PROBE_LENGTHS) {
+      let failing;
+      let last;
+      let failingInput = "";
+      let lastInput = "";
+      const attempt = (candidate) => {
+        const input = body(length) + candidate;
+        let m = timeMatch(re, input);
+        if (m.ms > PROBE_BUDGET_MS) m = confirmed(re, input, m);
+        last = m;
+        lastInput = input;
+        if (m.ms > PROBE_BUDGET_MS) return "over-budget";
+        if (!m.matched) {
+          failing = m;
+          failingInput = input;
+        }
+        return m;
+      };
+      for (const candidate of swept === void 0 ? candidates : [swept, ...candidates]) {
+        if (attempt(candidate) === "over-budget") return "over-budget";
+        if (failing !== void 0) break;
+      }
+      if (failing === void 0 && sweeps < MAX_SWEEPS && sweptMs < SWEEP_BUDGET_MS) {
+        sweeps++;
+        const sweepStarted = Date.now();
+        for (const candidate of SWEEP_TAILS) {
+          if (attempt(candidate) === "over-budget") return "over-budget";
+          if (failing !== void 0) {
+            swept = candidate;
+            break;
+          }
+        }
+        sweptMs += Date.now() - sweepStarted;
+      }
+      if (failing !== void 0) falsified = true;
+      let elapsed = (failing ?? last).ms;
+      const rungInput = failing !== void 0 ? failingInput : lastInput;
+      if (climbsBetweenRungs(previous, elapsed)) {
+        elapsed = confirmed(re, rungInput, { ms: elapsed, matched: false }).ms;
+        if (climbsBetweenRungs(previous, elapsed)) return "ratio";
+      }
+      previous = elapsed;
+      timings.push(elapsed);
+      inputs.push(rungInput);
     }
-    return result;
-  } finally {
-    installProjectRoot = previous;
+    if (projectsPastBudget(timings) && projectsPastBudget(remeasuredForProjection(re, timings, inputs))) return "projection";
   }
+  if (!falsified && QUANTIFIED_GROUP.test(re.source)) return "unfalsifiable";
+  return null;
 }
-function projectScopeRoot(opts) {
-  if (opts === void 0) return void 0;
-  if (opts.project !== true && opts.local !== true) return void 0;
-  return path5.resolve(opts.projectRoot ?? process.cwd());
-}
-function assertWriteInScope(target) {
-  const root = installProjectRoot;
-  if (root === void 0) return;
-  if (isTokenGoatStorage(target)) return;
-  assertProjectScopeTarget(target, root);
+function groupEnd(source, start) {
+  let depth = 0;
+  let inClass = false;
+  for (let i = start; i < source.length; i++) {
+    const c = source[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") inClass = true;
+    else if (c === "(") depth++;
+    else if (c === ")" && --depth === 0) return i;
+  }
+  return -1;
 }
-function projectPathIsConsultable(target, projectRoot) {
-  return isInsideRoot(target, projectRoot);
+function detune(source) {
+  let out = "";
+  let changed = false;
+  let hadLookaround = false;
+  const negativeBodies = [];
+  let inClass = false;
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i];
+    if (c === "\\") {
+      out += c + (source[i + 1] ?? "");
+      i++;
+      continue;
+    }
+    if (inClass) {
+      out += c;
+      if (c === "]") inClass = false;
+      continue;
+    }
+    if (c === "[") {
+      out += c;
+      inClass = true;
+      continue;
+    }
+    if (c === "{") {
+      const counted = /^\{(\d+)(,(\d*))?\}/.exec(source.slice(i));
+      if (counted !== null) {
+        const min = Math.min(parseInt(counted[1], 10), MAX_COUNTED_REPEAT);
+        const upper = counted[3];
+        const max = upper === void 0 || upper === "" ? "" : String(Math.min(parseInt(upper, 10), MAX_COUNTED_REPEAT));
+        const rebuilt = counted[2] === void 0 ? `{${min}}` : `{${min},${max}}`;
+        if (rebuilt !== counted[0]) changed = true;
+        out += rebuilt;
+        i += counted[0].length - 1;
+        continue;
+      }
+    }
+    if (c === "(" && LOOKAROUND_AT.test(source.slice(i, i + 4))) {
+      const end = groupEnd(source, i);
+      if (end === -1) return null;
+      const behind = source[i + 2] === "<";
+      const negative = source[i + (behind ? 3 : 2)] === "!";
+      const body = source.slice(i + (behind ? 4 : 3), end);
+      if (negative) negativeBodies.push(body);
+      else out += `(?:${body})`;
+      i = end;
+      changed = true;
+      hadLookaround = true;
+      continue;
+    }
+    if (LITERAL_RUN_ATOM.test(c)) {
+      let run = 1;
+      while (source[i + run] === c) run++;
+      const quantified = QUANTIFIER_AT.test(source.slice(i + run, i + run + 1));
+      const collapsible = quantified ? run - 1 : run;
+      if (collapsible > MAX_COUNTED_REPEAT) {
+        out += c.repeat(MAX_COUNTED_REPEAT) + (quantified ? c : "");
+        i += run - 1;
+        changed = true;
+        continue;
+      }
+    }
+    out += c;
+  }
+  return changed ? { source: out, hadLookaround, negativeBodies } : null;
+}
+function projectsPastBudget(timings) {
+  const hi = timings.length - 1;
+  const hiLength = PROBE_LENGTHS[hi];
+  if (hiLength === void 0) return false;
+  const lo = PROBE_LENGTHS.findIndex((l) => l * 2 >= hiLength);
+  const loLength = PROBE_LENGTHS[lo];
+  const top = timings[hi];
+  const prior = timings[lo];
+  if (top === void 0 || prior === void 0 || loLength === void 0 || loLength >= hiLength) return false;
+  if (top <= TIMING_SIGNAL_MS || prior <= 0) return false;
+  const exponent = Math.log2(top / prior) / Math.log2(hiLength / loLength);
+  return top * (PROJECTED_LINE_LENGTH / hiLength) ** exponent > PROJECTION_BUDGET_MS;
+}
+var MAX_PATTERN_LENGTH = 4096;
+function compileGuardedRegex(pattern, flags = "") {
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    return { ok: false, reason: `is longer than ${MAX_PATTERN_LENGTH} characters, which is past what can be checked for a stall` };
+  }
+  let re;
+  try {
+    re = new RegExp(pattern, flags);
+  } catch (e) {
+    return { ok: false, reason: e instanceof Error ? e.message : "is not a valid regular expression" };
+  }
+  if (!LINEAR_BY_CONSTRUCTION_EXCLUDES.test(pattern)) return { ok: true, re };
+  const cause = growsExponentially(re);
+  if (cause !== null) {
+    return {
+      ok: false,
+      reason: hasNestedQuantifier(pattern) ? "repeats a group that already repeats, which can take exponential time to match" : "takes time that climbs steeply with the length of the line, which can stall on ordinary text",
+      cause
+    };
+  }
+  return { ok: true, re };
+}
+var GUARDED_CACHE_LIMIT = 64;
+var guardedCache = /* @__PURE__ */ new Map();
+function compileGuardedRegexCached(pattern, flags = "") {
+  const key = `${flags}/${pattern}`;
+  const hit = guardedCache.get(key);
+  if (hit !== void 0) return hit;
+  const result = compileGuardedRegex(pattern, flags);
+  if (guardedCache.size >= GUARDED_CACHE_LIMIT) {
+    const oldest = guardedCache.keys().next();
+    if (!oldest.done) guardedCache.delete(oldest.value);
+  }
+  guardedCache.set(key, result);
+  return result;
 }
 
-// src/util.ts
-import { spawnSync } from "node:child_process";
-
 // src/util_config.ts
 init_define_import_meta_env();
-import { readFileSync as readFileSync2 } from "node:fs";
-import * as path6 from "node:path";
+import { readFileSync } from "node:fs";
+import * as path2 from "node:path";
+function commandHookFields(h) {
+  if (typeof h?.command !== "string") return void 0;
+  const args = Array.isArray(h.args) && h.args.every((a) => typeof a === "string") ? h.args : void 0;
+  return { command: h.command, args };
+}
+function isOwnHookEntry(h, isOurs) {
+  const fields = commandHookFields(h);
+  return fields !== void 0 && isOurs(fields.command, fields.args);
+}
 function stripOwnHooksFromMap(hooks, isOurs) {
   let removed = false;
   for (const eventKey of Object.keys(hooks)) {
@@ -738,7 +500,7 @@ function stripOwnHooksFromMap(hooks, isOurs) {
     const kept = [];
     for (const group of groups) {
       const keptHooks = (group.hooks ?? []).filter((h) => {
-        const isOur = isOurs(h.command, h.args);
+        const isOur = isOwnHookEntry(h, isOurs);
         if (isOur) removed = true;
         return !isOur;
       });
@@ -764,7 +526,7 @@ function stripStaleGroupHooks(groups, isOurs, matcherFilter) {
       next.push(group);
       continue;
     }
-    const keptHooks = (group.hooks ?? []).filter((h) => !isOurs(h.command, h.args));
+    const keptHooks = (group.hooks ?? []).filter((h) => !isOwnHookEntry(h, isOurs));
     if (keptHooks.length > 0) {
       next.push({ ...group, hooks: keptHooks });
     } else if ((group.hooks ?? []).length === 0) {
@@ -773,10 +535,13 @@ function stripStaleGroupHooks(groups, isOurs, matcherFilter) {
   }
   return next;
 }
+function detectEol(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
 function stripDelimitedBlock(p, beginMarker, endMarker, keepBackups = false) {
   let existing;
   try {
-    existing = readFileSync2(p, "utf8");
+    existing = readFileSync(p, "utf8");
   } catch {
     return false;
   }
@@ -786,29 +551,29 @@ function stripDelimitedBlock(p, beginMarker, endMarker, keepBackups = false) {
   const before = existing.slice(0, beginIdx).replace(/\s+$/, "");
   const after = existing.slice(endIdx + endMarker.length).replace(/^\s+/, "");
   let next;
+  const eol = detectEol(existing);
   if (before.length > 0 && after.length > 0) {
-    next = `${before}
-
-${after}`;
+    next = `${before}${eol}${eol}${after}`;
   } else if (before.length > 0) {
-    next = `${before}
-`;
+    next = `${before}${eol}`;
   } else {
     next = after;
   }
   backupFile(p);
-  atomicWriteText(p, next);
+  atomicWriteText(p, keepBom(existing, next));
   if (!keepBackups) removeCreatedBackups(p);
   return true;
 }
-function upsertDelimitedBlock(p, beginMarker, endMarker, block) {
+function upsertDelimitedBlock(p, beginMarker, endMarker, blockText) {
   assertWriteInScope(p);
   let existing;
   try {
-    existing = readFileSync2(p, "utf8");
+    existing = readFileSync(p, "utf8");
   } catch {
     existing = "";
   }
+  const eol = detectEol(existing);
+  const block = eol === "\n" ? blockText : blockText.replace(/\r?\n/g, eol);
   const beginIdx = existing.indexOf(beginMarker);
   const endIdx = existing.indexOf(endMarker);
   if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
@@ -816,42 +581,136 @@ function upsertDelimitedBlock(p, beginMarker, endMarker, block) {
     const after = existing.slice(endIdx + endMarker.length);
     const current = existing.slice(beginIdx, endIdx + endMarker.length);
     if (current === block) return false;
-    ensureDirSync(path6.dirname(p));
+    ensureDirSync(path2.dirname(p));
     backupFile(p);
     atomicWriteText(p, `${before}${block}${after}`);
     return true;
   }
   const trimmed = existing.replace(/\s+$/, "");
-  const next = trimmed.length > 0 ? `${trimmed}
-
-${block}
-` : `${block}
-`;
-  ensureDirSync(path6.dirname(p));
+  const next = trimmed.length > 0 ? `${trimmed}${eol}${eol}${block}${eol}` : `${block}${eol}`;
+  ensureDirSync(path2.dirname(p));
   backupFile(p);
-  atomicWriteText(p, next);
+  atomicWriteText(p, keepBom(existing, next));
   return true;
 }
 function writeJsonSettings(p, settings) {
-  ensureDirSync(path6.dirname(p));
+  ensureDirSync(path2.dirname(p));
+  let existing = "";
+  try {
+    existing = readFileSync(p, "utf8");
+  } catch {
+  }
   backupFile(p);
-  atomicWriteText(p, `${JSON.stringify(settings, null, 2)}
-`);
+  const eol = detectEol(existing);
+  const body = JSON.stringify(settings, null, detectJsonIndent(existing)).replace(/\n/g, eol);
+  atomicWriteText(p, keepBom(existing, existing.length > 0 && !existing.endsWith("\n") ? body : `${body}${eol}`));
+}
+var BOM = String.fromCharCode(65279);
+function keepBom(existing, next) {
+  return existing?.startsWith(BOM) && !next.startsWith(BOM) ? `${BOM}${next}` : next;
+}
+function writeConfigText(p, next) {
+  let existing;
+  try {
+    existing = readFileSync(p, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  atomicWriteText(p, keepBom(existing, next));
+}
+function detectJsonIndent(text) {
+  const lead = /^([ \t]+)\S/m.exec(text)?.[1];
+  if (lead === void 0) return "  ";
+  return lead.startsWith("	") ? "	" : lead.slice(0, 10);
 }
 function writeIfDifferent(p, content, backup = false) {
   let existing;
   try {
-    existing = readFileSync2(p, "utf8");
+    existing = readFileSync(p, "utf8");
   } catch {
     existing = void 0;
   }
   if (existing === content) return false;
   if (backup) backupFile(p);
-  ensureDirSync(path6.dirname(p));
+  ensureDirSync(path2.dirname(p));
   atomicWriteText(p, content);
   return true;
 }
 
+// src/encoding.ts
+init_define_import_meta_env();
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function detectSourceEncoding(buf) {
+  if (buf.length >= 4) {
+    if (buf[0] === 255 && buf[1] === 254 && buf[2] === 0 && buf[3] === 0) return "utf32le";
+    if (buf[0] === 0 && buf[1] === 0 && buf[2] === 254 && buf[3] === 255) return "utf32be";
+  }
+  if (buf.length >= 2) {
+    if (buf[0] === 255 && buf[1] === 254) return "utf16le";
+    if (buf[0] === 254 && buf[1] === 255) return "utf16be";
+  }
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) return "utf8-bom";
+  return "utf8";
+}
+function decodeSource(buf) {
+  switch (detectSourceEncoding(buf)) {
+    case "utf32le":
+      return decodeUtf32(buf.subarray(4), true);
+    case "utf32be":
+      return decodeUtf32(buf.subarray(4), false);
+    case "utf16le":
+      return buf.subarray(2).toString("utf16le");
+    case "utf16be":
+      return swap16(buf.subarray(2)).toString("utf16le");
+    case "utf8-bom":
+      return buf.subarray(3).toString("utf8");
+    default:
+      return buf.toString("utf8");
+  }
+}
+function encodeSource(text, encoding) {
+  switch (encoding) {
+    case "utf32le":
+      return Buffer.concat([Buffer.from([255, 254, 0, 0]), encodeUtf32(text, true)]);
+    case "utf32be":
+      return Buffer.concat([Buffer.from([0, 0, 254, 255]), encodeUtf32(text, false)]);
+    case "utf16le":
+      return Buffer.concat([Buffer.from([255, 254]), Buffer.from(text, "utf16le")]);
+    case "utf16be":
+      return Buffer.concat([Buffer.from([254, 255]), swap16(Buffer.from(text, "utf16le"))]);
+    case "utf8-bom":
+      return Buffer.concat([Buffer.from([239, 187, 191]), Buffer.from(text, "utf8")]);
+    default:
+      return Buffer.from(text, "utf8");
+  }
+}
+function swap16(buf) {
+  const out = Buffer.from(buf);
+  return out.subarray(0, out.length - out.length % 2).swap16();
+}
+function decodeUtf32(buf, littleEndian) {
+  const points = [];
+  for (let i = 0; i + 4 <= buf.length; i += 4) {
+    const cp = littleEndian ? buf.readUInt32LE(i) : buf.readUInt32BE(i);
+    points.push(cp > 1114111 || cp >= 55296 && cp <= 57343 ? 65533 : cp);
+  }
+  let out = "";
+  for (let i = 0; i < points.length; i += 8192) out += String.fromCodePoint(...points.slice(i, i + 8192));
+  return out;
+}
+function encodeUtf32(text, littleEndian) {
+  const points = [...text];
+  const out = Buffer.alloc(points.length * 4);
+  points.forEach((ch, i) => {
+    const cp = ch.codePointAt(0) ?? 65533;
+    if (littleEndian) out.writeUInt32LE(cp, i * 4);
+    else out.writeUInt32BE(cp, i * 4);
+  });
+  return out;
+}
+
 // src/util.ts
 function runGit(args, opts = {}) {
   const subArgs = args[0] === "diff" ? [args[0], "--no-ext-diff", "--no-textconv", ...args.slice(1)] : args;
@@ -881,7 +740,7 @@ function runGit(args, opts = {}) {
 }
 function statSize(absPath) {
   try {
-    const st = statSync3(absPath);
+    const st = statSync(absPath);
     return st.isFile() ? st.size : null;
   } catch {
     return null;
@@ -894,14 +753,16 @@ function isRetryable(err) {
   return typeof code === "string" && RETRYABLE_ERRNO.has(code);
 }
 function isEExist(err) {
-  if (typeof err !== "object" || err === null) return false;
-  return err.code === "EEXIST";
+  return errnoCode(err) === "EEXIST";
+}
+function errnoCode(err) {
+  return typeof err === "object" && err !== null ? err.code : void 0;
 }
 function ensureDirSync(dir) {
   assertWriteInScope(dir);
   ensureStorageRootPrivate(dir);
   try {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync(dir, { recursive: true });
   } catch (err) {
     if (!isEExist(err)) {
       throw err;
@@ -922,10 +783,28 @@ function withRetryOnLock(fn) {
   }
   throw lastErr;
 }
-function atomicWriteCore(dest, content) {
-  assertWriteInScope(dest);
+function resolveSymlinkChain(p) {
+  const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
+  let current = p;
+  for (let hops = 0; hops < 40; hops++) {
+    let st;
+    try {
+      st = lstatSync(current);
+    } catch (err) {
+      if (err.code === "ENOENT") return current;
+      throw err;
+    }
+    if (!st.isSymbolicLink() || uid !== void 0 && st.uid !== uid && st.uid !== 0) return current;
+    current = path3.resolve(path3.dirname(current), readlinkSync(current));
+  }
+  throw Object.assign(new Error(`ELOOP: too many levels of symbolic links, resolving ${p}`), { code: "ELOOP" });
+}
+function atomicWriteCore(requested, content) {
+  assertWriteInScope(requested);
+  const dest = resolveSymlinkChain(requested);
+  if (dest !== requested) assertWriteInScope(dest);
   const tmp = `${dest}.${process.pid}.${process.hrtime.bigint().toString()}.tmp`;
-  ensureDirSync(path7.dirname(dest));
+  ensureDirSync(path3.dirname(dest));
   try {
     const fd = openSync(tmp, "w", 384);
     try {
@@ -938,8 +817,8 @@ function atomicWriteCore(dest, content) {
       closeSync(fd);
     }
     try {
-      const destMode = statSync3(dest).mode;
-      chmodSync2(tmp, destMode);
+      const destStat = lstatSync(dest);
+      if (!destStat.isSymbolicLink()) chmodSync(tmp, destStat.mode);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -961,19 +840,19 @@ function atomicWriteBytes(filePath, content) {
 function installSingleFilePlugin(filePath, sidecarPath, template) {
   let existing;
   try {
-    existing = readFileSync3(filePath, "utf8");
+    existing = readFileSync2(filePath, "utf8");
   } catch {
     existing = void 0;
   }
   const entryPath = process.argv[1];
   if (entryPath) {
-    ensureDirSync(path7.dirname(filePath));
+    ensureDirSync(path3.dirname(filePath));
     atomicWriteText(sidecarPath, JSON.stringify({ entryPath }));
   }
   if (existing === template) {
     return { filePath, alreadyInstalled: true };
   }
-  ensureDirSync(path7.dirname(filePath));
+  ensureDirSync(path3.dirname(filePath));
   atomicWriteText(filePath, template);
   return { filePath, alreadyInstalled: false };
 }
@@ -1007,7 +886,7 @@ var MAX_BACKUPS_PER_FILE = 5;
 var MAX_BACKUP_NAME_ATTEMPTS = 16;
 function backupFile(p) {
   assertWriteInScope(p);
-  if (!existsSync3(p)) return;
+  if (!existsSync(p)) return;
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   let backupPath;
   for (let attempt = 0; ; attempt++) {
@@ -1047,34 +926,43 @@ function containsLineRun(haystack, needle) {
 var LOCK_WAIT_MS = 2e3;
 var LOCK_STALE_MS = 5e3;
 var LOCK_WAIT_MS_HARDENED = 15e3;
-var HEARTBEAT_SCRIPT = `
-const fs = require('fs')
-const [, lockPath, token, ms] = process.argv
-const ppid = process.ppid
-function tick() {
+var LOCK_LIVE_HOLDER_MAX_MS = 6e4;
+var LOCK_EPERM_RUN_MS = 1e3;
+function lockHolderAlive(token) {
+  const pid = Number(/^(\d+):/.exec(token)?.[1]);
+  if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) return false;
   try {
-    process.kill(ppid, 0)
-  } catch {
-    // Parent is gone (crashed, killed, ...): stop ticking so a genuinely dead holder's lock still goes stale and gets reclaimed. Windows ties this child's lifetime to its parent's Job Object automatically, but POSIX does not -- without this check, a plain spawn() child outlives a crashed parent as an orphan and would refresh the lock file forever, permanently wedging it. This is the actual enforcement mechanism on POSIX (this project's CI runs on ubuntu-latest); on Windows it is a harmless backstop.
-    process.exit(0)
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
   }
+}
+function lockAbandoned(lockPath, staleMs) {
+  const age = Date.now() - statSync(lockPath).mtimeMs;
+  return age > staleMs && (age > Math.max(staleMs, LOCK_LIVE_HOLDER_MAX_MS) || !lockHolderAlive(readFileSync2(lockPath, "utf8")));
+}
+function stealAbandoned(lockPath, staleMs) {
+  const guardPath = `${lockPath}.steal`;
   try {
-    // Only ever refresh the token already on disk; never (re)create the file. This preserves the ownership check in withFileLock's finally block unchanged -- the heartbeat never changes what makes a lock file "belong" to a holder, only how fresh its mtime looks.
-    if (fs.readFileSync(lockPath, 'utf8') === token) fs.writeFileSync(lockPath, token)
-  } catch {}
-}
-setInterval(tick, Number(ms))
-`;
-function startHeartbeat(lockPath, token, staleMs) {
-  const intervalMs = Math.max(20, Math.floor(staleMs / 3));
+    writeFileSync(guardPath, "", { flag: "wx" });
+  } catch (err) {
+    try {
+      if (isEExist(err) && Date.now() - statSync(guardPath).mtimeMs > staleMs) unlinkSync(guardPath);
+    } catch {
+    }
+    return false;
+  }
   try {
-    return spawn(process.execPath, ["-e", HEARTBEAT_SCRIPT, lockPath, token, String(intervalMs)], {
-      stdio: "ignore",
-      windowsHide: true
-    });
+    if (lockAbandoned(lockPath, staleMs)) unlinkSync(lockPath);
   } catch {
-    return void 0;
+  } finally {
+    try {
+      unlinkSync(guardPath);
+    } catch {
+    }
   }
+  return true;
 }
 function withFileLock(lockPath, fn, opts = {}) {
   const waitMs = opts.waitMs ?? LOCK_WAIT_MS;
@@ -1082,40 +970,37 @@ function withFileLock(lockPath, fn, opts = {}) {
   const token = `${process.pid}:${process.hrtime.bigint().toString()}`;
   const deadline = Date.now() + waitMs;
   let attempt = 0;
+  let epermSince;
   for (; ; ) {
     try {
       writeFileSync(lockPath, token, { flag: "wx" });
       break;
     } catch (err) {
+      if (process.platform === "win32" && errnoCode(err) === "EPERM") {
+        epermSince ??= Date.now();
+        if (Date.now() >= deadline || Date.now() - epermSince >= LOCK_EPERM_RUN_MS) return void 0;
+        sleepSync(Math.min(20 * ++attempt, 200));
+        continue;
+      }
       if (!isEExist(err)) return void 0;
+      epermSince = void 0;
     }
     let stale;
     try {
-      const st = statSync3(lockPath);
-      stale = Date.now() - st.mtimeMs > staleMs;
-    } catch {
-      stale = true;
-    }
-    if (stale) {
-      try {
-        unlinkSync(lockPath);
-      } catch {
-      }
-      continue;
+      stale = lockAbandoned(lockPath, staleMs);
+    } catch (err) {
+      if (errnoCode(err) === "ENOENT") continue;
+      stale = false;
     }
+    if (stale && stealAbandoned(lockPath, staleMs)) continue;
     if (Date.now() >= deadline) return void 0;
     sleepSync(Math.min(20 * ++attempt, 200));
   }
-  const heartbeat = startHeartbeat(lockPath, token, staleMs);
   try {
     return fn();
   } finally {
     try {
-      heartbeat?.kill();
-    } catch {
-    }
-    try {
-      if (readFileSync3(lockPath, "utf8") === token) unlinkSync(lockPath);
+      if (readFileSync2(lockPath, "utf8") === token) unlinkSync(lockPath);
     } catch {
     }
   }
@@ -1173,9 +1058,9 @@ function redactUrlQuery(raw) {
 }
 function withExtension(filePath, format) {
   const ext = format === "jpeg" ? ".jpg" : `.${format}`;
-  const dir = path7.dirname(filePath);
-  const base = path7.basename(filePath, path7.extname(filePath));
-  return path7.join(dir, `${base}${ext}`);
+  const dir = path3.dirname(filePath);
+  const base = path3.basename(filePath, path3.extname(filePath));
+  return path3.join(dir, `${base}${ext}`);
 }
 function ensureNewline(text) {
   return text.endsWith("\n") ? text : text + "\n";
@@ -1234,10 +1119,10 @@ function isTestFile(p) {
 }
 function isUnderBlockedRoot(filePath, blockedRoots) {
   if (blockedRoots.length === 0) return false;
-  const target = foldPath(normalizePath(path7.resolve(filePath)));
+  const target = foldPath(normalizePath(path3.resolve(filePath)));
   for (const root of blockedRoots) {
     if (!root) continue;
-    const normRoot = foldPath(normalizePath(path7.resolve(root)));
+    const normRoot = foldPath(normalizePath(path3.resolve(root)));
     if (target === normRoot) return true;
     const boundary = normRoot.endsWith("/") ? normRoot : `${normRoot}/`;
     if (target.startsWith(boundary)) return true;
@@ -1270,50 +1155,159 @@ function hookPowershellCommand(scriptPath, event) {
   return `${quotePowershellPath(process.execPath)} ${quotePowershellPath(scriptPath)} ${event}${entryArg}`;
 }
 
+// src/bridges/created_configs.ts
+function ledgerPath() {
+  return path4.join(dataDir(), "created-configs.json");
+}
+function keyOf(filePath) {
+  return normalizePath(path4.resolve(filePath));
+}
+function foldKey(key) {
+  return foldPath(key);
+}
+function readLedger() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(ledgerPath(), "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function writeLedger(entries) {
+  try {
+    ensureDirSync(path4.dirname(ledgerPath()));
+    atomicWriteText(ledgerPath(), `${JSON.stringify(entries)}
+`);
+  } catch {
+  }
+}
+function recordCreatedConfig(filePath) {
+  const key = keyOf(filePath);
+  const entries = readLedger();
+  if (entries.some((entry) => foldKey(entry) === foldKey(key))) return;
+  writeLedger([...entries, key]);
+}
+function hasCreatedConfig(filePath) {
+  const key = foldKey(keyOf(filePath));
+  return readLedger().some((entry) => foldKey(entry) === key);
+}
+function takeCreatedConfig(filePath) {
+  const key = foldKey(keyOf(filePath));
+  const entries = readLedger();
+  if (!entries.some((entry) => foldKey(entry) === key)) return false;
+  writeLedger(entries.filter((entry) => foldKey(entry) !== key));
+  return true;
+}
+function rootKeyMarker(filePath, rootKey) {
+  return `${filePath}#root-key=${rootKey}`;
+}
+function recordCreatedRootKey(filePath, rootKey) {
+  recordCreatedConfig(rootKeyMarker(filePath, rootKey));
+}
+function takeCreatedRootKey(filePath, rootKey) {
+  return takeCreatedConfig(rootKeyMarker(filePath, rootKey));
+}
+function recordCreatedBackup(backupPath) {
+  recordCreatedConfig(backupPath);
+}
+function forgetCreatedBackup(backupPath) {
+  takeCreatedConfig(backupPath);
+}
+function createdBackupsFor(configPath) {
+  const prefix = foldKey(`${keyOf(configPath)}.bak.`);
+  return readLedger().filter((entry) => foldKey(entry).startsWith(prefix)).sort();
+}
+function removeCreatedBackups(configPath) {
+  const prefix = foldKey(`${keyOf(configPath)}.bak.`);
+  const entries = readLedger();
+  const ours = entries.filter((entry) => foldKey(entry).startsWith(prefix));
+  if (ours.length === 0) return 0;
+  const failed = /* @__PURE__ */ new Set();
+  let removed = 0;
+  for (const target of ours) {
+    try {
+      if (fs.existsSync(target) && removeFileInScope(target)) {
+        removed++;
+      }
+    } catch {
+      failed.add(target);
+    }
+  }
+  writeLedger(entries.filter((entry) => !ours.includes(entry) || failed.has(entry)));
+  return removed;
+}
+function ensureDirRecordingCreation(dir) {
+  const existed = fs.existsSync(dir);
+  ensureDirSync(dir);
+  if (!existed) recordCreatedConfig(dir);
+}
+function holdsNothing(text) {
+  const trimmed = text.trim();
+  return trimmed === "" || /^\{\s*\}$/.test(trimmed);
+}
+function removeCreatedIfEmpty(target) {
+  if (!hasCreatedConfig(target)) return;
+  let removed = false;
+  try {
+    removed = fs.lstatSync(target).isDirectory() ? removeEmptyDirInScope(target) : holdsNothing(fs.readFileSync(target, "utf8")) && removeFileInScope(target);
+  } catch {
+  }
+  if (removed) takeCreatedConfig(target);
+}
+function recordCreatedBy(targets, work) {
+  const absent = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    for (let p = path4.resolve(target); !fs.existsSync(p) && !absent.has(p); p = path4.dirname(p)) absent.add(p);
+  }
+  try {
+    return work();
+  } finally {
+    for (const p of absent) if (fs.existsSync(p)) recordCreatedConfig(p);
+  }
+}
+function removeCreatedTree(targets) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    for (let p = path4.resolve(target); !paths.has(p); p = path4.dirname(p)) {
+      paths.add(p);
+      if (path4.dirname(p) === p) break;
+    }
+  }
+  for (const p of [...paths].sort((a, b) => b.length - a.length)) {
+    if (fs.existsSync(p)) removeCreatedIfEmpty(p);
+    else if (hasCreatedConfig(p)) takeCreatedConfig(p);
+  }
+}
+
 export {
-  VERSION,
-  PACKAGE_NAME,
-  supportRequestLine,
-  dataDirForHome,
-  dataDir,
-  ensureDataDirPrivate,
-  tokenGoatHome,
-  globalDbPath,
-  configPath,
-  projectConfigPath,
-  ENV_KEYS,
-  SYMBOL_BODY_CHAR_CAP,
-  SKELETON_SYMBOL_CAP,
   recordCreatedConfig,
   hasCreatedConfig,
   takeCreatedConfig,
+  recordCreatedRootKey,
+  takeCreatedRootKey,
   removeCreatedBackups,
-  isCaseInsensitiveFs,
-  foldPath,
-  isNodeModulesPath,
-  foldCase,
-  foldCaseForContainment,
-  foldPathForContainment,
-  canonicalize,
-  escapesOntoNetworkThroughLinks,
-  isInsideRoot,
+  ensureDirRecordingCreation,
+  removeCreatedIfEmpty,
+  recordCreatedBy,
+  removeCreatedTree,
   assertProjectScopeTarget,
   withInstallScope,
   projectScopeRoot,
   assertWriteInScope,
   projectPathIsConsultable,
+  hasNestedQuantifier,
+  growsExponentially,
+  compileGuardedRegex,
+  compileGuardedRegexCached,
+  commandHookFields,
+  isOwnHookEntry,
   stripOwnHooksFromMap,
   stripStaleGroupHooks,
   stripDelimitedBlock,
   upsertDelimitedBlock,
   writeJsonSettings,
+  writeConfigText,
   writeIfDifferent,
-  sleepSync,
-  isWindows,
-  windowsCmdQuoteArg,
-  quoteShellPath,
-  resolveOnPath,
-  installEpipeGuard,
   stripBom,
   detectSourceEncoding,
   decodeSource,