token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,1377 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  echoedValue
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  foldPath,
+  isInsideRoot,
+  quotePowershellPath,
+  quoteShellPath,
+  sleepSync
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir,
+  ensureStorageRootPrivate,
+  isTokenGoatStorage
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/bridges/created_configs.ts
+init_define_import_meta_env();
+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/bridges/project_scope_guard.ts
+init_define_import_meta_env();
+import * as path 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 : path.resolve(projectRoot);
+  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."
+      );
+    }
+    return result;
+  } finally {
+    installProjectRoot = previous;
+  }
+}
+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());
+}
+function assertWriteInScope(target) {
+  const root = installProjectRoot;
+  if (root === void 0) return;
+  if (isTokenGoatStorage(target)) return;
+  assertProjectScopeTarget(target, root);
+}
+function projectPathIsConsultable(target, projectRoot) {
+  return isInsideRoot(target, projectRoot);
+}
+
+// src/util.ts
+import { spawnSync } from "node:child_process";
+
+// src/regex_guard.ts
+init_define_import_meta_env();
+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);
+  }
+  return out;
+}
+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 {
+    re = new RegExp(source, flags);
+  } catch {
+    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);
+  };
+  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;
+      }
+    }
+    if (c !== "\\") {
+      if (/[^\s()[\]{}|^$*+?.-]/.test(c)) push(c);
+      continue;
+    }
+    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 (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;
+      }
+      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 (next === "c" && /[a-zA-Z]/.test(source[i + 1] ?? "")) {
+      push(String.fromCharCode(source[i + 1].toUpperCase().charCodeAt(0) % 32));
+      i++;
+      continue;
+    }
+    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 out;
+}
+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 {
+      inner = new RegExp(body, re.flags);
+    } catch {
+      continue;
+    }
+    const innerCause = growsExponentially(inner);
+    if (innerCause !== null) return innerCause;
+  }
+  let widened;
+  try {
+    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);
+    }
+    if (projectsPastBudget(timings) && projectsPastBudget(remeasuredForProjection(re, timings, inputs))) return "projection";
+  }
+  if (!falsified && QUANTIFIED_GROUP.test(re.source)) return "unfalsifiable";
+  return null;
+}
+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 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_config.ts
+init_define_import_meta_env();
+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)) {
+    const groups = hooks[eventKey];
+    if (groups === void 0 || !Array.isArray(groups)) continue;
+    const kept = [];
+    for (const group of groups) {
+      const keptHooks = (group.hooks ?? []).filter((h) => {
+        const isOur = isOwnHookEntry(h, isOurs);
+        if (isOur) removed = true;
+        return !isOur;
+      });
+      if (keptHooks.length > 0) {
+        kept.push({ ...group, hooks: keptHooks });
+      } else if ((group.hooks ?? []).length === 0) {
+        kept.push(group);
+      }
+    }
+    if (kept.length > 0) {
+      hooks[eventKey] = kept;
+    } else {
+      delete hooks[eventKey];
+    }
+  }
+  return removed;
+}
+function stripStaleGroupHooks(groups, isOurs, matcherFilter) {
+  const list = Array.isArray(groups) ? groups : [];
+  const next = [];
+  for (const group of list) {
+    if (matcherFilter !== void 0 && group.matcher !== matcherFilter.matcher) {
+      next.push(group);
+      continue;
+    }
+    const keptHooks = (group.hooks ?? []).filter((h) => !isOwnHookEntry(h, isOurs));
+    if (keptHooks.length > 0) {
+      next.push({ ...group, hooks: keptHooks });
+    } else if ((group.hooks ?? []).length === 0) {
+      next.push(group);
+    }
+  }
+  return next;
+}
+function detectEol(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function stripDelimitedBlock(p, beginMarker, endMarker, keepBackups = false) {
+  let existing;
+  try {
+    existing = readFileSync(p, "utf8");
+  } catch {
+    return false;
+  }
+  const beginIdx = existing.indexOf(beginMarker);
+  const endIdx = existing.indexOf(endMarker);
+  if (beginIdx === -1 || endIdx === -1 || endIdx <= beginIdx) return 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}${eol}${eol}${after}`;
+  } else if (before.length > 0) {
+    next = `${before}${eol}`;
+  } else {
+    next = after;
+  }
+  backupFile(p);
+  atomicWriteText(p, keepBom(existing, next));
+  if (!keepBackups) removeCreatedBackups(p);
+  return true;
+}
+function upsertDelimitedBlock(p, beginMarker, endMarker, blockText) {
+  assertWriteInScope(p);
+  let existing;
+  try {
+    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) {
+    const before = existing.slice(0, beginIdx);
+    const after = existing.slice(endIdx + endMarker.length);
+    const current = existing.slice(beginIdx, endIdx + endMarker.length);
+    if (current === block) return false;
+    ensureDirSync(path2.dirname(p));
+    backupFile(p);
+    atomicWriteText(p, `${before}${block}${after}`);
+    return true;
+  }
+  const trimmed = existing.replace(/\s+$/, "");
+  const next = trimmed.length > 0 ? `${trimmed}${eol}${eol}${block}${eol}` : `${block}${eol}`;
+  ensureDirSync(path2.dirname(p));
+  backupFile(p);
+  atomicWriteText(p, keepBom(existing, next));
+  return true;
+}
+function writeJsonSettings(p, settings) {
+  ensureDirSync(path2.dirname(p));
+  let existing = "";
+  try {
+    existing = readFileSync(p, "utf8");
+  } catch {
+  }
+  backupFile(p);
+  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 = readFileSync(p, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  if (existing === content) return false;
+  if (backup) backupFile(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;
+  const fullArgs = [
+    "--no-optional-locks",
+    "-c",
+    "core.fsmonitor=",
+    "-c",
+    "core.quotepath=false",
+    ...subArgs
+  ];
+  const result = spawnSync("git", fullArgs, {
+    ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+    ...opts.timeoutMs !== void 0 ? { timeout: opts.timeoutMs } : {},
+    ...opts.input !== void 0 ? { input: opts.input } : {},
+    encoding: "utf-8",
+    windowsHide: true,
+    maxBuffer: 200 * 1024 * 1024
+  });
+  if (result.error) {
+    const timedOut = result.error.code === "ETIMEDOUT";
+    return { stdout: "", stderr: String(result.error.message ?? result.error), exitCode: -1, ...timedOut ? { timedOut } : {} };
+  }
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    exitCode: result.status ?? 1
+  };
+}
+function statSize(absPath) {
+  try {
+    const st = statSync(absPath);
+    return st.isFile() ? st.size : null;
+  } catch {
+    return null;
+  }
+}
+var RETRYABLE_ERRNO = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "ETXTBSY"]);
+function isRetryable(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const code = err.code;
+  return typeof code === "string" && RETRYABLE_ERRNO.has(code);
+}
+function isEExist(err) {
+  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 {
+    mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    if (!isEExist(err)) {
+      throw err;
+    }
+  }
+}
+function withRetryOnLock(fn) {
+  let lastErr;
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    try {
+      fn();
+      return;
+    } catch (err) {
+      lastErr = err;
+      if (!isRetryable(err) || attempt === 5) throw err;
+      sleepSync(50 * attempt);
+    }
+  }
+  throw lastErr;
+}
+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(path3.dirname(dest));
+  try {
+    const fd = openSync(tmp, "w", 384);
+    try {
+      if (typeof content === "string") {
+        writeSync(fd, Buffer.from(content, "utf-8"));
+      } else {
+        writeSync(fd, Buffer.from(content));
+      }
+    } finally {
+      closeSync(fd);
+    }
+    try {
+      const destStat = lstatSync(dest);
+      if (!destStat.isSymbolicLink()) chmodSync(tmp, destStat.mode);
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    withRetryOnLock(() => renameSync(tmp, dest));
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function atomicWriteText(filePath, content) {
+  atomicWriteCore(filePath, content);
+}
+function atomicWriteBytes(filePath, content) {
+  atomicWriteCore(filePath, content);
+}
+function installSingleFilePlugin(filePath, sidecarPath, template) {
+  let existing;
+  try {
+    existing = readFileSync2(filePath, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  const entryPath = process.argv[1];
+  if (entryPath) {
+    ensureDirSync(path3.dirname(filePath));
+    atomicWriteText(sidecarPath, JSON.stringify({ entryPath }));
+  }
+  if (existing === template) {
+    return { filePath, alreadyInstalled: true };
+  }
+  ensureDirSync(path3.dirname(filePath));
+  atomicWriteText(filePath, template);
+  return { filePath, alreadyInstalled: false };
+}
+function removeFileInScope(p) {
+  assertWriteInScope(p);
+  try {
+    unlinkSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeEmptyDirInScope(dirPath) {
+  assertWriteInScope(dirPath);
+  try {
+    const entries = readdirSync(dirPath);
+    if (entries.length === 0) {
+      rmdirSync(dirPath);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function uninstallSingleFilePlugin(filePath, sidecarPath) {
+  removeFileInScope(sidecarPath);
+  return removeFileInScope(filePath);
+}
+var MAX_BACKUPS_PER_FILE = 5;
+var MAX_BACKUP_NAME_ATTEMPTS = 16;
+function backupFile(p) {
+  assertWriteInScope(p);
+  if (!existsSync(p)) return;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  let backupPath;
+  for (let attempt = 0; ; attempt++) {
+    backupPath = attempt === 0 ? `${p}.bak.${stamp}` : `${p}.bak.${stamp}-${attempt}`;
+    try {
+      copyFileSync(p, backupPath, fsConstants.COPYFILE_EXCL);
+      break;
+    } catch (err) {
+      if (!isEExist(err) || attempt >= MAX_BACKUP_NAME_ATTEMPTS - 1) throw err;
+    }
+  }
+  recordCreatedBackup(backupPath);
+  pruneOldBackups(p);
+}
+function pruneOldBackups(p) {
+  const backups = createdBackupsFor(p);
+  const excess = backups.length - MAX_BACKUPS_PER_FILE;
+  for (const stalePath of backups.slice(0, Math.max(0, excess))) {
+    try {
+      removeFileInScope(stalePath);
+      forgetCreatedBackup(stalePath);
+    } catch {
+    }
+  }
+}
+var PER_FILE_COUNTERFACTUAL_CEILING = 1e5;
+function cappedSourceBytesSaved(fullSourceBytes, emittedBytes) {
+  return Math.max(1, Math.min(fullSourceBytes, PER_FILE_COUNTERFACTUAL_CEILING) - emittedBytes);
+}
+var IDENTICAL_READ_MIN_BODY_BYTES = 512;
+function containsLineRun(haystack, needle) {
+  const h = haystack.endsWith("\n") ? haystack.slice(0, -1) : haystack;
+  const n = needle.endsWith("\n") ? needle.slice(0, -1) : needle;
+  if (n.length === 0 || n.length > h.length) return false;
+  return ("\n" + h + "\n").includes("\n" + n + "\n");
+}
+function isSequentialPagingChain(ranges, minChainLength = 3) {
+  if (ranges.length < minChainLength) return false;
+  const slice = ranges.slice(-minChainLength);
+  const steps = (isStep) => slice.every((curr, i) => i === 0 || isStep(slice[i - 1], curr));
+  const inReach = (gap) => gap >= -25 && gap <= 60;
+  return steps(([s1, e1], [s2]) => s2 > s1 && inReach(s2 - e1)) || steps(([s1], [s2, e2]) => s2 < s1 && inReach(s1 - e2));
+}
+var LOCK_WAIT_MS = 2e3;
+var LOCK_STALE_MS = 5e3;
+var LOCK_WAIT_MS_HARDENED = 15e3;
+var LOCK_LIVE_HOLDER_MAX_MS = 6e4;
+var LOCK_EPERM_RUN_MS = 1e3;
+function lockPollMs(attempt, waitMs) {
+  return Math.max(1, Math.min(20 * attempt, 200, Math.floor(waitMs / 50)));
+}
+function lockHolderAlive(token) {
+  const pid = Number(/^(\d+):/.exec(token)?.[1]);
+  if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) return false;
+  try {
+    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 {
+    writeFileSync(guardPath, "", { flag: "wx" });
+  } catch (err) {
+    try {
+      if (isEExist(err) && Date.now() - statSync(guardPath).mtimeMs > staleMs) unlinkSync(guardPath);
+    } catch {
+    }
+    return false;
+  }
+  try {
+    if (lockAbandoned(lockPath, staleMs)) unlinkSync(lockPath);
+  } catch {
+  } finally {
+    try {
+      unlinkSync(guardPath);
+    } catch {
+    }
+  }
+  return true;
+}
+function withFileLock(lockPath, fn, opts = {}) {
+  const waitMs = opts.waitMs ?? LOCK_WAIT_MS;
+  const staleMs = opts.staleMs ?? LOCK_STALE_MS;
+  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) {
+          opts.onContended?.();
+          return void 0;
+        }
+        if (Date.now() - epermSince >= LOCK_EPERM_RUN_MS) return void 0;
+        sleepSync(lockPollMs(++attempt, waitMs));
+        continue;
+      }
+      if (!isEExist(err)) return void 0;
+      epermSince = void 0;
+    }
+    let stale;
+    try {
+      stale = lockAbandoned(lockPath, staleMs);
+    } catch (err) {
+      if (errnoCode(err) === "ENOENT") continue;
+      stale = false;
+    }
+    if (stale && stealAbandoned(lockPath, staleMs)) continue;
+    if (Date.now() >= deadline) {
+      opts.onContended?.();
+      return void 0;
+    }
+    sleepSync(lockPollMs(++attempt, waitMs));
+  }
+  try {
+    return fn();
+  } finally {
+    try {
+      if (readFileSync2(lockPath, "utf8") === token) unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
+function stripLower(s) {
+  return s.trim().toLowerCase();
+}
+function sanitizeIdForFilename(id, maxLen, fallback) {
+  const safe = id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, maxLen);
+  return safe.length > 0 ? safe : fallback ?? safe;
+}
+function toKB(bytes) {
+  return Math.round(bytes / 1024);
+}
+function compileGrepMatcher(pattern) {
+  const guarded = compileGuardedRegex(pattern);
+  if (!guarded.ok) return (candidate) => candidate.includes(pattern);
+  const re = guarded.re;
+  return (candidate) => re.test(candidate);
+}
+function countNoun(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function excludeTestsHiddenNote(count) {
+  return `${count} in test ${count === 1 ? "file" : "files"} hidden by --exclude-tests`;
+}
+function countContentLines(content) {
+  if (content === "") return 0;
+  const n = content.split("\n").length;
+  return content.endsWith("\n") ? n - 1 : n;
+}
+function pushAll(target, items) {
+  for (const item of items) target.push(item);
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function redactUrlQuery(raw) {
+  const q = raw.indexOf("?");
+  return q === -1 ? raw : raw.slice(0, q);
+}
+function withExtension(filePath, format) {
+  const ext = format === "jpeg" ? ".jpg" : `.${format}`;
+  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";
+}
+function extractErrorMessage(err, fallback = "") {
+  return err instanceof Error ? err.message : fallback || String(err);
+}
+function requireStrictInt(flag, raw) {
+  if (!/^-?\d+$/.test(raw)) {
+    throw new Error(`${flag} must be a number, got: ${echoedValue(raw)}`);
+  }
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n)) {
+    throw new Error(`${flag} must be a number, got: ${echoedValue(raw)}`);
+  }
+  return n;
+}
+function requireNonNegativeStrictInt(flag, raw) {
+  const n = requireStrictInt(flag, raw);
+  if (n < 0) {
+    throw new Error(`${flag} must be a non-negative number, got: ${echoedValue(raw)}`);
+  }
+  return n;
+}
+function requirePositiveStrictInt(flag, raw) {
+  const n = requireStrictInt(flag, raw);
+  if (n <= 0) {
+    throw new Error(`${flag} must be a positive number, got: ${echoedValue(raw)}`);
+  }
+  return n;
+}
+function isCodeFenceDelimiter(line) {
+  const s = line.trim();
+  return s.startsWith("```") || s.startsWith("~~~");
+}
+function pad(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+function normalizePathForwardSlash(p, toLowerCase) {
+  let result = normalizePath(p).replace(/\\/g, "/");
+  if (toLowerCase) result = result.toLowerCase();
+  return result;
+}
+function safeSlice(str, endIndex) {
+  let idx = endIndex;
+  if (idx > 0 && idx < str.length) {
+    const codeUnit = str.charCodeAt(idx);
+    if (codeUnit >= 56320 && codeUnit <= 57343) {
+      idx--;
+    }
+  }
+  return str.slice(0, idx);
+}
+function isTestFile(p) {
+  return /(^|[/\\])(tests?)[/\\]/i.test(p) || /\.(test|spec)\.|_test\.|(^|[/\\])test_/i.test(p);
+}
+function isUnderBlockedRoot(filePath, blockedRoots) {
+  if (blockedRoots.length === 0) return false;
+  const target = foldPath(normalizePath(path3.resolve(filePath)));
+  for (const root of blockedRoots) {
+    if (!root) continue;
+    const normRoot = foldPath(normalizePath(path3.resolve(root)));
+    if (target === normRoot) return true;
+    const boundary = normRoot.endsWith("/") ? normRoot : `${normRoot}/`;
+    if (target.startsWith(boundary)) return true;
+  }
+  return false;
+}
+var QUIET_HOURS_RE = /^([01]\d|2[0-3]):([0-5]\d)-([01]\d|2[0-3]):([0-5]\d)$/;
+function isWithinQuietHours(spec, now = /* @__PURE__ */ new Date()) {
+  const m = QUIET_HOURS_RE.exec(spec);
+  if (!m) return false;
+  const startMin = Number(m[1]) * 60 + Number(m[2]);
+  const endMin = Number(m[3]) * 60 + Number(m[4]);
+  const nowMin = now.getHours() * 60 + now.getMinutes();
+  if (startMin === endMin) return false;
+  if (startMin < endMin) return nowMin >= startMin && nowMin < endMin;
+  return nowMin >= startMin || nowMin < endMin;
+}
+function hookCommandFor(scriptPath, event) {
+  const entryPath = process.argv[1];
+  const entryArg = entryPath ? ` ${quoteShellPath(entryPath)}` : "";
+  return `${quoteShellPath(process.execPath)} ${quoteShellPath(scriptPath)} ${event}${entryArg}`;
+}
+function hookExecPartsFor(scriptPath, event) {
+  const entryPath = process.argv[1];
+  return { command: process.execPath, args: entryPath ? [scriptPath, event, entryPath] : [scriptPath, event] };
+}
+function hookPowershellCommand(scriptPath, event) {
+  const entryPath = process.argv[1];
+  const entryArg = entryPath ? ` ${quotePowershellPath(entryPath)}` : "";
+  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 turnedOffMarker(filePath, key) {
+  return `${filePath}#turned-off=${key}:true`;
+}
+function recordTurnedOffSetting(filePath, key) {
+  recordCreatedConfig(turnedOffMarker(filePath, key));
+}
+function takeTurnedOffSetting(filePath, key) {
+  return takeCreatedConfig(turnedOffMarker(filePath, key));
+}
+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 {
+  recordCreatedConfig,
+  hasCreatedConfig,
+  takeCreatedConfig,
+  recordCreatedRootKey,
+  takeCreatedRootKey,
+  recordTurnedOffSetting,
+  takeTurnedOffSetting,
+  removeCreatedBackups,
+  ensureDirRecordingCreation,
+  removeCreatedIfEmpty,
+  recordCreatedBy,
+  removeCreatedTree,
+  assertProjectScopeTarget,
+  withInstallScope,
+  projectScopeRoot,
+  assertWriteInScope,
+  projectPathIsConsultable,
+  hasNestedQuantifier,
+  growsExponentially,
+  compileGuardedRegex,
+  compileGuardedRegexCached,
+  commandHookFields,
+  isOwnHookEntry,
+  stripOwnHooksFromMap,
+  stripStaleGroupHooks,
+  stripDelimitedBlock,
+  upsertDelimitedBlock,
+  writeJsonSettings,
+  writeConfigText,
+  writeIfDifferent,
+  stripBom,
+  detectSourceEncoding,
+  decodeSource,
+  encodeSource,
+  runGit,
+  statSize,
+  ensureDirSync,
+  withRetryOnLock,
+  atomicWriteText,
+  atomicWriteBytes,
+  installSingleFilePlugin,
+  removeFileInScope,
+  removeEmptyDirInScope,
+  uninstallSingleFilePlugin,
+  backupFile,
+  PER_FILE_COUNTERFACTUAL_CEILING,
+  cappedSourceBytesSaved,
+  IDENTICAL_READ_MIN_BODY_BYTES,
+  containsLineRun,
+  isSequentialPagingChain,
+  LOCK_WAIT_MS_HARDENED,
+  withFileLock,
+  stripLower,
+  sanitizeIdForFilename,
+  toKB,
+  compileGrepMatcher,
+  countNoun,
+  excludeTestsHiddenNote,
+  countContentLines,
+  pushAll,
+  escapeRegExp,
+  redactUrlQuery,
+  withExtension,
+  ensureNewline,
+  extractErrorMessage,
+  requireNonNegativeStrictInt,
+  requirePositiveStrictInt,
+  isCodeFenceDelimiter,
+  pad,
+  normalizePathForwardSlash,
+  safeSlice,
+  isTestFile,
+  isUnderBlockedRoot,
+  isWithinQuietHours,
+  hookCommandFor,
+  hookExecPartsFor,
+  hookPowershellCommand
+};