token-goat 2.9.29 → 2.9.31

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

@@ -1,807 +0,0 @@
-import { createRequire as __cjsRequire } from 'node:module';
-const require = __cjsRequire(import.meta.url);
-import {
-  foldPath,
-  isInsideRoot,
-  quotePowershellPath,
-  quoteShellPath,
-  sleepSync
-} from "./token-goat-chunk-TCQANXYC.mjs";
-import {
-  normalizePath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
-import {
-  dataDir,
-  ensureStorageRootPrivate,
-  isTokenGoatStorage
-} from "./token-goat-chunk-MELOKFDJ.mjs";
-import {
-  compileGuardedRegex
-} from "./token-goat-chunk-JTKCQMQA.mjs";
-import {
-  init_define_import_meta_env
-} from "./token-goat-chunk-A37V4PBF.mjs";
-
-// 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 { 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;
-}
-
-// src/bridges/project_scope_guard.ts
-init_define_import_meta_env();
-import * as path2 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 : path2.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 path2.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/util_config.ts
-init_define_import_meta_env();
-import { readFileSync as readFileSync2 } from "node:fs";
-import * as path3 from "node:path";
-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 = isOurs(h.command, h.args);
-        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) => !isOurs(h.command, h.args));
-    if (keptHooks.length > 0) {
-      next.push({ ...group, hooks: keptHooks });
-    } else if ((group.hooks ?? []).length === 0) {
-      next.push(group);
-    }
-  }
-  return next;
-}
-function stripDelimitedBlock(p, beginMarker, endMarker, keepBackups = false) {
-  let existing;
-  try {
-    existing = readFileSync2(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;
-  if (before.length > 0 && after.length > 0) {
-    next = `${before}
-
-${after}`;
-  } else if (before.length > 0) {
-    next = `${before}
-`;
-  } else {
-    next = after;
-  }
-  backupFile(p);
-  atomicWriteText(p, next);
-  if (!keepBackups) removeCreatedBackups(p);
-  return true;
-}
-function upsertDelimitedBlock(p, beginMarker, endMarker, block) {
-  assertWriteInScope(p);
-  let existing;
-  try {
-    existing = readFileSync2(p, "utf8");
-  } catch {
-    existing = "";
-  }
-  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(path3.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));
-  backupFile(p);
-  atomicWriteText(p, next);
-  return true;
-}
-function writeJsonSettings(p, settings) {
-  ensureDirSync(path3.dirname(p));
-  backupFile(p);
-  atomicWriteText(p, `${JSON.stringify(settings, null, 2)}
-`);
-}
-function writeIfDifferent(p, content, backup = false) {
-  let existing;
-  try {
-    existing = readFileSync2(p, "utf8");
-  } catch {
-    existing = void 0;
-  }
-  if (existing === content) return false;
-  if (backup) backupFile(p);
-  ensureDirSync(path3.dirname(p));
-  atomicWriteText(p, content);
-  return true;
-}
-
-// 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 } : {},
-    encoding: "utf-8",
-    windowsHide: true,
-    maxBuffer: 200 * 1024 * 1024
-  });
-  if (result.error) {
-    return { stdout: "", stderr: String(result.error.message ?? result.error), exitCode: -1 };
-  }
-  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) {
-  if (typeof err !== "object" || err === null) return false;
-  return err.code === "EEXIST";
-}
-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 atomicWriteCore(dest, content) {
-  assertWriteInScope(dest);
-  const tmp = `${dest}.${process.pid}.${process.hrtime.bigint().toString()}.tmp`;
-  ensureDirSync(path4.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 destMode = statSync(dest).mode;
-      chmodSync(tmp, destMode);
-    } 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 = readFileSync3(filePath, "utf8");
-  } catch {
-    existing = void 0;
-  }
-  const entryPath = process.argv[1];
-  if (entryPath) {
-    ensureDirSync(path4.dirname(filePath));
-    atomicWriteText(sidecarPath, JSON.stringify({ entryPath }));
-  }
-  if (existing === template) {
-    return { filePath, alreadyInstalled: true };
-  }
-  ensureDirSync(path4.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 (!existsSync2(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");
-}
-var LOCK_WAIT_MS = 2e3;
-var LOCK_STALE_MS = 5e3;
-var LOCK_WAIT_MS_HARDENED = 15e3;
-var LOCK_LIVE_HOLDER_MAX_MS = 6e4;
-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 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;
-  for (; ; ) {
-    try {
-      writeFileSync(lockPath, token, { flag: "wx" });
-      break;
-    } catch (err) {
-      if (!isEExist(err)) return 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;
-    }
-    if (Date.now() >= deadline) return void 0;
-    sleepSync(Math.min(20 * ++attempt, 200));
-  }
-  try {
-    return fn();
-  } finally {
-    try {
-      if (readFileSync3(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 grepFilteredToEmptyNotice(preFilterCount, grep, nounSingular, nounPlural) {
-  const noun = preFilterCount === 1 ? nounSingular : nounPlural;
-  const verb = preFilterCount === 1 ? "was" : "were";
-  const pronoun = preFilterCount === 1 ? "it" : "them";
-  return `  (all ${preFilterCount} ${noun} ${verb} filtered out by --grep ${grep} -- widen or drop the filter to see ${pronoun})`;
-}
-function filtersFilteredToEmptyNotice(preFilterCount, activeFilters, nounSingular, nounPlural, reassurance) {
-  const noun = preFilterCount === 1 ? nounSingular : nounPlural;
-  const cause = activeFilters.length === 0 ? "the active filter" : activeFilters.join(" + ");
-  const knob = activeFilters.length > 1 ? "filters" : "filter";
-  const verb = preFilterCount === 1 ? "was" : "were";
-  const tail = reassurance === void 0 ? "" : `; ${reassurance}`;
-  return `  (all ${preFilterCount} ${noun} ${verb} filtered out by ${cause}${tail} -- widen or drop the ${knob} to see them)`;
-}
-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 = path4.dirname(filePath);
-  const base = path4.basename(filePath, path4.extname(filePath));
-  return path4.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: "${raw}"`);
-  }
-  const n = Number.parseInt(raw, 10);
-  if (!Number.isFinite(n)) {
-    throw new Error(`${flag} must be a number, got: "${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: "${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: "${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(path4.resolve(filePath)));
-  for (const root of blockedRoots) {
-    if (!root) continue;
-    const normRoot = foldPath(normalizePath(path4.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}`;
-}
-
-export {
-  recordCreatedConfig,
-  hasCreatedConfig,
-  takeCreatedConfig,
-  removeCreatedBackups,
-  assertProjectScopeTarget,
-  withInstallScope,
-  projectScopeRoot,
-  assertWriteInScope,
-  projectPathIsConsultable,
-  stripOwnHooksFromMap,
-  stripStaleGroupHooks,
-  stripDelimitedBlock,
-  upsertDelimitedBlock,
-  writeJsonSettings,
-  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,
-  LOCK_WAIT_MS_HARDENED,
-  withFileLock,
-  stripLower,
-  sanitizeIdForFilename,
-  toKB,
-  compileGrepMatcher,
-  grepFilteredToEmptyNotice,
-  filtersFilteredToEmptyNotice,
-  countNoun,
-  excludeTestsHiddenNote,
-  countContentLines,
-  pushAll,
-  escapeRegExp,
-  redactUrlQuery,
-  withExtension,
-  ensureNewline,
-  extractErrorMessage,
-  requireNonNegativeStrictInt,
-  requirePositiveStrictInt,
-  isCodeFenceDelimiter,
-  pad,
-  normalizePathForwardSlash,
-  safeSlice,
-  isTestFile,
-  isUnderBlockedRoot,
-  isWithinQuietHours,
-  hookCommandFor,
-  hookExecPartsFor,
-  hookPowershellCommand
-};