token-goat 2.9.29 → 2.9.30

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

@@ -6,178 +6,32 @@ import {
   quotePowershellPath,
   quoteShellPath,
   sleepSync
-} from "./token-goat-chunk-TCQANXYC.mjs";
+} from "./token-goat-chunk-AM5V6GSX.mjs";
 import {
   normalizePath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   dataDir,
   ensureStorageRootPrivate,
   isTokenGoatStorage
-} from "./token-goat-chunk-MELOKFDJ.mjs";
-import {
-  compileGuardedRegex
-} from "./token-goat-chunk-JTKCQMQA.mjs";
+} from "./token-goat-chunk-VES7EL7O.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
 
-// src/encoding.ts
+// src/bridges/created_configs.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;
-}
+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 as existsSync2, mkdirSync, openSync, readdirSync, readFileSync as readFileSync3, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import * as path4 from "node:path";
-
-// src/bridges/created_configs.ts
-init_define_import_meta_env();
-import * as fs from "fs";
-import * as path from "path";
-function ledgerPath() {
-  return path.join(dataDir(), "created-configs.json");
-}
-function keyOf(filePath) {
-  return normalizePath(path.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(path.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(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;
-}
+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 path2 from "node:path";
+import * as path from "node:path";
 function assertProjectScopeTarget(target, projectRoot) {
   if (projectRoot === void 0) return;
   if (isInsideRoot(target, projectRoot)) return;
@@ -188,7 +42,7 @@ function assertProjectScopeTarget(target, projectRoot) {
 var installProjectRoot;
 function withInstallScope(projectRoot, fn) {
   const previous = installProjectRoot;
-  installProjectRoot = projectRoot === void 0 ? void 0 : path2.resolve(projectRoot);
+  installProjectRoot = projectRoot === void 0 ? void 0 : path.resolve(projectRoot);
   try {
     const result = fn();
     if (typeof result?.then === "function") {
@@ -204,7 +58,7 @@ function withInstallScope(projectRoot, fn) {
 function projectScopeRoot(opts) {
   if (opts === void 0) return void 0;
   if (opts.project !== true && opts.local !== true) return void 0;
-  return path2.resolve(opts.projectRoot ?? process.cwd());
+  return path.resolve(opts.projectRoot ?? process.cwd());
 }
 function assertWriteInScope(target) {
   const root = installProjectRoot;
@@ -219,10 +73,425 @@ function projectPathIsConsultable(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 as readFileSync2 } from "node:fs";
-import * as path3 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)) {
@@ -231,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;
       });
@@ -257,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) {
@@ -266,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;
   }
@@ -279,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) {
@@ -309,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(path3.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(path3.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(path3.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(path3.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;
@@ -387,8 +753,10 @@ 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);
@@ -415,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(path4.dirname(dest));
+  ensureDirSync(path3.dirname(dest));
   try {
     const fd = openSync(tmp, "w", 384);
     try {
@@ -431,8 +817,8 @@ function atomicWriteCore(dest, content) {
       closeSync(fd);
     }
     try {
-      const destMode = statSync(dest).mode;
-      chmodSync(tmp, destMode);
+      const destStat = lstatSync(dest);
+      if (!destStat.isSymbolicLink()) chmodSync(tmp, destStat.mode);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -454,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(path4.dirname(filePath));
+    ensureDirSync(path3.dirname(filePath));
     atomicWriteText(sidecarPath, JSON.stringify({ entryPath }));
   }
   if (existing === template) {
     return { filePath, alreadyInstalled: true };
   }
-  ensureDirSync(path4.dirname(filePath));
+  ensureDirSync(path3.dirname(filePath));
   atomicWriteText(filePath, template);
   return { filePath, alreadyInstalled: false };
 }
@@ -500,7 +886,7 @@ var MAX_BACKUPS_PER_FILE = 5;
 var MAX_BACKUP_NAME_ATTEMPTS = 16;
 function backupFile(p) {
   assertWriteInScope(p);
-  if (!existsSync2(p)) return;
+  if (!existsSync(p)) return;
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   let backupPath;
   for (let attempt = 0; ; attempt++) {
@@ -541,6 +927,7 @@ 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 lockHolderAlive(token) {
   const pid = Number(/^(\d+):/.exec(token)?.[1]);
   if (!Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) return false;
@@ -551,33 +938,61 @@ function lockHolderAlive(token) {
     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 || 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 age = Date.now() - statSync(lockPath).mtimeMs;
-      stale = age > staleMs && (age > Math.max(staleMs, LOCK_LIVE_HOLDER_MAX_MS) || !lockHolderAlive(readFileSync3(lockPath, "utf8")));
-    } 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));
   }
@@ -585,7 +1000,7 @@ function withFileLock(lockPath, fn, opts = {}) {
     return fn();
   } finally {
     try {
-      if (readFileSync3(lockPath, "utf8") === token) unlinkSync(lockPath);
+      if (readFileSync2(lockPath, "utf8") === token) unlinkSync(lockPath);
     } catch {
     }
   }
@@ -643,9 +1058,9 @@ function redactUrlQuery(raw) {
 }
 function withExtension(filePath, format) {
   const ext = format === "jpeg" ? ".jpg" : `.${format}`;
-  const dir = path4.dirname(filePath);
-  const base = path4.basename(filePath, path4.extname(filePath));
-  return path4.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";
@@ -704,10 +1119,10 @@ function isTestFile(p) {
 }
 function isUnderBlockedRoot(filePath, blockedRoots) {
   if (blockedRoots.length === 0) return false;
-  const target = foldPath(normalizePath(path4.resolve(filePath)));
+  const target = foldPath(normalizePath(path3.resolve(filePath)));
   for (const root of blockedRoots) {
     if (!root) continue;
-    const normRoot = foldPath(normalizePath(path4.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;
@@ -740,21 +1155,158 @@ 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 {
   recordCreatedConfig,
   hasCreatedConfig,
   takeCreatedConfig,
+  recordCreatedRootKey,
+  takeCreatedRootKey,
   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,