codebase-snapshot 0.9.5 → 0.9.6

package/dist/index.cjs

@@ -2,13 +2,14 @@
 
 var crypto = require('crypto');
 var async_hooks = require('async_hooks');
-var fs11 = require('fs');
+var fs12 = require('fs');
 var os = require('os');
-var path12 = require('path');
+var path13 = require('path');
 var ts = require('typescript');
 var module$1 = require('module');
 var url = require('url');
 var childProcess = require('child_process');
+var https = require('https');
 var readline = require('readline');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -32,11 +33,12 @@ function _interopNamespace(e) {
 }
 
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
-var fs11__namespace = /*#__PURE__*/_interopNamespace(fs11);
+var fs12__namespace = /*#__PURE__*/_interopNamespace(fs12);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var path12__namespace = /*#__PURE__*/_interopNamespace(path12);
+var path13__namespace = /*#__PURE__*/_interopNamespace(path13);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
 var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
+var https__namespace = /*#__PURE__*/_interopNamespace(https);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 // src/index.ts
@@ -263,9 +265,9 @@ var JAVA_METHOD = /^\s+(?:public|private|protected)\s+(?:static\s+)?(?:final\s+)
 var jvmProfile = {
   id: "jvm",
   extensions: [".java", ".kt", ".kts", ".scala"],
-  summarize(path13, content) {
+  summarize(path14, content) {
     const summary = emptySummary();
-    const lower = path13.toLowerCase();
+    const lower = path14.toLowerCase();
     const isJava = lower.endsWith(".java");
     const isKotlin = lower.endsWith(".kt") || lower.endsWith(".kts");
     eachLine(content, (line) => {
@@ -718,16 +720,16 @@ function summarizeTypeScriptSource(relativePath, content) {
 // src/ast/profiles/sfc.ts
 var SCRIPT_BLOCK = /<script[^>]*>([\s\S]*?)<\/script>/gi;
 var ASTRO_FRONTMATTER = /^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?=\r?\n|$)/;
-function componentName(path13) {
-  const base = path13.split("/").pop() ?? path13;
+function componentName(path14) {
+  const base = path14.split("/").pop() ?? path14;
   return base.replace(/\.[^.]+$/, "");
 }
 var sfcProfile = {
   id: "sfc",
   extensions: [".vue", ".svelte", ".astro"],
-  summarize(path13, content) {
+  summarize(path14, content) {
     let script = "";
-    if (path13.toLowerCase().endsWith(".astro")) {
+    if (path14.toLowerCase().endsWith(".astro")) {
       const frontmatter = ASTRO_FRONTMATTER.exec(content);
       if (frontmatter) script += `${frontmatter[1]}
 `;
@@ -736,7 +738,7 @@ var sfcProfile = {
       script += `${match[1]}
 `;
     }
-    const name = componentName(path13);
+    const name = componentName(path14);
     if (!script.trim()) {
       const summary2 = emptySummary();
       if (name) {
@@ -770,15 +772,15 @@ for (const profile of LANGUAGE_PROFILES) {
     BY_EXTENSION.set(extension.toLowerCase(), profile);
   }
 }
-function profileForPath(path13) {
-  const lower = path13.toLowerCase();
+function profileForPath(path14) {
+  const lower = path14.toLowerCase();
   const dot = lower.lastIndexOf(".");
   if (dot === -1) return null;
   return BY_EXTENSION.get(lower.slice(dot)) ?? null;
 }
-function summarizeWithProfile(path13, content) {
-  const profile = profileForPath(path13);
-  return profile ? profile.summarize(path13, content) : null;
+function summarizeWithProfile(path14, content) {
+  const profile = profileForPath(path14);
+  return profile ? profile.summarize(path14, content) : null;
 }
 
 // src/ast/structured.ts
@@ -949,15 +951,15 @@ var SKIPPED_WALK_DIRS = /* @__PURE__ */ new Set([
 ]);
 function readSmallFile(fullPath) {
   try {
-    const stats = fs11__namespace.statSync(fullPath);
+    const stats = fs12__namespace.statSync(fullPath);
     if (!stats.isFile() || stats.size > MANIFEST_MAX_BYTES) return null;
-    return fs11__namespace.readFileSync(fullPath, "utf8");
+    return fs12__namespace.readFileSync(fullPath, "utf8");
   } catch {
     return null;
   }
 }
 function readManifest(cwd, name) {
-  return readSmallFile(path12__namespace.join(cwd, name));
+  return readSmallFile(path13__namespace.join(cwd, name));
 }
 function dependenciesFromPackageJson(raw) {
   const names = /* @__PURE__ */ new Set();
@@ -1017,7 +1019,7 @@ function pnpmWorkspacePatterns(raw) {
 function childDirectories(cwd, parent) {
   let entries;
   try {
-    entries = fs11__namespace.readdirSync(path12__namespace.join(cwd, parent), { withFileTypes: true });
+    entries = fs12__namespace.readdirSync(path13__namespace.join(cwd, parent), { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1053,12 +1055,12 @@ function scanWorkspacePackages(cwd, patterns) {
   const files = /* @__PURE__ */ new Set();
   const dependencies = /* @__PURE__ */ new Set();
   for (const relative7 of workspacePackageDirs(cwd, patterns)) {
-    const full = path12__namespace.join(cwd, relative7);
+    const full = path13__namespace.join(cwd, relative7);
     try {
-      for (const entry of fs11__namespace.readdirSync(full, { withFileTypes: true })) files.add(entry.name);
+      for (const entry of fs12__namespace.readdirSync(full, { withFileTypes: true })) files.add(entry.name);
     } catch {
     }
-    const raw = readSmallFile(path12__namespace.join(full, "package.json"));
+    const raw = readSmallFile(path13__namespace.join(full, "package.json"));
     if (raw !== null) {
       for (const name of dependenciesFromPackageJson(raw)) dependencies.add(name);
     }
@@ -1075,7 +1077,7 @@ function countMarkdownFiles(cwd) {
     directoriesSeen += 1;
     let entries;
     try {
-      entries = fs11__namespace.readdirSync(current.dir, { withFileTypes: true });
+      entries = fs12__namespace.readdirSync(current.dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -1086,7 +1088,7 @@ function countMarkdownFiles(cwd) {
       }
       if (!entry.isDirectory() || current.depth >= 2) continue;
       if (entry.name.startsWith(".") || SKIPPED_WALK_DIRS.has(entry.name)) continue;
-      queue.push({ dir: path12__namespace.join(current.dir, entry.name), depth: current.depth + 1 });
+      queue.push({ dir: path13__namespace.join(current.dir, entry.name), depth: current.depth + 1 });
     }
   }
   return count;
@@ -1095,7 +1097,7 @@ function buildPresetContext(cwd) {
   const files = /* @__PURE__ */ new Set();
   const dirs = /* @__PURE__ */ new Set();
   try {
-    for (const entry of fs11__namespace.readdirSync(cwd, { withFileTypes: true })) {
+    for (const entry of fs12__namespace.readdirSync(cwd, { withFileTypes: true })) {
       if (entry.isDirectory()) dirs.add(entry.name);
       else if (entry.isFile()) files.add(entry.name);
     }
@@ -1112,7 +1114,7 @@ function buildPresetContext(cwd) {
   const isWorkspace = files.has("pnpm-workspace.yaml") || files.has("nx.json") || files.has("turbo.json") || files.has("lerna.json") || packageJson !== void 0 && packageJson.includes('"workspaces"') || declaredWorkspaces.length > 0;
   let workspace = { files: /* @__PURE__ */ new Set(), dependencies: /* @__PURE__ */ new Set() };
   if (isWorkspace) {
-    const pnpmRaw = files.has("pnpm-workspace.yaml") ? readSmallFile(path12__namespace.join(cwd, "pnpm-workspace.yaml")) : null;
+    const pnpmRaw = files.has("pnpm-workspace.yaml") ? readSmallFile(path13__namespace.join(cwd, "pnpm-workspace.yaml")) : null;
     const declared = pnpmRaw === null ? [] : pnpmWorkspacePatterns(pnpmRaw);
     const patterns = declared.length > 0 ? declared : declaredWorkspaces.length > 0 ? declaredWorkspaces : DEFAULT_WORKSPACE_PATTERNS;
     workspace = scanWorkspacePackages(cwd, patterns);
@@ -2387,14 +2389,14 @@ var PRESET_IGNORES = new Set(
 );
 function readLinkTarget(linkPath, fallback) {
   try {
-    return fs11__namespace.readlinkSync(linkPath);
+    return fs12__namespace.readlinkSync(linkPath);
   } catch {
     return fallback;
   }
 }
 function isInside(root, candidate) {
-  const relative7 = path12__namespace.relative(root, candidate);
-  return relative7 === "" || !relative7.startsWith(`..${path12__namespace.sep}`) && relative7 !== ".." && !path12__namespace.isAbsolute(relative7);
+  const relative7 = path13__namespace.relative(root, candidate);
+  return relative7 === "" || !relative7.startsWith(`..${path13__namespace.sep}`) && relative7 !== ".." && !path13__namespace.isAbsolute(relative7);
 }
 function getGitInfo(cwd, fallbackBranch = "main") {
   try {
@@ -2599,10 +2601,10 @@ function trimUnescapedTrailingSpaces(line) {
   return line.slice(0, end);
 }
 function readGitignoreRules(dir) {
-  const gitignorePath = path12__namespace.join(dir, ".gitignore");
+  const gitignorePath = path13__namespace.join(dir, ".gitignore");
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(gitignorePath, "utf8");
+    raw = fs12__namespace.readFileSync(gitignorePath, "utf8");
   } catch {
     return [];
   }
@@ -2729,7 +2731,7 @@ function isToolOwnedDirName(name) {
 }
 function hasSnapshotMarker(target) {
   try {
-    return fs11__namespace.statSync(target).isDirectory() && fs11__namespace.existsSync(path12__namespace.join(target, ".codebase-snapshot"));
+    return fs12__namespace.statSync(target).isDirectory() && fs12__namespace.existsSync(path13__namespace.join(target, ".codebase-snapshot"));
   } catch {
     return false;
   }
@@ -2743,7 +2745,7 @@ function makeToolOwnedDecider(cwd, toolOwnedPaths) {
       const prefix = parts.slice(0, depth).join("/");
       let hasMarker = markers.get(prefix);
       if (hasMarker === void 0) {
-        hasMarker = fs11__namespace.existsSync(path12__namespace.join(cwd, prefix, ".codebase-snapshot"));
+        hasMarker = fs12__namespace.existsSync(path13__namespace.join(cwd, prefix, ".codebase-snapshot"));
         markers.set(prefix, hasMarker);
       }
       if (hasMarker) return true;
@@ -2758,7 +2760,7 @@ function makeLinkProbe() {
     let known = cache.get(absolutePath);
     if (known === void 0) {
       try {
-        known = fs11__namespace.lstatSync(absolutePath).isSymbolicLink();
+        known = fs12__namespace.lstatSync(absolutePath).isSymbolicLink();
       } catch {
         known = false;
       }
@@ -2771,7 +2773,7 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
   const isLink = makeLinkProbe();
   let rootReal = cwd;
   try {
-    rootReal = fs11__namespace.realpathSync(cwd);
+    rootReal = fs12__namespace.realpathSync(cwd);
   } catch {
   }
   const reported = /* @__PURE__ */ new Set();
@@ -2781,7 +2783,7 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
     let linkedDir = null;
     for (let depth = 1; depth <= parts.length; depth += 1) {
       const prefix = parts.slice(0, depth).join("/");
-      if (isLink(path12__namespace.join(cwd, prefix))) {
+      if (isLink(path13__namespace.join(cwd, prefix))) {
         linkedDir = prefix;
         break;
       }
@@ -2792,10 +2794,10 @@ function dropLinkedDirectories(cwd, candidates, skipped) {
     }
     if (reported.has(linkedDir)) continue;
     reported.add(linkedDir);
-    const absolute = path12__namespace.join(cwd, linkedDir);
+    const absolute = path13__namespace.join(cwd, linkedDir);
     let targetReal = absolute;
     try {
-      targetReal = fs11__namespace.realpathSync(absolute);
+      targetReal = fs12__namespace.realpathSync(absolute);
     } catch {
     }
     const target = readLinkTarget(absolute, targetReal);
@@ -2872,7 +2874,7 @@ function collectFiles(cwd, options = {}) {
           "Discovery mode is `git`, but git could not list this directory's files. Run inside a working repository, or pass --discovery walk (or auto) to scan the tree directly."
         );
       }
-      if (fs11__namespace.existsSync(path12__namespace.join(cwd, ".git"))) {
+      if (fs12__namespace.existsSync(path13__namespace.join(cwd, ".git"))) {
         throw new Error(
           "This directory is a git repository, but git could not list its files. A plain walk honours .gitignore files, but git also applies .git/info/exclude and your global excludes file, includes files that are tracked although a .gitignore now matches them, and treats a submodule as a single entry. Fix the repository (git status should work), run outside git, or pass --discovery walk to accept those differences."
         );
@@ -2931,7 +2933,7 @@ function collectFiles(cwd, options = {}) {
 }
 function rootRealFor(root) {
   try {
-    return fs11__namespace.realpathSync(root);
+    return fs12__namespace.realpathSync(root);
   } catch {
     return root;
   }
@@ -2939,18 +2941,18 @@ function rootRealFor(root) {
 function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PURE__ */ new Set(), parentGitignoreLayers = []) {
   const results = { files: [], skipped: [] };
   const stack = [];
-  const relativeToBase = (target) => path12__namespace.relative(baseDir, target).replace(/\\/g, "/") || ".";
+  const relativeToBase = (target) => path13__namespace.relative(baseDir, target).replace(/\\/g, "/") || ".";
   const enter = (current, layers) => {
     if (visited.has(current)) return false;
     visited.add(current);
     const localRules = readGitignoreRules(current);
     const gitignoreLayers = localRules.length === 0 ? layers : [
       ...layers,
-      { prefix: path12__namespace.relative(baseDir, current).replace(/\\/g, "/"), rules: localRules }
+      { prefix: path13__namespace.relative(baseDir, current).replace(/\\/g, "/"), rules: localRules }
     ];
     let entries;
     try {
-      entries = fs11__namespace.readdirSync(current, { withFileTypes: true });
+      entries = fs12__namespace.readdirSync(current, { withFileTypes: true });
     } catch {
       results.skipped.push({
         path: relativeToBase(current),
@@ -2972,8 +2974,8 @@ function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PU
     }
     const entry = frame.entries[frame.index];
     frame.index += 1;
-    const fullPath = path12__namespace.join(frame.dir, entry.name);
-    const relPath = path12__namespace.relative(baseDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path13__namespace.join(frame.dir, entry.name);
+    const relPath = path13__namespace.relative(baseDir, fullPath).replace(/\\/g, "/");
     if (isToolOwnedDirName(entry.name) && reservedPaths.has(relPath)) continue;
     if (DEFAULT_IGNORED_DIRS.includes(entry.name)) {
       results.skipped.push({
@@ -3006,14 +3008,14 @@ function walkDirectory(dir, baseDir, rootReal, visited, reservedPaths = /* @__PU
     if (entry.isSymbolicLink()) {
       let targetReal;
       try {
-        targetReal = fs11__namespace.realpathSync(fullPath);
+        targetReal = fs12__namespace.realpathSync(fullPath);
       } catch {
         results.skipped.push({ path: relPath, reason: "read-error", detail: "broken symlink" });
         continue;
       }
       let stats;
       try {
-        stats = fs11__namespace.statSync(fullPath);
+        stats = fs12__namespace.statSync(fullPath);
       } catch {
         results.skipped.push({ path: relPath, reason: "read-error", detail: "unreadable symlink" });
         continue;
@@ -3311,11 +3313,11 @@ async function loadConfigFileDetailed(cwd) {
   const warnings = [];
   const errors = [];
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path12__namespace.join(cwd, filename);
-    if (!fs11__namespace.existsSync(fullPath)) continue;
+    const fullPath = path13__namespace.join(cwd, filename);
+    if (!fs12__namespace.existsSync(fullPath)) continue;
     if (filename.endsWith(".json") || filename === ".snapshotrc") {
       try {
-        const config = parseJsonish(fs11__namespace.readFileSync(fullPath, "utf8"), fullPath);
+        const config = parseJsonish(fs12__namespace.readFileSync(fullPath, "utf8"), fullPath);
         if (config === null || typeof config !== "object" || Array.isArray(config)) {
           throw new Error(
             `${fullPath} does not hold a configuration object (received ${describeValue2(config)}).`
@@ -3349,10 +3351,10 @@ async function loadConfigFileDetailed(cwd) {
       continue;
     }
   }
-  const pkgJsonPath = path12__namespace.join(cwd, "package.json");
-  if (fs11__namespace.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path13__namespace.join(cwd, "package.json");
+  if (fs12__namespace.existsSync(pkgJsonPath)) {
     try {
-      const parsed = parseJsonish(fs11__namespace.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
+      const parsed = parseJsonish(fs12__namespace.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
       const snapshotKey = parsed.snapshot;
       if (snapshotKey && typeof snapshotKey === "object" && !Array.isArray(snapshotKey)) {
         return { config: snapshotKey, file: pkgJsonPath, warnings, errors };
@@ -3375,7 +3377,7 @@ async function loadConfigFile(cwd) {
   const loaded = await loadConfigFileDetailed(cwd);
   if (loaded.config && loaded.file && typeof loaded.config === "object") {
     Object.defineProperty(loaded.config, CONFIG_DIR_SYMBOL, {
-      value: path12__namespace.dirname(loaded.file),
+      value: path13__namespace.dirname(loaded.file),
       enumerable: false,
       configurable: true
     });
@@ -3534,9 +3536,9 @@ function resolveKindRules(value) {
 function outputExcludePatterns(cwd, outDir, tmpDir) {
   const patterns = [];
   for (const dir of [outDir, tmpDir]) {
-    const absolute = path12__namespace.resolve(cwd, dir);
-    const relative7 = path12__namespace.relative(cwd, absolute);
-    if (!relative7 || relative7 === ".." || relative7.startsWith(`..${path12__namespace.sep}`) || path12__namespace.isAbsolute(relative7)) {
+    const absolute = path13__namespace.resolve(cwd, dir);
+    const relative7 = path13__namespace.relative(cwd, absolute);
+    if (!relative7 || relative7 === ".." || relative7.startsWith(`..${path13__namespace.sep}`) || path13__namespace.isAbsolute(relative7)) {
       continue;
     }
     patterns.push(`${relative7.replace(/\\/g, "/")}/**`);
@@ -3655,11 +3657,11 @@ function resolveCandidateCwd(userConfig, cliOptions, baseDir) {
     );
   }
   const candidate = cliOptions?.cwd || userConfig?.cwd || baseDir || process.cwd();
-  const resolved = path12__namespace.resolve(candidate);
-  if (!fs11__namespace.existsSync(resolved)) {
+  const resolved = path13__namespace.resolve(candidate);
+  if (!fs12__namespace.existsSync(resolved)) {
     throw new Error(`Working directory does not exist: ${resolved}`);
   }
-  if (!fs11__namespace.statSync(resolved).isDirectory()) {
+  if (!fs12__namespace.statSync(resolved).isDirectory()) {
     throw new Error(`Working directory is not a directory: ${resolved}`);
   }
   return resolved;
@@ -4683,7 +4685,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".so"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path12__namespace.extname(filePath).toLowerCase();
+  const ext = path13__namespace.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -4853,13 +4855,13 @@ function isBinaryFile(absolutePath) {
   if (isBinaryExtension(absolutePath)) return true;
   let fd;
   try {
-    fd = fs11__namespace.openSync(absolutePath, "r");
+    fd = fs12__namespace.openSync(absolutePath, "r");
     const buffer = Buffer.alloc(CHUNK);
     let sample;
     let position = 0;
     while (position < BINARY_SCAN_BYTES) {
       const wanted = Math.min(CHUNK, BINARY_SCAN_BYTES - position);
-      const bytesRead = fs11__namespace.readSync(fd, buffer, 0, wanted, position);
+      const bytesRead = fs12__namespace.readSync(fd, buffer, 0, wanted, position);
       if (bytesRead === 0) return false;
       const chunk = buffer.subarray(0, bytesRead);
       if (sample === void 0) {
@@ -4877,7 +4879,7 @@ function isBinaryFile(absolutePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        fs11__namespace.closeSync(fd);
+        fs12__namespace.closeSync(fd);
       } catch {
       }
     }
@@ -4937,10 +4939,10 @@ var LANGUAGE_BY_BASENAME = {
 };
 function detectLanguage(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const base = path12__namespace.posix.basename(normalized);
+  const base = path13__namespace.posix.basename(normalized);
   if (LANGUAGE_BY_BASENAME[base]) return LANGUAGE_BY_BASENAME[base];
   if (base === ".env" || base.startsWith(".env.")) return "dotenv";
-  const ext = path12__namespace.posix.extname(base).toLowerCase();
+  const ext = path13__namespace.posix.extname(base).toLowerCase();
   return LANGUAGE_BY_EXTENSION[ext] ?? "text";
 }
 function maskedPath(value, secretRules) {
@@ -4948,33 +4950,33 @@ function maskedPath(value, secretRules) {
 }
 function confineToDirectory(directory, filename) {
   if (filename.includes("\0")) return null;
-  if (path12__namespace.isAbsolute(filename)) return null;
-  const base = path12__namespace.resolve(directory);
-  const resolved = path12__namespace.resolve(base, filename);
+  if (path13__namespace.isAbsolute(filename)) return null;
+  const base = path13__namespace.resolve(directory);
+  const resolved = path13__namespace.resolve(base, filename);
   const caseInsensitive = process.platform === "win32" || process.platform === "darwin";
-  const prefix = caseInsensitive ? `${base}${path12__namespace.sep}`.toLowerCase() : `${base}${path12__namespace.sep}`;
+  const prefix = caseInsensitive ? `${base}${path13__namespace.sep}`.toLowerCase() : `${base}${path13__namespace.sep}`;
   const candidate = caseInsensitive ? resolved.toLowerCase() : resolved;
   return candidate.startsWith(prefix) ? resolved : null;
 }
 function findStagingDirectory(config) {
-  const tmpDir = path12__namespace.resolve(config.cwd, config.tmpDir);
+  const tmpDir = path13__namespace.resolve(config.cwd, config.tmpDir);
   let entries;
   try {
-    entries = fs11__namespace.readdirSync(tmpDir);
+    entries = fs12__namespace.readdirSync(tmpDir);
   } catch {
     return null;
   }
   const runs = entries.filter((name) => name.startsWith("run-")).sort();
   const newest = runs[runs.length - 1];
-  return newest ? path12__namespace.join(tmpDir, newest) : null;
+  return newest ? path13__namespace.join(tmpDir, newest) : null;
 }
 function describeMissingManifest(config, manifestPath) {
-  const outDir = path12__namespace.resolve(config.cwd, config.outDir);
-  const markerPath = path12__namespace.join(outDir, ".codebase-snapshot");
+  const outDir = path13__namespace.resolve(config.cwd, config.outDir);
+  const markerPath = path13__namespace.join(outDir, ".codebase-snapshot");
   let marker2 = null;
   try {
-    if (fs11__namespace.existsSync(markerPath)) {
-      const parsed = JSON.parse(fs11__namespace.readFileSync(markerPath, "utf8"));
+    if (fs12__namespace.existsSync(markerPath)) {
+      const parsed = JSON.parse(fs12__namespace.readFileSync(markerPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         marker2 = parsed;
       }
@@ -5010,14 +5012,14 @@ function sha256Hex(buffer) {
 }
 var VERIFY_SNIFF_MAX_BYTES = 8 * 1024 * 1024;
 function wouldNowBeIncluded(cwd, relativePath, reason) {
-  const absolutePath = path12__namespace.join(cwd, relativePath);
+  const absolutePath = path13__namespace.join(cwd, relativePath);
   try {
-    const stats = fs11__namespace.statSync(absolutePath);
+    const stats = fs12__namespace.statSync(absolutePath);
     if (!stats.isFile()) return false;
     if (isBinaryFile(absolutePath)) return false;
     if (reason !== "binary") return true;
     if (stats.size > VERIFY_SNIFF_MAX_BYTES) return false;
-    return !decodeText(fs11__namespace.readFileSync(absolutePath)).binary;
+    return !decodeText(fs12__namespace.readFileSync(absolutePath)).binary;
   } catch {
     return false;
   }
@@ -5075,8 +5077,8 @@ function describeManifestShapeProblem(value) {
 function validateSnapshot(configInput) {
   assertUsableConfigInput(configInput);
   const config = isResolvedConfig(configInput) ? normalizeResolvedConfig(configInput) : resolveConfig(configInput);
-  const manifestPath = path12__namespace.resolve(config.cwd, config.outDir, "manifest.json");
-  if (!fs11__namespace.existsSync(manifestPath)) {
+  const manifestPath = path13__namespace.resolve(config.cwd, config.outDir, "manifest.json");
+  if (!fs12__namespace.existsSync(manifestPath)) {
     return {
       valid: false,
       manifestPresent: false,
@@ -5087,7 +5089,7 @@ function validateSnapshot(configInput) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs11__namespace.readFileSync(manifestPath, "utf8"));
+    manifest = JSON.parse(fs12__namespace.readFileSync(manifestPath, "utf8"));
   } catch (err) {
     return {
       valid: false,
@@ -5109,7 +5111,7 @@ function validateSnapshot(configInput) {
   }
   const drift = emptyDrift();
   const warnings = [];
-  const snapshotDir = path12__namespace.resolve(config.cwd, config.outDir);
+  const snapshotDir = path13__namespace.resolve(config.cwd, config.outDir);
   const manifestFileMap = /* @__PURE__ */ new Map();
   for (const file of manifest.files) {
     if (file && typeof file.relativePath === "string") {
@@ -5143,7 +5145,7 @@ function validateSnapshot(configInput) {
     }
     let diskHash;
     try {
-      diskHash = sha256Hex(fs11__namespace.readFileSync(path12__namespace.join(config.cwd, diskFile)));
+      diskHash = sha256Hex(fs12__namespace.readFileSync(path13__namespace.join(config.cwd, diskFile)));
     } catch (err) {
       if (err.code === "ENOENT") {
         drift.missingOnDisk.push(diskFile);
@@ -5167,7 +5169,7 @@ function validateSnapshot(configInput) {
     }
     let statFailure = null;
     try {
-      fs11__namespace.statSync(confined);
+      fs12__namespace.statSync(confined);
     } catch (err) {
       statFailure = err;
     }
@@ -5187,7 +5189,7 @@ function validateSnapshot(configInput) {
     ...Object.values(config.budgets.byLayer)
   );
   const partNames = /* @__PURE__ */ new Set();
-  const partsDir = path12__namespace.join(snapshotDir, "parts");
+  const partsDir = path13__namespace.join(snapshotDir, "parts");
   for (const part of manifest.parts) {
     if (!part || typeof part.filename !== "string") continue;
     partNames.add(part.filename);
@@ -5202,7 +5204,7 @@ function validateSnapshot(configInput) {
     }
     let buffer;
     try {
-      buffer = fs11__namespace.readFileSync(partPath);
+      buffer = fs12__namespace.readFileSync(partPath);
     } catch {
       drift.partIssues.push({ part: part.filename, issue: "missing from snapshot/parts" });
       continue;
@@ -5416,9 +5418,9 @@ function validateSnapshot(configInput) {
     ["full-codebase.md", manifest.artifacts?.fullMarkdown]
   ]) {
     if (!artifact) continue;
-    const artifactPath = path12__namespace.join(snapshotDir, key);
+    const artifactPath = path13__namespace.join(snapshotDir, key);
     try {
-      const buffer = fs11__namespace.readFileSync(artifactPath);
+      const buffer = fs12__namespace.readFileSync(artifactPath);
       if (sha256Hex(buffer) !== artifact.sha256 || buffer.length !== artifact.byteSize) {
         drift.partIssues.push({ part: key, issue: "artifact does not match its recorded digest" });
       }
@@ -5488,12 +5490,168 @@ function validateSnapshot(configInput) {
 
 // src/version.ts
 var GENERATOR_NAME = "codebase-snapshot";
-var GENERATOR_VERSION = "0.9.5";
+var GENERATOR_VERSION = "0.9.6";
 var LEGACY_GENERATOR_NAMES = ["@ankurhalder/codebase-snapshot"];
 function isOurGeneratorName(name) {
   if (typeof name !== "string") return false;
   return name === GENERATOR_NAME || LEGACY_GENERATOR_NAMES.includes(name);
 }
+var PACKAGE_LATEST_URL = "https://registry.npmjs.org/codebase-snapshot/latest";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FAILURE_INTERVAL_MS = 60 * 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 1200;
+function versionParts(value) {
+  const core = value.trim().replace(/^v/i, "").split("-")[0];
+  return core.split(".").map((part) => {
+    const parsed = Number(part);
+    return Number.isFinite(parsed) ? parsed : 0;
+  });
+}
+function isNewer(candidate, current) {
+  const left = versionParts(candidate);
+  const right = versionParts(current);
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const a = left[index] ?? 0;
+    const b = right[index] ?? 0;
+    if (a !== b) return a > b;
+  }
+  return false;
+}
+function cacheDirectory(env = process.env, platform = process.platform) {
+  if (platform === "win32") {
+    const base2 = env.LOCALAPPDATA ?? path13__namespace.join(os__namespace.homedir(), "AppData", "Local");
+    return path13__namespace.join(base2, "codebase-snapshot");
+  }
+  if (platform === "darwin") {
+    return path13__namespace.join(os__namespace.homedir(), "Library", "Caches", "codebase-snapshot");
+  }
+  const base = env.XDG_CACHE_HOME ?? path13__namespace.join(os__namespace.homedir(), ".cache");
+  return path13__namespace.join(base, "codebase-snapshot");
+}
+function cacheFilePath(env = process.env) {
+  return path13__namespace.join(cacheDirectory(env), "update-check.json");
+}
+function shouldCheck(argv, env) {
+  const disabled = ["1", "true", "yes"].includes(
+    String(env.CODEBASE_SNAPSHOT_NO_UPDATE_CHECK ?? "").toLowerCase()
+  );
+  if (disabled) return false;
+  if (env.CI !== void 0 && env.CI !== "" && env.CI !== "false" && env.CI !== "0") return false;
+  const args = argv.map((argument) => argument.toLowerCase());
+  if (args.includes("--no-update-check")) return false;
+  for (const skip of ["mcp", "describe", "skill", "--version", "-v", "--help", "-h"]) {
+    if (args.includes(skip)) return false;
+  }
+  if (args.some((argument) => argument.includes("json"))) return false;
+  return true;
+}
+function readCache(file) {
+  let raw;
+  try {
+    raw = fs12__namespace.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const candidate = parsed;
+    if (typeof candidate.checkedAt !== "number") return null;
+    const latest = typeof candidate.latest === "string" ? candidate.latest : null;
+    return { checkedAt: candidate.checkedAt, latest };
+  } catch {
+    return null;
+  }
+}
+function writeCache(file, entry) {
+  try {
+    fs12__namespace.mkdirSync(path13__namespace.dirname(file), { recursive: true });
+    fs12__namespace.writeFileSync(file, `${JSON.stringify(entry)}
+`, "utf8");
+  } catch {
+  }
+}
+function fetchLatestVersion(url = PACKAGE_LATEST_URL, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve5) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve5(value);
+    };
+    const request = https__namespace.get(
+      url,
+      {
+        headers: {
+          accept: "application/json",
+          "user-agent": "codebase-snapshot (update check)"
+        }
+      },
+      (response) => {
+        if (response.statusCode !== 200) {
+          response.resume();
+          finish(null);
+          return;
+        }
+        let body = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          body += chunk;
+          if (body.length > 64 * 1024) {
+            request.destroy();
+            finish(null);
+          }
+        });
+        response.on("end", () => {
+          try {
+            const parsed = JSON.parse(body);
+            finish(typeof parsed.version === "string" ? parsed.version : null);
+          } catch {
+            finish(null);
+          }
+        });
+      }
+    );
+    request.on("error", () => finish(null));
+    request.setTimeout(timeoutMs, () => {
+      request.destroy();
+      finish(null);
+    });
+  });
+}
+async function checkForUpdate(options) {
+  if (options.enabled === false) return null;
+  const now = options.now ?? (() => Date.now());
+  const fetchLatest = options.fetchLatest ?? fetchLatestVersion;
+  let latest = null;
+  try {
+    const cached = readCache(options.cacheFile);
+    let needsFetch = cached === null;
+    if (cached) {
+      const age = now() - cached.checkedAt;
+      if (cached.latest === null) {
+        needsFetch = age >= FAILURE_INTERVAL_MS;
+      } else {
+        latest = cached.latest;
+        needsFetch = age >= CHECK_INTERVAL_MS;
+      }
+    }
+    if (needsFetch) {
+      const fetched = await fetchLatest(PACKAGE_LATEST_URL, REQUEST_TIMEOUT_MS);
+      writeCache(options.cacheFile, { checkedAt: now(), latest: fetched });
+      latest = fetched;
+    }
+  } catch {
+    return null;
+  }
+  if (!latest) return null;
+  return isNewer(latest, options.current) ? { current: options.current, latest } : null;
+}
+function formatUpdateNotice(notice) {
+  return `\u2191 codebase-snapshot ${notice.latest} is available \u2014 you have ${notice.current}.
+  npm install -g codebase-snapshot`;
+}
 function describeMatcher(matcher) {
   if (typeof matcher === "string") return matcher;
   if (matcher instanceof RegExp) return String(matcher);
@@ -5503,10 +5661,10 @@ function describeMatcher(matcher) {
   return String(matcher);
 }
 function normalizeTarget(cwd, target) {
-  const absolute = path12__namespace.resolve(cwd, target);
-  const relative7 = path12__namespace.relative(cwd, absolute);
-  if (relative7.startsWith("..") || path12__namespace.isAbsolute(relative7)) return target;
-  return relative7.split(path12__namespace.sep).join("/");
+  const absolute = path13__namespace.resolve(cwd, target);
+  const relative7 = path13__namespace.relative(cwd, absolute);
+  if (relative7.startsWith("..") || path13__namespace.isAbsolute(relative7)) return target;
+  return relative7.split(path13__namespace.sep).join("/");
 }
 function findRuleMatch(rules, relativePath) {
   return rules.find(
@@ -5525,20 +5683,20 @@ function findRecordedAncestor(skipped, relative7, maskedPath2) {
   return nearest;
 }
 function readManifest2(config) {
-  const manifestPath = path12__namespace.resolve(config.cwd, config.outDir, "manifest.json");
+  const manifestPath = path13__namespace.resolve(config.cwd, config.outDir, "manifest.json");
   try {
-    return JSON.parse(fs11__namespace.readFileSync(manifestPath, "utf8"));
+    return JSON.parse(fs12__namespace.readFileSync(manifestPath, "utf8"));
   } catch {
     return null;
   }
 }
 function explainPath(config, target) {
   const relative7 = normalizeTarget(config.cwd, target);
-  const absolute = path12__namespace.join(config.cwd, relative7);
+  const absolute = path13__namespace.join(config.cwd, relative7);
   const maskedPath2 = findSecretInPath(relative7, config.secretRules)?.masked ?? relative7;
   const result = {
     path: maskedPath2,
-    exists: fs11__namespace.existsSync(absolute),
+    exists: fs12__namespace.existsSync(absolute),
     included: false
   };
   const collection = collectFiles(config.cwd, {
@@ -5549,7 +5707,7 @@ function explainPath(config, target) {
     // Same exclusion `generate` applies, so `explain` never says "not-discovered" about a file
     // that is only missing because the walker dropped the tool's own output directory.
     toolOwnedPaths: [config.outDir, config.tmpDir].map(
-      (directory) => path12__namespace.relative(config.cwd, path12__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
+      (directory) => path13__namespace.relative(config.cwd, path13__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
     ).filter((relative8) => relative8.length > 0 && !relative8.startsWith(".."))
   });
   if (!collection.files.includes(relative7)) {
@@ -5588,8 +5746,8 @@ function explainPath(config, target) {
   if (layerRule) result.layerMatch = describeMatcher(layerRule.match);
   const kindRule = findRuleMatch(config.kinds, relative7);
   if (kindRule) result.kindMatch = describeMatcher(kindRule.match);
-  if (fs11__namespace.existsSync(absolute) && fs11__namespace.statSync(absolute).isFile()) {
-    const buffer = fs11__namespace.readFileSync(absolute);
+  if (fs12__namespace.existsSync(absolute) && fs12__namespace.statSync(absolute).isFile()) {
+    const buffer = fs12__namespace.readFileSync(absolute);
     const decoded = decodeText(buffer);
     if (decoded.binary) {
       result.included = false;
@@ -5837,14 +5995,14 @@ function compareManifests(before, after) {
 function loadManifest(target) {
   let isDirectory;
   try {
-    isDirectory = fs11__namespace.statSync(target).isDirectory();
+    isDirectory = fs12__namespace.statSync(target).isDirectory();
   } catch {
     throw new Error(`No snapshot found at ${target}: the path does not exist.`);
   }
-  const manifestPath = isDirectory ? path12__namespace.join(target, "manifest.json") : target;
+  const manifestPath = isDirectory ? path13__namespace.join(target, "manifest.json") : target;
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(manifestPath, "utf8");
+    raw = fs12__namespace.readFileSync(manifestPath, "utf8");
   } catch {
     throw new Error(`Could not read a manifest at ${manifestPath}.`);
   }
@@ -5901,15 +6059,15 @@ function renderDiffText(diff) {
 function appendGitignoreEntries(cwd, entries) {
   const wanted = [...new Set(entries)].filter((entry) => entry.trim().length > 0);
   if (wanted.length === 0) return { added: [], note: null };
-  const ignorePath = path12__namespace.join(cwd, ".gitignore");
+  const ignorePath = path13__namespace.join(cwd, ".gitignore");
   const manual = `Add ${wanted.map((entry) => `"${entry}"`).join(" and ")} to your .gitignore yourself.`;
   let existing = "";
   try {
-    if (fs11__namespace.existsSync(ignorePath)) {
-      if (fs11__namespace.statSync(ignorePath).isDirectory()) {
+    if (fs12__namespace.existsSync(ignorePath)) {
+      if (fs12__namespace.statSync(ignorePath).isDirectory()) {
         return { added: [], note: `${ignorePath} is a directory, so it was not updated. ${manual}` };
       }
-      existing = fs11__namespace.readFileSync(ignorePath, "utf8");
+      existing = fs12__namespace.readFileSync(ignorePath, "utf8");
     }
   } catch (err) {
     return {
@@ -5922,7 +6080,7 @@ function appendGitignoreEntries(cwd, entries) {
   if (added.length === 0) return { added: [], note: null };
   const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
   try {
-    fs11__namespace.writeFileSync(ignorePath, `${existing}${prefix}${added.join("\n")}
+    fs12__namespace.writeFileSync(ignorePath, `${existing}${prefix}${added.join("\n")}
 `, "utf8");
   } catch (err) {
     return { added: [], note: `${err.message}. ${manual}` };
@@ -6349,10 +6507,10 @@ var CONFIG_CANDIDATES = [
 ];
 function chooseConfigFileName(cwd) {
   if (!supportsTypeScriptImports()) return "snapshot.config.mjs";
-  const pkgPath = path12__namespace.join(cwd, "package.json");
-  if (!fs11__namespace.existsSync(pkgPath)) return "snapshot.config.mjs";
+  const pkgPath = path13__namespace.join(cwd, "package.json");
+  if (!fs12__namespace.existsSync(pkgPath)) return "snapshot.config.mjs";
   try {
-    const parsed = JSON.parse(fs11__namespace.readFileSync(pkgPath, "utf8"));
+    const parsed = JSON.parse(fs12__namespace.readFileSync(pkgPath, "utf8"));
     return parsed.type === "module" ? "snapshot.config.ts" : "snapshot.config.mjs";
   } catch {
     return "snapshot.config.mjs";
@@ -6366,7 +6524,7 @@ var SIZE_CHOICES = [
 ];
 function packageJsonHasConfig(cwd) {
   try {
-    const parsed = JSON.parse(fs11__namespace.readFileSync(path12__namespace.join(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(fs12__namespace.readFileSync(path13__namespace.join(cwd, "package.json"), "utf8"));
     return typeof parsed.snapshot === "object" && parsed.snapshot !== null && !Array.isArray(parsed.snapshot);
   } catch {
     return false;
@@ -6387,7 +6545,7 @@ function artifactAnswers(options) {
 }
 function topLevelDirs(cwd) {
   try {
-    return fs11__namespace.readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
+    return fs12__namespace.readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
   } catch {
     return [];
   }
@@ -6400,7 +6558,7 @@ function describeJsonValue(value) {
 }
 function writeFileOrExplain(target, content) {
   try {
-    fs11__namespace.writeFileSync(target, content, "utf8");
+    fs12__namespace.writeFileSync(target, content, "utf8");
   } catch (err) {
     const code = err.code;
     const reason = code === "EACCES" || code === "EPERM" || code === "EROFS" ? `permission denied (${code})` : code === "EISDIR" ? "it is a directory" : `${err.message}`;
@@ -6411,7 +6569,7 @@ function canWriteModuleConfig(name, cwd) {
   if (name.endsWith(".mjs") || name.endsWith(".ts")) return true;
   if (!name.endsWith(".js")) return false;
   try {
-    const parsed = JSON.parse(fs11__namespace.readFileSync(path12__namespace.join(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(fs12__namespace.readFileSync(path13__namespace.join(cwd, "package.json"), "utf8"));
     return parsed.type === "module";
   } catch {
     return false;
@@ -6446,19 +6604,19 @@ function serializePackageJson(raw, value) {
   return `${text2}${raw.endsWith("\n") ? crlf ? "\r\n" : "\n" : ""}`;
 }
 function updatePackageJson(cwd, notes) {
-  const packagePath = path12__namespace.join(cwd, "package.json");
+  const packagePath = path13__namespace.join(cwd, "package.json");
   const unchanged = {
     scripts: [],
     dependency: { name: GENERATOR_NAME, range: null, added: false }
   };
-  if (!fs11__namespace.existsSync(packagePath)) {
+  if (!fs12__namespace.existsSync(packagePath)) {
     notes.push("No package.json found, so npm scripts and the devDependency were not added.");
     return unchanged;
   }
   let raw;
   let parsed;
   try {
-    raw = fs11__namespace.readFileSync(packagePath, "utf8");
+    raw = fs12__namespace.readFileSync(packagePath, "utf8");
     parsed = JSON.parse(raw);
   } catch {
     notes.push("Could not parse package.json; npm scripts and the devDependency were not added.");
@@ -6750,7 +6908,7 @@ async function runInit(options) {
   const configText = renderConfig(answers);
   const preferredName = chooseConfigFileName(options.cwd);
   const presentConfigs = CONFIG_CANDIDATES.filter(
-    (name) => fs11__namespace.existsSync(path12__namespace.join(options.cwd, name))
+    (name) => fs12__namespace.existsSync(path13__namespace.join(options.cwd, name))
   );
   const present = presentConfigs[0] ?? null;
   if (presentConfigs.length > 1) {
@@ -6759,7 +6917,7 @@ async function runInit(options) {
     );
   }
   const configName = present !== null && options.force ? present : preferredName;
-  const configPath = path12__namespace.join(options.cwd, configName);
+  const configPath = path13__namespace.join(options.cwd, configName);
   const reused = present !== null && options.force !== true && options.reuseConfig === true;
   if (reused) notes.push(`Kept the existing ${present} instead of writing a new one.`);
   if (options.dryRun) {
@@ -6792,7 +6950,7 @@ async function runInit(options) {
       'package.json already defines a "snapshot" config. Remove that key, or re-run with --force to write a config file that takes precedence over it.'
     );
   }
-  if (fs11__namespace.existsSync(configPath) && !options.force && !reused) {
+  if (fs12__namespace.existsSync(configPath) && !options.force && !reused) {
     throw new Error(`${configName} already exists. Re-run with --force to replace it.`);
   }
   if (!reused) writeFileOrExplain(configPath, configText);
@@ -6814,9 +6972,9 @@ async function runInit(options) {
   };
 }
 function describeTarget(cwd) {
-  const relative7 = path12__namespace.relative(process.cwd(), cwd);
+  const relative7 = path13__namespace.relative(process.cwd(), cwd);
   if (relative7 === "") return "this directory";
-  if (relative7.startsWith("..") || path12__namespace.isAbsolute(relative7)) return cwd;
+  if (relative7.startsWith("..") || path13__namespace.isAbsolute(relative7)) return cwd;
   return relative7;
 }
 function firstRunMessage(reason, cwd) {
@@ -6840,7 +6998,7 @@ function planFirstRun(facts) {
 var NOT_CONTENT = /* @__PURE__ */ new Set([".git", ".hg", ".svn", ".bzr", ".DS_Store", "Thumbs.db"]);
 function isEffectivelyEmpty(cwd) {
   try {
-    return fs11__namespace.readdirSync(cwd).every((entry) => NOT_CONTENT.has(entry));
+    return fs12__namespace.readdirSync(cwd).every((entry) => NOT_CONTENT.has(entry));
   } catch {
     return false;
   }
@@ -6848,7 +7006,7 @@ function isEffectivelyEmpty(cwd) {
 function hasPriorSnapshot(cwd, outDir) {
   let parsed;
   try {
-    parsed = JSON.parse(fs11__namespace.readFileSync(path12__namespace.join(cwd, outDir, ".codebase-snapshot"), "utf8"));
+    parsed = JSON.parse(fs12__namespace.readFileSync(path13__namespace.join(cwd, outDir, ".codebase-snapshot"), "utf8"));
   } catch {
     return false;
   }
@@ -6936,13 +7094,13 @@ function buildImportResolver(files) {
     const relativePath = file.relativePath;
     remember(byPath, relativePath, relativePath);
     remember(byPathFolded, relativePath.toLowerCase(), relativePath);
-    const extension = path12__namespace.posix.extname(relativePath);
+    const extension = path13__namespace.posix.extname(relativePath);
     if (!SOURCE_EXTENSIONS.has(extension)) continue;
     const stem = relativePath.slice(0, -extension.length);
     remember(byStem, stem, relativePath);
     remember(byStemFolded, stem.toLowerCase(), relativePath);
-    if (path12__namespace.posix.basename(stem) === "index") {
-      const directory = path12__namespace.posix.dirname(stem);
+    if (path13__namespace.posix.basename(stem) === "index") {
+      const directory = path13__namespace.posix.dirname(stem);
       remember(byStem, directory, relativePath);
       remember(byStemFolded, directory.toLowerCase(), relativePath);
     }
@@ -6951,8 +7109,8 @@ function buildImportResolver(files) {
 }
 function resolveSpecifier(fromFile, specifier, resolver) {
   if (!RELATIVE_SPECIFIER.test(specifier)) return null;
-  const joined = path12__namespace.posix.normalize(
-    path12__namespace.posix.join(path12__namespace.posix.dirname(fromFile), specifier)
+  const joined = path13__namespace.posix.normalize(
+    path13__namespace.posix.join(path13__namespace.posix.dirname(fromFile), specifier)
   );
   const exact = (key) => resolver.byPath.get(key) ?? resolver.byPathFolded.get(key.toLowerCase()) ?? null;
   const direct = exact(joined);
@@ -7045,11 +7203,11 @@ function verifyInMemory(files, parts, maxPartBytes) {
   return errors;
 }
 function resolveSafeOutputDirs(config) {
-  const cwd = path12__namespace.resolve(config.cwd);
-  const outDir = path12__namespace.resolve(cwd, config.outDir);
-  const tmpDir = path12__namespace.resolve(cwd, config.tmpDir);
-  const root = path12__namespace.parse(cwd).root;
-  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path12__namespace.sep}`);
+  const cwd = path13__namespace.resolve(config.cwd);
+  const outDir = path13__namespace.resolve(cwd, config.outDir);
+  const tmpDir = path13__namespace.resolve(cwd, config.tmpDir);
+  const root = path13__namespace.parse(cwd).root;
+  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path13__namespace.sep}`);
   const reject = (reason) => {
     throw new Error(
       `Refusing to generate: ${reason}. outDir=${outDir} tmpDir=${tmpDir} cwd=${cwd}`
@@ -7105,14 +7263,14 @@ function listEntries(dir) {
   const walk = (absolute, prefix) => {
     let children;
     try {
-      children = fs11__namespace.readdirSync(absolute, { withFileTypes: true });
+      children = fs12__namespace.readdirSync(absolute, { withFileTypes: true });
     } catch {
       return;
     }
     for (const child of children) {
       const relative7 = prefix === "" ? child.name : `${prefix}/${child.name}`;
       entries.push(relative7);
-      if (child.isDirectory()) walk(path12__namespace.join(absolute, child.name), relative7);
+      if (child.isDirectory()) walk(path13__namespace.join(absolute, child.name), relative7);
     }
   };
   walk(dir, "");
@@ -7129,28 +7287,28 @@ function markerPayload(dir, state, id, createdAt) {
     pid: process.pid,
     entries: listEntries(dir)
   };
-  const manifestPath = path12__namespace.join(dir, "manifest.json");
-  if (fs11__namespace.existsSync(manifestPath)) {
-    marker2.manifestSha256 = sha256Hex2(fs11__namespace.readFileSync(manifestPath));
+  const manifestPath = path13__namespace.join(dir, "manifest.json");
+  if (fs12__namespace.existsSync(manifestPath)) {
+    marker2.manifestSha256 = sha256Hex2(fs12__namespace.readFileSync(manifestPath));
   }
   return marker2;
 }
 function writeOwnershipMarker(dir, marker2) {
-  fs11__namespace.writeFileSync(
-    path12__namespace.join(dir, OWNERSHIP_MARKER),
+  fs12__namespace.writeFileSync(
+    path13__namespace.join(dir, OWNERSHIP_MARKER),
     `${JSON.stringify(marker2, null, 2)}
 `,
     "utf8"
   );
 }
 function readOwnershipMarker(dir) {
-  const markerPath = path12__namespace.join(dir, OWNERSHIP_MARKER);
-  if (!fs11__namespace.existsSync(markerPath)) {
+  const markerPath = path13__namespace.join(dir, OWNERSHIP_MARKER);
+  if (!fs12__namespace.existsSync(markerPath)) {
     return { marker: null, problem: "it holds no .codebase-snapshot marker" };
   }
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(markerPath, "utf8");
+    raw = fs12__namespace.readFileSync(markerPath, "utf8");
   } catch {
     return { marker: null, problem: "its .codebase-snapshot marker could not be read" };
   }
@@ -7218,11 +7376,11 @@ function assessSnapshotDirectory(dir) {
       marker: marker2
     };
   }
-  const manifestPath = path12__namespace.join(dir, "manifest.json");
-  if (fs11__namespace.existsSync(manifestPath)) {
+  const manifestPath = path13__namespace.join(dir, "manifest.json");
+  if (fs12__namespace.existsSync(manifestPath)) {
     let raw;
     try {
-      raw = fs11__namespace.readFileSync(manifestPath, "utf8");
+      raw = fs12__namespace.readFileSync(manifestPath, "utf8");
     } catch {
       return {
         owned: false,
@@ -7304,13 +7462,13 @@ function containsNoFiles(dir) {
     const current = pending.pop();
     let entries;
     try {
-      entries = fs11__namespace.readdirSync(current, { withFileTypes: true });
+      entries = fs12__namespace.readdirSync(current, { withFileTypes: true });
     } catch {
       return false;
     }
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        pending.push(path12__namespace.join(current, entry.name));
+        pending.push(path13__namespace.join(current, entry.name));
       } else if (!IGNORABLE_ENTRIES.has(entry.name)) {
         return false;
       }
@@ -7319,13 +7477,13 @@ function containsNoFiles(dir) {
   return true;
 }
 function assertReplaceable(target, label, secretRules) {
-  if (!fs11__namespace.existsSync(target)) return;
-  if (!fs11__namespace.statSync(target).isDirectory()) {
+  if (!fs12__namespace.existsSync(target)) return;
+  if (!fs12__namespace.statSync(target).isDirectory()) {
     throw new Error(
       `Refusing to write into ${label} ${target}: it exists but is not a directory.`
     );
   }
-  const entries = fs11__namespace.readdirSync(target);
+  const entries = fs12__namespace.readdirSync(target);
   if (entries.length === 0) return;
   if (entries.every((name) => IGNORABLE_ENTRIES.has(name))) return;
   if (containsNoFiles(target)) return;
@@ -7345,18 +7503,18 @@ function assertReplaceable(target, label, secretRules) {
   );
 }
 function assertStagingRootUsable(tmpDir, secretRules) {
-  if (!fs11__namespace.existsSync(tmpDir)) return;
-  if (!fs11__namespace.statSync(tmpDir).isDirectory()) {
+  if (!fs12__namespace.existsSync(tmpDir)) return;
+  if (!fs12__namespace.statSync(tmpDir).isDirectory()) {
     throw new Error(`Refusing to write into tmpDir ${tmpDir}: it exists but is not a directory.`);
   }
-  const entries = fs11__namespace.readdirSync(tmpDir);
+  const entries = fs12__namespace.readdirSync(tmpDir);
   if (entries.length === 0) return;
   const foreign = entries.filter((name) => {
-    const full = path12__namespace.join(tmpDir, name);
+    const full = path13__namespace.join(tmpDir, name);
     if (!name.startsWith(RUN_DIR_PREFIX)) return true;
     let stats;
     try {
-      stats = fs11__namespace.statSync(full);
+      stats = fs12__namespace.statSync(full);
     } catch {
       return true;
     }
@@ -7364,7 +7522,7 @@ function assertStagingRootUsable(tmpDir, secretRules) {
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) return false;
     try {
-      return fs11__namespace.readdirSync(full).length > 0;
+      return fs12__namespace.readdirSync(full).length > 0;
     } catch {
       return true;
     }
@@ -7379,13 +7537,13 @@ function assertStagingRootUsable(tmpDir, secretRules) {
 function cleanStaleRunDirs(tmpDir) {
   let entries;
   try {
-    entries = fs11__namespace.readdirSync(tmpDir);
+    entries = fs12__namespace.readdirSync(tmpDir);
   } catch {
     return;
   }
   for (const name of entries) {
     if (!name.startsWith(RUN_DIR_PREFIX)) continue;
-    const full = path12__namespace.join(tmpDir, name);
+    const full = path13__namespace.join(tmpDir, name);
     const { marker: marker2 } = readOwnershipMarker(full);
     if (marker2) {
       const created = Date.parse(marker2.createdAt);
@@ -7393,33 +7551,33 @@ function cleanStaleRunDirs(tmpDir) {
       const abandoned = typeof marker2.pid === "number" && !isProcessAlive(marker2.pid);
       if (aged || abandoned) {
         try {
-          fs11__namespace.rmSync(full, { recursive: true, force: true });
+          fs12__namespace.rmSync(full, { recursive: true, force: true });
         } catch {
         }
       }
       continue;
     }
     try {
-      if (fs11__namespace.readdirSync(full).length === 0) fs11__namespace.rmSync(full, { recursive: true, force: true });
+      if (fs12__namespace.readdirSync(full).length === 0) fs12__namespace.rmSync(full, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function removeIfEmpty(dir) {
   try {
-    if (fs11__namespace.readdirSync(dir).length === 0) fs11__namespace.rmSync(dir, { recursive: true, force: true });
+    if (fs12__namespace.readdirSync(dir).length === 0) fs12__namespace.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
 function ensureParentDirectory(target, label) {
-  const parent = path12__namespace.dirname(target);
-  if (fs11__namespace.existsSync(parent) && !fs11__namespace.statSync(parent).isDirectory()) {
+  const parent = path13__namespace.dirname(target);
+  if (fs12__namespace.existsSync(parent) && !fs12__namespace.statSync(parent).isDirectory()) {
     throw new Error(
       `Refusing to create ${label} ${target}: ${parent} exists but is not a directory.`
     );
   }
   try {
-    fs11__namespace.mkdirSync(parent, { recursive: true });
+    fs12__namespace.mkdirSync(parent, { recursive: true });
   } catch (err) {
     throw new Error(
       `Refusing to create ${label} ${target}: its parent ${parent} could not be created (${err.message}).`
@@ -7428,7 +7586,7 @@ function ensureParentDirectory(target, label) {
 }
 function acquireRunLock(stagingRoot) {
   const key = lockKeyFor(stagingRoot);
-  const lockPath = path12__namespace.join(os__namespace.tmpdir(), `codebase-snapshot-${key}.lock`);
+  const lockPath = path13__namespace.join(os__namespace.tmpdir(), `codebase-snapshot-${key}.lock`);
   const payload = `${JSON.stringify({
     pid: process.pid,
     stagingRoot,
@@ -7437,22 +7595,22 @@ function acquireRunLock(stagingRoot) {
 `;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = fs11__namespace.openSync(lockPath, "wx");
+      const handle = fs12__namespace.openSync(lockPath, "wx");
       try {
-        fs11__namespace.writeSync(handle, payload);
+        fs12__namespace.writeSync(handle, payload);
       } finally {
-        fs11__namespace.closeSync(handle);
+        fs12__namespace.closeSync(handle);
       }
       return () => {
         try {
-          fs11__namespace.rmSync(lockPath, { force: true });
+          fs12__namespace.rmSync(lockPath, { force: true });
         } catch {
         }
       };
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       if (attempt === 0 && lockOwnerIsGone(lockPath)) {
-        fs11__namespace.rmSync(lockPath, { force: true });
+        fs12__namespace.rmSync(lockPath, { force: true });
         continue;
       }
       throw new Error(
@@ -7465,7 +7623,7 @@ function acquireRunLock(stagingRoot) {
 function lockKeyFor(stagingRoot) {
   let key = stagingRoot;
   try {
-    key = fs11__namespace.realpathSync(stagingRoot);
+    key = fs12__namespace.realpathSync(stagingRoot);
   } catch {
   }
   if (process.platform === "win32" || process.platform === "darwin") key = key.toLowerCase();
@@ -7474,7 +7632,7 @@ function lockKeyFor(stagingRoot) {
 function lockOwnerIsGone(lockPath) {
   let raw;
   try {
-    raw = fs11__namespace.readFileSync(lockPath, "utf8");
+    raw = fs12__namespace.readFileSync(lockPath, "utf8");
   } catch {
     return false;
   }
@@ -7494,12 +7652,12 @@ function lockOwnerIsGone(lockPath) {
 }
 function writeManifestAtomically(manifestPath, manifest) {
   const tempPath = `${manifestPath}.${process.pid}.tmp`;
-  fs11__namespace.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
+  fs12__namespace.writeFileSync(tempPath, JSON.stringify(manifest, null, 2), "utf8");
   try {
-    fs11__namespace.renameSync(tempPath, manifestPath);
+    fs12__namespace.renameSync(tempPath, manifestPath);
   } catch (err) {
     try {
-      fs11__namespace.rmSync(tempPath, { force: true });
+      fs12__namespace.rmSync(tempPath, { force: true });
     } catch {
     }
     throw err;
@@ -7522,31 +7680,31 @@ function swapIntoPlace(stagingDir, outDir) {
 }
 function swapOnce(stagingDir, outDir) {
   const backupDir = `${outDir}.backup-${process.pid}-${Date.now()}`;
-  const hadPrevious = fs11__namespace.existsSync(outDir);
-  if (hadPrevious) fs11__namespace.renameSync(outDir, backupDir);
+  const hadPrevious = fs12__namespace.existsSync(outDir);
+  if (hadPrevious) fs12__namespace.renameSync(outDir, backupDir);
   try {
     try {
-      fs11__namespace.renameSync(stagingDir, outDir);
+      fs12__namespace.renameSync(stagingDir, outDir);
     } catch (err) {
       if (err.code !== "EXDEV") throw err;
       const partialDir = `${outDir}.partial-${process.pid}-${Date.now()}`;
       try {
-        fs11__namespace.cpSync(stagingDir, partialDir, { recursive: true });
-        fs11__namespace.renameSync(partialDir, outDir);
-        fs11__namespace.rmSync(stagingDir, { recursive: true, force: true });
+        fs12__namespace.cpSync(stagingDir, partialDir, { recursive: true });
+        fs12__namespace.renameSync(partialDir, outDir);
+        fs12__namespace.rmSync(stagingDir, { recursive: true, force: true });
       } catch (copyErr) {
         try {
-          fs11__namespace.rmSync(partialDir, { recursive: true, force: true });
+          fs12__namespace.rmSync(partialDir, { recursive: true, force: true });
         } catch {
         }
         throw copyErr;
       }
     }
-    if (hadPrevious) fs11__namespace.rmSync(backupDir, { recursive: true, force: true });
+    if (hadPrevious) fs12__namespace.rmSync(backupDir, { recursive: true, force: true });
   } catch (err) {
-    if (hadPrevious && fs11__namespace.existsSync(backupDir)) {
-      if (fs11__namespace.existsSync(outDir)) fs11__namespace.rmSync(outDir, { recursive: true, force: true });
-      fs11__namespace.renameSync(backupDir, outDir);
+    if (hadPrevious && fs12__namespace.existsSync(backupDir)) {
+      if (fs12__namespace.existsSync(outDir)) fs12__namespace.rmSync(outDir, { recursive: true, force: true });
+      fs12__namespace.renameSync(backupDir, outDir);
     }
     throw err;
   }
@@ -7641,7 +7799,7 @@ function generateSnapshot(configInput, options) {
     // first run cannot have marked them yet, so the name alone keeps a run from recording its own
     // output — but only at these exact paths, not at every directory that shares the name.
     toolOwnedPaths: [config.outDir, config.tmpDir].map(
-      (directory) => path12__namespace.relative(config.cwd, path12__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
+      (directory) => path13__namespace.relative(config.cwd, path13__namespace.resolve(config.cwd, directory)).replace(/\\/g, "/")
     ).filter((relative7) => relative7.length > 0 && !relative7.startsWith(".."))
   });
   const files = [];
@@ -7662,12 +7820,12 @@ function generateSnapshot(configInput, options) {
   let totalSizeBytes = 0;
   let largeFileCount = 0;
   for (const relativePath of collection.files) {
-    const absolutePath = path12__namespace.join(config.cwd, relativePath);
+    const absolutePath = path13__namespace.join(config.cwd, relativePath);
     let stats;
     try {
-      stats = fs11__namespace.statSync(absolutePath);
+      stats = fs12__namespace.statSync(absolutePath);
       if (!stats.isFile()) {
-        const nestedRepository = stats.isDirectory() && fs11__namespace.existsSync(path12__namespace.join(absolutePath, ".git"));
+        const nestedRepository = stats.isDirectory() && fs12__namespace.existsSync(path13__namespace.join(absolutePath, ".git"));
         skipped.push(
           nestedRepository ? {
             path: relativePath,
@@ -7687,7 +7845,7 @@ function generateSnapshot(configInput, options) {
     }
     let buffer;
     try {
-      buffer = fs11__namespace.readFileSync(absolutePath);
+      buffer = fs12__namespace.readFileSync(absolutePath);
     } catch {
       skipped.push({ path: relativePath, reason: "read-error" });
       continue;
@@ -8017,12 +8175,12 @@ function generateSnapshot(configInput, options) {
   let stagingDir = null;
   try {
     ensureParentDirectory(outDir, "outDir");
-    fs11__namespace.mkdirSync(tmpDir, { recursive: true });
+    fs12__namespace.mkdirSync(tmpDir, { recursive: true });
     cleanStaleRunDirs(tmpDir);
     const snapshotId = crypto__namespace.randomUUID();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-    stagingDir = path12__namespace.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
-    fs11__namespace.mkdirSync(stagingDir);
+    stagingDir = path13__namespace.join(tmpDir, `${RUN_DIR_PREFIX}${process.pid}-${snapshotId.slice(0, 8)}`);
+    fs12__namespace.mkdirSync(stagingDir);
     writeOwnershipMarker(stagingDir, {
       generator: GENERATOR_NAME,
       version: GENERATOR_VERSION,
@@ -8032,41 +8190,41 @@ function generateSnapshot(configInput, options) {
       id: snapshotId,
       pid: process.pid
     });
-    const partsDir = path12__namespace.join(stagingDir, "parts");
-    const reportsDir = path12__namespace.join(stagingDir, "reports");
-    if (artifacts.parts) fs11__namespace.mkdirSync(partsDir, { recursive: true });
+    const partsDir = path13__namespace.join(stagingDir, "parts");
+    const reportsDir = path13__namespace.join(stagingDir, "reports");
+    if (artifacts.parts) fs12__namespace.mkdirSync(partsDir, { recursive: true });
     if (artifacts.navigation || artifacts.projectTree || artifacts.audit) {
-      fs11__namespace.mkdirSync(reportsDir, { recursive: true });
+      fs12__namespace.mkdirSync(reportsDir, { recursive: true });
     }
     if (artifacts.parts) {
       for (const part of parts) {
-        fs11__namespace.writeFileSync(path12__namespace.join(partsDir, part.filename), part.markdown, "utf8");
+        fs12__namespace.writeFileSync(path13__namespace.join(partsDir, part.filename), part.markdown, "utf8");
       }
     }
     if (projectTree !== null) {
-      fs11__namespace.writeFileSync(path12__namespace.join(reportsDir, "project-tree.md"), projectTree, "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(reportsDir, "project-tree.md"), projectTree, "utf8");
     }
     if (artifacts.navigation) {
-      fs11__namespace.writeFileSync(path12__namespace.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
     }
     if (artifacts.audit) {
-      fs11__namespace.writeFileSync(
-        path12__namespace.join(reportsDir, "audit.md"),
+      fs12__namespace.writeFileSync(
+        path13__namespace.join(reportsDir, "audit.md"),
         generateAuditReport(manifest, secretFindings, config.secretRules),
         "utf8"
       );
     }
     if (artifacts.readme) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "README.md"), generateReadme(manifest, artifacts), "utf8");
     }
     if (artifacts.manifest) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
     }
     if (monolithJson !== null) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "full-codebase.json"), monolithJson, "utf8");
     }
     if (monolithMarkdown !== null) {
-      fs11__namespace.writeFileSync(path12__namespace.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
+      fs12__namespace.writeFileSync(path13__namespace.join(stagingDir, "full-codebase.md"), monolithMarkdown, "utf8");
     }
     writeOwnershipMarker(stagingDir, markerPayload(stagingDir, "complete", snapshotId, createdAt));
     swapIntoPlace(stagingDir, outDir);
@@ -8075,7 +8233,7 @@ function generateSnapshot(configInput, options) {
     const pendingHook = runAfterGenerate(config, manifest);
     const shipHookState = () => {
       if (artifacts.manifest && manifest.warnings.length !== warningsBeforeHook) {
-        writeManifestAtomically(path12__namespace.join(outDir, "manifest.json"), manifest);
+        writeManifestAtomically(path13__namespace.join(outDir, "manifest.json"), manifest);
       }
       writeOwnershipMarker(outDir, markerPayload(outDir, "complete", snapshotId, createdAt));
     };
@@ -8098,7 +8256,7 @@ function generateSnapshot(configInput, options) {
   } catch (err) {
     if (stagingDir !== null) {
       try {
-        fs11__namespace.rmSync(stagingDir, { recursive: true, force: true });
+        fs12__namespace.rmSync(stagingDir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -8113,18 +8271,25 @@ async function generateSnapshotAsync(configInput, options) {
 }
 
 exports.ARTIFACT_NAMES = ARTIFACT_NAMES;
+exports.CHECK_INTERVAL_MS = CHECK_INTERVAL_MS;
 exports.DEFAULT_ANSWERS = DEFAULT_ANSWERS;
 exports.DEFAULT_SECRET_PATTERNS = DEFAULT_SECRET_PATTERNS;
+exports.FAILURE_INTERVAL_MS = FAILURE_INTERVAL_MS;
 exports.GENERATOR_NAME = GENERATOR_NAME;
 exports.GENERATOR_VERSION = GENERATOR_VERSION;
 exports.LANGUAGE_PROFILES = LANGUAGE_PROFILES;
 exports.MIN_MAX_PART_BYTES = MIN_MAX_PART_BYTES;
+exports.PACKAGE_LATEST_URL = PACKAGE_LATEST_URL;
 exports.PRESETS = PRESETS;
 exports.PromptCancelled = PromptCancelled;
+exports.REQUEST_TIMEOUT_MS = REQUEST_TIMEOUT_MS;
 exports.SCHEMA_VERSION = SCHEMA_VERSION;
 exports.anchorForPath = anchorForPath;
 exports.assertReplaceable = assertReplaceable;
 exports.assertUsableConfigInput = assertUsableConfigInput;
+exports.cacheDirectory = cacheDirectory;
+exports.cacheFilePath = cacheFilePath;
+exports.checkForUpdate = checkForUpdate;
 exports.collectFiles = collectFiles;
 exports.compareManifests = compareManifests;
 exports.countInvalidUtf8Bytes = countInvalidUtf8Bytes;
@@ -8136,7 +8301,9 @@ exports.detectPreset = detectPreset;
 exports.explainPath = explainPath;
 exports.fenceForContent = fenceForContent;
 exports.fenceForText = fenceForText;
+exports.fetchLatestVersion = fetchLatestVersion;
 exports.firstRunMessage = firstRunMessage;
+exports.formatUpdateNotice = formatUpdateNotice;
 exports.generateProjectTree = generateProjectTree;
 exports.generateSnapshot = generateSnapshot;
 exports.generateSnapshotAsync = generateSnapshotAsync;
@@ -8148,6 +8315,7 @@ exports.isBinaryExtension = isBinaryExtension;
 exports.isBinaryFile = isBinaryFile;
 exports.isEffectivelyEmpty = isEffectivelyEmpty;
 exports.isInteractive = isInteractive;
+exports.isNewer = isNewer;
 exports.isResolvedConfig = isResolvedConfig;
 exports.isSensitivePath = isSensitivePath;
 exports.listPresetNames = listPresetNames;
@@ -8170,6 +8338,7 @@ exports.resolveConfig = resolveConfig;
 exports.resolveSafeOutputDirs = resolveSafeOutputDirs;
 exports.runInit = runInit;
 exports.scanAndRedactSecrets = scanAndRedactSecrets;
+exports.shouldCheck = shouldCheck;
 exports.stripJsonComments = stripJsonComments;
 exports.summarizeJson = summarizeJson;
 exports.summarizeMarkdown = summarizeMarkdown;