@ankurhalder/codebase-snapshot 0.0.0-stage → 2.0.0

package/dist/bin.js

@@ -0,0 +1,3725 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as fs9 from "fs";
+import * as path10 from "path";
+import { parseArgs } from "util";
+
+// src/diff.ts
+import * as fs from "fs";
+import * as path from "path";
+function side(manifest) {
+  return {
+    generatedAt: manifest.generatedAt,
+    fingerprint: manifest.fingerprint,
+    fileCount: manifest.counts.totalFiles,
+    partsCount: manifest.counts.partsCount
+  };
+}
+function hashMap(manifest) {
+  const map = /* @__PURE__ */ new Map();
+  for (const file of manifest.files) {
+    if (file && typeof file.relativePath === "string") {
+      map.set(file.relativePath, file.hashSha256);
+    }
+  }
+  return map;
+}
+function compareManifests(before, after) {
+  const left = hashMap(before);
+  const right = hashMap(after);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  let unchanged = 0;
+  for (const [filePath, hash] of right) {
+    const previous = left.get(filePath);
+    if (previous === void 0) added.push(filePath);
+    else if (previous !== hash) changed.push(filePath);
+    else unchanged += 1;
+  }
+  for (const filePath of left.keys()) {
+    if (!right.has(filePath)) removed.push(filePath);
+  }
+  const sort = (values) => values.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return {
+    before: side(before),
+    after: side(after),
+    added: sort(added),
+    removed: sort(removed),
+    changed: sort(changed),
+    unchanged
+  };
+}
+function loadManifest(target) {
+  const manifestPath = fs.statSync(target).isDirectory() ? path.join(target, "manifest.json") : target;
+  let raw;
+  try {
+    raw = fs.readFileSync(manifestPath, "utf8");
+  } catch {
+    throw new Error(`Could not read a manifest at ${manifestPath}.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Could not parse ${manifestPath}: ${err.message}`);
+  }
+  if (!parsed || !Array.isArray(parsed.files)) {
+    throw new Error(`${manifestPath} is not a snapshot manifest (no "files" array).`);
+  }
+  return parsed;
+}
+function renderDiffText(diff) {
+  const lines = [];
+  lines.push(`before  ${diff.before.generatedAt}  ${diff.before.fileCount} file(s), ${diff.before.partsCount} part(s)`);
+  lines.push(`after   ${diff.after.generatedAt}  ${diff.after.fileCount} file(s), ${diff.after.partsCount} part(s)`);
+  lines.push("");
+  lines.push(`  + ${diff.added.length} added`);
+  lines.push(`  - ${diff.removed.length} removed`);
+  lines.push(`  ~ ${diff.changed.length} changed`);
+  lines.push(`  = ${diff.unchanged} unchanged`);
+  const section = (title, values) => {
+    if (values.length === 0) return;
+    lines.push("", title);
+    for (const value of values.slice(0, 200)) lines.push(`  ${value}`);
+    if (values.length > 200) lines.push(`  ... and ${values.length - 200} more`);
+  };
+  section("added:", diff.added);
+  section("removed:", diff.removed);
+  section("changed:", diff.changed);
+  return lines.join("\n");
+}
+
+// src/explain.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+
+// src/config.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { pathToFileURL } from "url";
+
+// src/presets/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/presets/nextjs.ts
+var NEXTJS_LAYERS = [
+  { name: "app", match: (p) => p.startsWith("src/app/") || p.startsWith("app/") },
+  { name: "features", match: (p) => p.startsWith("src/features/") || p.startsWith("features/") },
+  { name: "shared", match: (p) => p.startsWith("src/shared/") || p.startsWith("shared/") },
+  { name: "layout", match: (p) => p.startsWith("src/layout/") || p.startsWith("layout/") },
+  { name: "scripts", match: (p) => p.startsWith("scripts/") },
+  { name: "docs", match: (p) => p.startsWith("docs/") },
+  {
+    name: "config",
+    match: (p) => p.startsWith(".github/") || p.startsWith(".husky/") || p.startsWith(".vscode/") || p.startsWith(".") || p.includes("config")
+  },
+  { name: "root", match: (p) => !p.includes("/") }
+];
+var NEXTJS_KINDS = [
+  { kind: "test", match: (p) => /\.(test|spec)\.[jt]sx?$/.test(p.toLowerCase()) },
+  {
+    kind: "route",
+    match: (p) => {
+      const l = p.toLowerCase();
+      return l.endsWith("/route.ts") || l.endsWith("/route.tsx") || l.startsWith("src/app/api/");
+    }
+  },
+  { kind: "handler", match: (p) => p.includes(".handler.") || p.endsWith(".handler.ts") },
+  { kind: "repository", match: (p) => p.includes("repositories/") || p.includes("repository") },
+  { kind: "service", match: (p) => p.includes("service") || p.includes(".factory.") },
+  { kind: "schema", match: (p) => p.includes("schema") || p.includes("zod") },
+  { kind: "model", match: (p) => p.includes("model") || p.includes("types/") },
+  { kind: "type", match: (p) => p.endsWith(".d.ts") || p.includes("types.ts") },
+  {
+    kind: "hook",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return p.includes("/hooks/") || /^use[A-Z]/.test(base);
+    }
+  },
+  {
+    kind: "component",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return p.includes("/components/") || base.endsWith(".tsx") || base.endsWith(".jsx");
+    }
+  },
+  { kind: "data", match: (p) => p.endsWith(".json") || p.endsWith(".csv") },
+  { kind: "doc", match: (p) => p.endsWith(".md") || p.endsWith(".mdx") },
+  { kind: "script", match: (p) => p.startsWith("scripts/") || p.endsWith(".sh") || p.endsWith(".ps1") },
+  {
+    kind: "config",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return ["package.json", "tsconfig.json", "next.config.ts", "next.config.js", "eslint.config.mjs"].includes(base) || base.startsWith(".");
+    }
+  }
+];
+
+// src/presets/vite.ts
+var VITE_LAYERS = [
+  { name: "pages", match: (p) => p.startsWith("src/pages/") || p.startsWith("src/views/") },
+  { name: "components", match: (p) => p.startsWith("src/components/") },
+  { name: "hooks", match: (p) => p.startsWith("src/hooks/") },
+  { name: "services", match: (p) => p.startsWith("src/services/") || p.startsWith("src/api/") },
+  { name: "shared", match: (p) => p.startsWith("src/shared/") || p.startsWith("src/common/") },
+  { name: "styles", match: (p) => p.startsWith("src/styles/") || p.startsWith("src/assets/") },
+  { name: "scripts", match: (p) => p.startsWith("scripts/") },
+  { name: "docs", match: (p) => p.startsWith("docs/") },
+  {
+    name: "config",
+    match: (p) => p.startsWith(".github/") || p.startsWith(".husky/") || p.startsWith(".") || p.includes("config")
+  },
+  { name: "root", match: (p) => !p.includes("/") }
+];
+var VITE_KINDS = [
+  { kind: "test", match: (p) => /\.(test|spec)\.[jt]sx?$/.test(p.toLowerCase()) },
+  {
+    kind: "component",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return p.includes("/components/") || base.endsWith(".tsx") || base.endsWith(".jsx") || base.endsWith(".vue");
+    }
+  },
+  {
+    kind: "hook",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return p.includes("/hooks/") || /^use[A-Z]/.test(base);
+    }
+  },
+  { kind: "service", match: (p) => p.includes("service") || p.includes("api") },
+  { kind: "type", match: (p) => p.endsWith(".d.ts") || p.includes("types") },
+  { kind: "style", match: (p) => p.endsWith(".css") || p.endsWith(".scss") },
+  { kind: "data", match: (p) => p.endsWith(".json") || p.endsWith(".csv") },
+  { kind: "doc", match: (p) => p.endsWith(".md") || p.endsWith(".mdx") },
+  { kind: "script", match: (p) => p.startsWith("scripts/") || p.endsWith(".sh") || p.endsWith(".ps1") },
+  {
+    kind: "config",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return ["package.json", "tsconfig.json", "vite.config.ts", "vite.config.js"].includes(base) || base.startsWith(".");
+    }
+  }
+];
+
+// src/presets/node.ts
+var NODE_LAYERS = [
+  { name: "core", match: (p) => p.startsWith("src/core/") || p.startsWith("core/") },
+  { name: "protocols", match: (p) => p.startsWith("src/protocols/") || p.startsWith("protocols/") },
+  { name: "providers", match: (p) => p.startsWith("src/providers/") || p.startsWith("providers/") },
+  { name: "security", match: (p) => p.startsWith("src/security/") || p.startsWith("security/") },
+  { name: "db", match: (p) => p.startsWith("src/db/") || p.startsWith("db/") || p.startsWith("prisma/") },
+  { name: "api", match: (p) => p.startsWith("src/api/") || p.startsWith("api/") || p.startsWith("routes/") },
+  { name: "services", match: (p) => p.startsWith("src/services/") || p.startsWith("services/") },
+  { name: "controllers", match: (p) => p.startsWith("src/controllers/") || p.startsWith("controllers/") },
+  { name: "scripts", match: (p) => p.startsWith("scripts/") },
+  { name: "docs", match: (p) => p.startsWith("docs/") },
+  {
+    name: "config",
+    match: (p) => p.startsWith(".github/") || p.startsWith(".husky/") || p.startsWith(".") || p.includes("config")
+  },
+  { name: "root", match: (p) => !p.includes("/") }
+];
+var NODE_KINDS = [
+  { kind: "test", match: (p) => /\.(test|spec)\.[jt]sx?$/.test(p.toLowerCase()) },
+  { kind: "route", match: (p) => p.includes("/routes/") || p.includes("route.") || p.includes("/api/") },
+  { kind: "controller", match: (p) => p.includes("controller") },
+  { kind: "service", match: (p) => p.includes("service") },
+  { kind: "provider", match: (p) => p.includes("provider") },
+  { kind: "model", match: (p) => p.includes("model") || p.includes("entity") },
+  { kind: "schema", match: (p) => p.includes("schema") || p.includes("zod") || p.includes("dto") },
+  { kind: "type", match: (p) => p.endsWith(".d.ts") || p.includes("types.") || p.includes("type.") },
+  { kind: "security", match: (p) => p.includes("auth") || p.includes("security") || p.includes("guard") },
+  { kind: "db", match: (p) => p.includes("db") || p.includes("database") || p.includes("migration") },
+  { kind: "data", match: (p) => p.endsWith(".json") || p.endsWith(".csv") },
+  { kind: "doc", match: (p) => p.endsWith(".md") || p.endsWith(".mdx") },
+  { kind: "script", match: (p) => p.startsWith("scripts/") || p.endsWith(".sh") || p.endsWith(".ps1") },
+  {
+    kind: "config",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return ["package.json", "tsconfig.json", "Dockerfile"].includes(base) || base.startsWith(".");
+    }
+  }
+];
+
+// src/presets/default.ts
+var DEFAULT_LAYERS = [
+  { name: "src", match: (p) => p.startsWith("src/") },
+  { name: "packages", match: (p) => p.startsWith("packages/") },
+  { name: "scripts", match: (p) => p.startsWith("scripts/") },
+  { name: "docs", match: (p) => p.startsWith("docs/") },
+  { name: "test", match: (p) => p.startsWith("test/") || p.startsWith("tests/") },
+  {
+    name: "config",
+    match: (p) => p.startsWith(".github/") || p.startsWith(".husky/") || p.startsWith(".") || p.includes("config")
+  },
+  { name: "root", match: (p) => !p.includes("/") }
+];
+var DEFAULT_KINDS = [
+  { kind: "test", match: (p) => /\.(test|spec)\.[jt]sx?$/.test(p.toLowerCase()) },
+  {
+    kind: "component",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return base.endsWith(".tsx") || base.endsWith(".jsx") || p.includes("component");
+    }
+  },
+  {
+    kind: "hook",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return /^use[A-Z]/.test(base) || p.includes("/hooks/");
+    }
+  },
+  { kind: "type", match: (p) => p.endsWith(".d.ts") || p.includes("type") },
+  { kind: "data", match: (p) => p.endsWith(".json") || p.endsWith(".csv") || p.endsWith(".yaml") || p.endsWith(".yml") },
+  { kind: "doc", match: (p) => p.endsWith(".md") || p.endsWith(".mdx") || p.endsWith(".txt") },
+  { kind: "script", match: (p) => p.startsWith("scripts/") || p.endsWith(".sh") || p.endsWith(".ps1") },
+  {
+    kind: "config",
+    match: (p) => {
+      const base = p.split("/").pop() || "";
+      return base.startsWith(".") || base.includes("config") || base === "package.json";
+    }
+  }
+];
+
+// src/presets/index.ts
+function detectPreset(cwd) {
+  const hasNextConfig = fs2.existsSync(path2.join(cwd, "next.config.ts")) || fs2.existsSync(path2.join(cwd, "next.config.js")) || fs2.existsSync(path2.join(cwd, "next.config.mjs"));
+  const hasViteConfig = fs2.existsSync(path2.join(cwd, "vite.config.ts")) || fs2.existsSync(path2.join(cwd, "vite.config.js")) || fs2.existsSync(path2.join(cwd, "vite.config.mjs"));
+  const pkgJsonPath = path2.join(cwd, "package.json");
+  let pkgDependencies = {};
+  if (fs2.existsSync(pkgJsonPath)) {
+    try {
+      const parsed = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf8"));
+      pkgDependencies = {
+        ...parsed.dependencies || {},
+        ...parsed.devDependencies || {}
+      };
+    } catch {
+      pkgDependencies = {};
+    }
+  }
+  if (hasNextConfig || pkgDependencies["next"]) {
+    return {
+      presetName: "nextjs",
+      layers: NEXTJS_LAYERS,
+      kinds: NEXTJS_KINDS
+    };
+  }
+  if (hasViteConfig || pkgDependencies["vite"]) {
+    return {
+      presetName: "vite",
+      layers: VITE_LAYERS,
+      kinds: VITE_KINDS
+    };
+  }
+  if (pkgDependencies["express"] || pkgDependencies["fastify"] || pkgDependencies["@nestjs/core"] || fs2.existsSync(path2.join(cwd, "src/core")) || fs2.existsSync(path2.join(cwd, "src/protocols"))) {
+    return {
+      presetName: "node",
+      layers: NODE_LAYERS,
+      kinds: NODE_KINDS
+    };
+  }
+  return {
+    presetName: "default",
+    layers: DEFAULT_LAYERS,
+    kinds: DEFAULT_KINDS
+  };
+}
+
+// src/scanner/files.ts
+import * as childProcess from "child_process";
+import * as fs3 from "fs";
+import * as path3 from "path";
+function getGitInfo(cwd, fallbackBranch = "main") {
+  try {
+    const branch = childProcess.execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim() || fallbackBranch;
+    const commit = childProcess.execSync("git rev-parse HEAD", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim() || "unknown";
+    const status = childProcess.execSync("git status --porcelain", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim();
+    return { branch, commit, isDirty: status.length > 0 };
+  } catch {
+    return { branch: fallbackBranch, commit: "unknown", isDirty: false };
+  }
+}
+var DEFAULT_IGNORED_DIRS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache",
+  "coverage",
+  "out",
+  "snapshot",
+  "snapshot.tmp"
+];
+var DEFAULT_IGNORED_FILES = [
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "composer.lock"
+];
+var SENSITIVE_BASENAME = /^(?:\.env(?:[._-][A-Za-z0-9_-]*)*|\.env(?:backup|bak|old|orig|copy|save)|\.envrc|\.npmrc(?:\.[A-Za-z0-9_-]+)?|\.yarnrc(?:\.yml)?|\.netrc(?:\.[A-Za-z0-9_-]+)?|\.git-credentials|\.htpasswd|\.pgpass|id_[a-z0-9_]+(?:\.[A-Za-z0-9_-]+)?|credentials(?:\.json)?|service[-_]?account(?:\.[a-z0-9_-]+)*\.json|secrets?\.(?:json|ya?ml))$/i;
+var SENSITIVE_PATH = /(?:^|\/)\.(?:aws|ssh|gnupg)\/|(?:^|\/)\.docker\/config\.json$|(?:^|\/)\.kube\/config$/i;
+var SENSITIVE_EXT = /\.(?:pem|key|p12|pfx|jks|keystore|ppk|asc|kdbx|tfstate|tfvars)$/i;
+var TEMPLATE_SUFFIX = /\.(?:example|sample|template|dist)(?=$|[.])/i;
+var matchesSensitiveList = (posixPath, base) => SENSITIVE_BASENAME.test(base) || SENSITIVE_PATH.test(posixPath) || SENSITIVE_EXT.test(base);
+function isSensitivePath(relativePath) {
+  const posixPath = relativePath.replace(/\\/g, "/");
+  const base = posixPath.split("/").pop() ?? posixPath;
+  if (TEMPLATE_SUFFIX.test(base)) {
+    const stripped = base.replace(new RegExp(TEMPLATE_SUFFIX.source, "gi"), "");
+    if (matchesSensitiveList(posixPath, stripped)) return false;
+  }
+  return matchesSensitiveList(posixPath, base);
+}
+function globToRegExp(glob) {
+  const normalized = glob.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  const anchored = normalized.startsWith("/");
+  const body = anchored ? normalized.slice(1) : normalized;
+  const prefix = anchored || body.includes("/") ? "^" : "(?:^|.*/)";
+  return new RegExp(`${prefix}${globBodyToRegExp(body, true)}(?:/.*)?$`);
+}
+function globBodyToRegExp(body, allowBraces) {
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    const char = body[i];
+    if (char === "*") {
+      if (body[i + 1] === "*") {
+        i += 1;
+        if (body[i + 1] === "/") {
+          i += 1;
+          out += "(?:.*/)?";
+        } else {
+          out += ".*";
+        }
+      } else {
+        out += "[^/]*";
+      }
+      continue;
+    }
+    if (char === "?") {
+      out += "[^/]";
+      continue;
+    }
+    if (char === "{" && allowBraces) {
+      const close = findClosing(body, i, "{", "}");
+      if (close !== -1) {
+        const alternatives = body.slice(i + 1, close).split(",").map((part) => globBodyToRegExp(part.trim(), false));
+        if (alternatives.length > 1) {
+          out += `(?:${alternatives.join("|")})`;
+          i = close;
+          continue;
+        }
+      }
+    }
+    if (char === "[") {
+      const close = body.indexOf("]", i + 1);
+      if (close !== -1 && close > i + 1) {
+        const inner = body.slice(i + 1, close);
+        const negated = inner.startsWith("!") || inner.startsWith("^");
+        const chars = negated ? inner.slice(1) : inner;
+        const safe = chars.replace(/[\\^\]]/g, (value) => `\\${value}`);
+        out += negated ? `[^/${safe}]` : `[${safe}]`;
+        i = close;
+        continue;
+      }
+    }
+    out += "\\^$.|+()[]{}".includes(char) ? `\\${char}` : char;
+  }
+  return out;
+}
+function findClosing(body, start, open, close) {
+  let depth = 0;
+  for (let i = start; i < body.length; i++) {
+    if (body[i] === open) depth += 1;
+    else if (body[i] === close) {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function matchesExclude(relativePath, pattern) {
+  const posixPath = relativePath.replace(/\\/g, "/");
+  const cleaned = pattern.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "").trim();
+  if (!cleaned) return false;
+  if (/[*?{[]/.test(cleaned)) {
+    return globToRegExp(cleaned).test(posixPath);
+  }
+  return posixPath === cleaned || posixPath.startsWith(`${cleaned}/`) || posixPath.includes(`/${cleaned}/`) || posixPath.endsWith(`/${cleaned}`);
+}
+function readGitignoreMatcher(dir) {
+  const gitignorePath = path3.join(dir, ".gitignore");
+  let raw;
+  try {
+    raw = fs3.readFileSync(gitignorePath, "utf8");
+  } catch {
+    return () => false;
+  }
+  const rules = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const negated = trimmed.startsWith("!");
+    let pattern = negated ? trimmed.slice(1) : trimmed;
+    const dirOnly = pattern.endsWith("/");
+    if (dirOnly) pattern = pattern.slice(0, -1);
+    if (pattern) rules.push({ pattern, negated, dirOnly });
+  }
+  return (relativePath) => {
+    let ignored = false;
+    for (const rule of rules) {
+      const target = rule.dirOnly ? relativePath.replace(/\/.*$/, "") : relativePath;
+      if (matchesExclude(target, rule.pattern)) ignored = !rule.negated;
+    }
+    return ignored;
+  };
+}
+function defaultIgnoreReason(relativePath) {
+  const posixPath = relativePath.replace(/\\/g, "/");
+  const parts = posixPath.split("/");
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (DEFAULT_IGNORED_DIRS.includes(parts[i])) {
+      return `built-in ignore: directory "${parts[i]}"`;
+    }
+    if (parts[i].startsWith("snapshot.backup-")) {
+      return `built-in ignore: leftover snapshot backup "${parts[i]}"`;
+    }
+  }
+  const base = parts[parts.length - 1];
+  if (DEFAULT_IGNORED_FILES.includes(base)) {
+    return `built-in ignore: filename "${base}"`;
+  }
+  return null;
+}
+function collectFiles(cwd, options = {}) {
+  const includePatterns = options.includePatterns ?? [];
+  const excludePatterns = options.excludePatterns ?? [];
+  const includeSensitiveFiles = options.includeSensitiveFiles ?? false;
+  let candidates;
+  let walkSkips = [];
+  try {
+    const stdout = childProcess.execSync(
+      "git ls-files -z --cached --others --exclude-standard",
+      {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf8",
+        maxBuffer: 50 * 1024 * 1024
+      }
+    );
+    candidates = stdout.split("\0").filter((entry) => entry.length > 0).map((entry) => entry.replace(/\\/g, "/"));
+  } catch {
+    const walked = walkDirectory(cwd, cwd, /* @__PURE__ */ new Set());
+    candidates = walked.files;
+    walkSkips = walked.skipped;
+  }
+  const skipped = [...walkSkips];
+  const files = candidates.filter((file) => {
+    const ignored = defaultIgnoreReason(file);
+    if (ignored) {
+      skipped.push({ path: file, reason: "default-ignore", detail: ignored });
+      return false;
+    }
+    if (includePatterns.length > 0 && !includePatterns.some((pattern) => matchesExclude(file, pattern))) {
+      skipped.push({
+        path: file,
+        reason: "excluded",
+        detail: `does not match any include pattern (${includePatterns.join(", ")})`
+      });
+      return false;
+    }
+    for (const pattern of excludePatterns) {
+      if (matchesExclude(file, pattern)) {
+        skipped.push({
+          path: file,
+          reason: "excluded",
+          detail: `matches exclude pattern "${pattern}"`
+        });
+        return false;
+      }
+    }
+    if (!includeSensitiveFiles && isSensitivePath(file)) {
+      skipped.push({
+        path: file,
+        reason: "sensitive-file",
+        detail: "credential-bearing file; enable includeSensitiveFiles to emit it"
+      });
+      return false;
+    }
+    return true;
+  }).sort();
+  return { files, skipped };
+}
+function walkDirectory(dir, baseDir, visited) {
+  const results = { files: [], skipped: [] };
+  let realDir;
+  try {
+    realDir = fs3.realpathSync(dir);
+  } catch {
+    realDir = dir;
+  }
+  if (visited.has(realDir)) return results;
+  visited.add(realDir);
+  const ignoredByGitignore = dir === baseDir ? readGitignoreMatcher(baseDir) : () => false;
+  let entries;
+  try {
+    entries = fs3.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    results.skipped.push({ path: dir, reason: "read-error", detail: "directory unreadable" });
+    return results;
+  }
+  for (const entry of entries) {
+    if (DEFAULT_IGNORED_DIRS.includes(entry.name)) continue;
+    const fullPath = path3.join(dir, entry.name);
+    const relPath = path3.relative(baseDir, fullPath).replace(/\\/g, "/");
+    if (ignoredByGitignore(relPath)) continue;
+    let isDirectory = entry.isDirectory();
+    let isFile = entry.isFile();
+    if (entry.isSymbolicLink()) {
+      try {
+        const stats = fs3.statSync(fullPath);
+        isDirectory = stats.isDirectory();
+        isFile = stats.isFile();
+        if (!isDirectory && !isFile) {
+          results.skipped.push({ path: relPath, reason: "symlink", detail: "not a file or directory" });
+          continue;
+        }
+        results.skipped.push({
+          path: relPath,
+          reason: "symlink",
+          detail: isDirectory ? "followed directory symlink" : "followed file symlink"
+        });
+      } catch {
+        results.skipped.push({ path: relPath, reason: "read-error", detail: "broken symlink" });
+        continue;
+      }
+    }
+    if (isDirectory) {
+      const nested = walkDirectory(fullPath, baseDir, visited);
+      results.files.push(...nested.files);
+      results.skipped.push(...nested.skipped);
+    } else if (isFile) {
+      results.files.push(relPath);
+    }
+  }
+  return results;
+}
+
+// src/security/patterns.ts
+var DEFAULT_SECRET_PATTERNS = [
+  {
+    rule: "private-key-header",
+    pattern: /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----|-----BEGIN (?:RSA |OPENSSH |EC |PGP |DSA |ENCRYPTED )?PRIVATE KEY-----/
+  },
+  {
+    rule: "jwt-token",
+    pattern: /eyJ[A-Za-z0-9_-]{10,1024}\.eyJ[A-Za-z0-9_-]{10,1024}\.[A-Za-z0-9_-]{10,1024}/
+  },
+  {
+    rule: "aws-access-key-id",
+    pattern: /(?:AKIA|ASIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASCA)[0-9A-Z]{16}/
+  },
+  {
+    rule: "aws-secret-access-key",
+    pattern: /(?:aws_secret_access_key|aws_secret_key|secret_access_key)["']?\s*[:=]\s*["']?[A-Za-z0-9/+=]{40}["']?/i
+  },
+  {
+    rule: "github-token",
+    pattern: /gh[pousr]_[A-Za-z0-9]{36,251}|github_pat_[A-Za-z0-9_]{22,251}|ghs_[A-Za-z0-9]{36,251}/
+  },
+  {
+    rule: "slack-token",
+    pattern: /xox[baprs]-[0-9A-Za-z-]{10,250}/
+  },
+  {
+    rule: "slack-webhook-url",
+    pattern: /hooks\.slack\.com\/services\/T[A-Z0-9]{6,12}\/B[A-Z0-9]{6,12}\/[A-Za-z0-9]{20,32}/
+  },
+  {
+    rule: "stripe-secret-key",
+    pattern: /[sr]k_live_[0-9a-zA-Z]{20,247}/
+  },
+  {
+    rule: "google-api-key",
+    pattern: /AIza[0-9A-Za-z_-]{35}/
+  },
+  {
+    rule: "google-oauth-client-secret",
+    pattern: /GOCSPX-[A-Za-z0-9_-]{20,64}/
+  },
+  {
+    rule: "openai-anthropic-key",
+    pattern: /\bsk-(?:ant-[a-z0-9]+-|proj-|svcacct-|admin-)?[A-Za-z0-9_-]{20,}_?[A-Za-z0-9_-]{0,20}\b/
+  },
+  {
+    rule: "npm-token",
+    pattern: /npm_[A-Za-z0-9]{36}/
+  },
+  {
+    rule: "pypi-token",
+    pattern: /pypi-[A-Za-z0-9_-]{50,180}/
+  },
+  {
+    rule: "sendgrid-key",
+    pattern: /SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}/
+  },
+  {
+    rule: "twilio-api-key",
+    pattern: /SK[0-9a-fA-F]{32}/
+  },
+  {
+    rule: "digitalocean-token",
+    pattern: /dop_v1_[0-9a-f]{64}/
+  },
+  {
+    rule: "azure-storage-account-key",
+    pattern: /AccountKey=[A-Za-z0-9+/=]{80,100}/
+  },
+  {
+    rule: "database-uri-credentials",
+    pattern: /(?:mongodb(?:\+srv)?|postgres(?:ql)?|mysql|maria(?:db)?|redis(?:s)?|amqp(?:s)?|clickhouse):\/\/[^\s:@/]{1,128}:[^\s@/]{1,256}@[^\s/]{1,256}/
+  },
+  {
+    rule: "basic-auth-url",
+    pattern: /(?:https?|ftp|sftp|ssh|git):\/\/[^\s:@/]{1,128}:[^\s@/]{1,256}@[^\s/]{1,256}/i
+  },
+  {
+    rule: "generic-secret-assignment",
+    pattern: /(?:api[_-]?key|secret[_-]?key|auth[_-]?token|client[_-]?secret|access[_-]?token|refresh[_-]?token|private[_-]?key|password|passwd|pwd)["']?\s*[:=]\s*["'][^"'\s]{8,256}["']/i
+  },
+  {
+    // Covers `.env` / shell assignment syntax, which never quotes its values and
+    // was therefore invisible to the rule above. Anchored to the line start and
+    // limited to secret-looking names to stay at zero false positives.
+    //
+    // The name is matched with BOUNDED quantifiers on purpose: an unbounded
+    // `[A-Za-z0-9_]*` on both sides of the keyword alternation backtracks at
+    // every offset of a long identifier, which made this rule quadratic
+    // (measured 5.6 s for a single 240 KB line before bounding).
+    rule: "env-secret-assignment",
+    pattern: /^\s{0,64}(?:export\s{1,8})?[A-Za-z0-9_]{0,96}(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|PWD|CREDENTIAL)[A-Za-z0-9_]{0,96}\s{0,8}=\s{0,8}(?![\s$<{[])[^\s#]{6,512}$/i
+  }
+];
+var PEM_BLOCK_PATTERN = /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----[\s\S]*?-----END (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/g;
+var PEM_UNTERMINATED_PATTERN = /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----(?:\r?\n[A-Za-z0-9+/=]{4,}[ A-Za-z0-9+/=]*)+/g;
+
+// src/security/redact.ts
+var REDACTION_MARKER = "[REDACTED: potential secret-like value omitted from snapshot]";
+var PEM_REDACTION_MARKER = "[REDACTED: private key block omitted from snapshot]";
+function compileSecretRules(rules) {
+  return rules.map((rule) => {
+    if (rule.pattern instanceof RegExp) {
+      return {
+        rule: rule.rule,
+        pattern: new RegExp(rule.pattern.source, rule.pattern.flags.replace(/[gy]/g, ""))
+      };
+    }
+    if (typeof rule.pattern === "string") {
+      try {
+        return { rule: rule.rule, pattern: new RegExp(rule.pattern, "i") };
+      } catch (err) {
+        throw new Error(
+          `Invalid regular expression for secret rule "${rule.rule}": ${err.message}`
+        );
+      }
+    }
+    throw new Error(
+      `Secret rule "${String(rule.rule)}" has a pattern that is neither a RegExp nor a string.`
+    );
+  });
+}
+function toGlobal(pattern) {
+  const flags = pattern.flags.replace(/[gy]/g, "");
+  return new RegExp(pattern.source, `${flags}g`);
+}
+function scanAndRedactSecrets(content, rules, filePath) {
+  const findings = [];
+  let redacted = content;
+  for (const blockPattern of [PEM_BLOCK_PATTERN, PEM_UNTERMINATED_PATTERN]) {
+    blockPattern.lastIndex = 0;
+    let match;
+    while ((match = blockPattern.exec(redacted)) !== null) {
+      if (match[0].length === 0) {
+        blockPattern.lastIndex += 1;
+        continue;
+      }
+      const line = redacted.slice(0, match.index).split("\n").length;
+      const newlines = (match[0].match(/\n/g) ?? []).length;
+      findings.push({ rule: "private-key-block", line, path: filePath });
+      redacted = redacted.slice(0, match.index) + PEM_REDACTION_MARKER + "\n".repeat(newlines) + redacted.slice(match.index + match[0].length);
+      blockPattern.lastIndex = match.index + PEM_REDACTION_MARKER.length + newlines;
+    }
+  }
+  const compiled = rules.map((rule) => ({
+    rule: rule.rule,
+    pattern: toGlobal(rule.pattern)
+  }));
+  const lines = redacted.split("\n");
+  const redactedLines = lines.map((line, index) => {
+    if (line.length === 0) return line;
+    const spans = [];
+    const matchedRules = /* @__PURE__ */ new Set();
+    for (const { rule, pattern } of compiled) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(line)) !== null) {
+        if (match[0].length === 0) {
+          pattern.lastIndex += 1;
+          continue;
+        }
+        spans.push({ start: match.index, end: match.index + match[0].length, rule });
+        matchedRules.add(rule);
+      }
+    }
+    if (spans.length === 0) return line;
+    for (const rule of matchedRules) {
+      findings.push({ rule, line: index + 1, path: filePath });
+    }
+    return applySpans(line, spans);
+  });
+  return { redacted: redactedLines.join("\n"), findings };
+}
+function applySpans(line, spans) {
+  const ordered = [...spans].sort((a, b) => a.start - b.start || a.end - b.end);
+  let out = "";
+  let cursor = 0;
+  for (const span of ordered) {
+    if (span.end <= cursor) continue;
+    const start = Math.max(span.start, cursor);
+    out += line.slice(cursor, start);
+    out += REDACTION_MARKER;
+    cursor = Math.min(span.end, line.length);
+  }
+  out += line.slice(cursor);
+  return out;
+}
+
+// src/config.ts
+var CONFIG_FILENAMES = [
+  "snapshot.config.ts",
+  "snapshot.config.js",
+  "snapshot.config.mjs",
+  "snapshot.config.cjs",
+  "snapshot.config.json",
+  ".snapshotrc.json",
+  ".snapshotrc"
+];
+var RESOLVED_CONFIG_BRAND = /* @__PURE__ */ Symbol.for(
+  "@ankurhalder/codebase-snapshot/resolved-config"
+);
+function markResolvedConfig(config) {
+  Object.defineProperty(config, RESOLVED_CONFIG_BRAND, {
+    value: true,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return config;
+}
+function isResolvedConfig(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  if (candidate[RESOLVED_CONFIG_BRAND] === true) {
+    return true;
+  }
+  const hasResolvedNumbers = typeof candidate.maxPartBytes === "number" && typeof candidate.largeFileBytes === "number" && typeof candidate.previewHeadLines === "number" && typeof candidate.previewTailLines === "number";
+  const hasResolvedStrings = typeof candidate.cwd === "string" && typeof candidate.outDir === "string" && typeof candidate.tmpDir === "string";
+  const hasResolvedFlags = typeof candidate.includeMonolith === "boolean" && typeof candidate.includeSensitiveFiles === "boolean";
+  const hasResolvedRules = Array.isArray(candidate.layers) && Array.isArray(candidate.kinds) && Array.isArray(candidate.excludePatterns);
+  const secretRules = candidate.secretRules;
+  const hasCompiledRules = Array.isArray(secretRules) && secretRules.every(
+    (rule) => typeof rule === "object" && rule !== null && typeof rule.rule === "string" && (typeof rule.pattern === "string" || rule.pattern instanceof RegExp)
+  );
+  return hasResolvedNumbers && hasResolvedStrings && hasResolvedFlags && hasResolvedRules && hasCompiledRules;
+}
+function normalizeResolvedConfig(config) {
+  return markResolvedConfig({
+    ...config,
+    secretRules: compileSecretRules(config.secretRules),
+    artifacts: resolveArtifacts(
+      config.artifacts,
+      void 0,
+      config.includeMonolith === true
+    ),
+    include: resolveInclude(config.include),
+    layersMode: config.layersMode === "replace" ? "replace" : "merge",
+    budgets: config.budgets && typeof config.budgets === "object" ? config.budgets : { default: config.maxPartBytes, byLayer: {} },
+    hooks: resolveHooks(config.hooks),
+    excludePatterns: Array.isArray(config.excludePatterns) ? config.excludePatterns : [],
+    layers: Array.isArray(config.layers) ? config.layers : [],
+    kinds: Array.isArray(config.kinds) ? config.kinds : []
+  });
+}
+function assertUsableConfigInput(value) {
+  if (typeof value !== "object" || value === null) return;
+  const candidate = value;
+  if (!Array.isArray(candidate.secretRules) || candidate.secretRules.length === 0) {
+    return;
+  }
+  const unusable = candidate.secretRules.filter((rule) => {
+    if (typeof rule !== "object" || rule === null) return true;
+    const pattern = rule.pattern;
+    if (pattern instanceof RegExp || typeof pattern === "string") return false;
+    return typeof pattern === "object" && pattern !== null;
+  });
+  if (unusable.length > 0) {
+    throw new Error(
+      `This configuration carries ${unusable.length} unusable secret rule pattern(s). A RegExp cannot survive JSON serialization, and silently dropping these rules would let those secrets through redaction. Pass the resolved config object itself (or express rules via \`secrets.customPatterns\`) instead of a JSON clone.`
+    );
+  }
+}
+function supportsTypeScriptImports() {
+  const features = process.features;
+  if (features && "typescript" in features) {
+    return features.typescript !== false && features.typescript !== void 0;
+  }
+  const [major, minor] = process.versions.node.split(".").map((value) => Number(value));
+  if (!Number.isFinite(major)) return false;
+  return major > 22 || major === 22 && minor >= 6;
+}
+function stripJsonComments(raw) {
+  return raw.replace(/^\uFEFF/, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:"'\\])\/\/.*$/gm, "$1");
+}
+function parseJsonish(raw, file) {
+  try {
+    return JSON.parse(stripJsonComments(raw));
+  } catch (err) {
+    throw new Error(`Could not parse ${file}: ${err.message}`);
+  }
+}
+async function loadConfigFileDetailed(cwd) {
+  const warnings = [];
+  for (const filename of CONFIG_FILENAMES) {
+    const fullPath = path4.join(cwd, filename);
+    if (!fs4.existsSync(fullPath)) continue;
+    if (filename.endsWith(".json") || filename === ".snapshotrc") {
+      try {
+        return {
+          config: parseJsonish(fs4.readFileSync(fullPath, "utf8"), fullPath),
+          file: fullPath,
+          warnings
+        };
+      } catch (err) {
+        warnings.push(err.message);
+        continue;
+      }
+    }
+    if (filename.endsWith(".ts") && !supportsTypeScriptImports()) {
+      warnings.push(
+        `${fullPath} was ignored: loading a .ts config needs Node >= 22.6 (running ${process.versions.node}). Use snapshot.config.mjs, .cjs or .json instead.`
+      );
+      continue;
+    }
+    try {
+      const imported = await import(pathToFileURL(fullPath).href);
+      const config = imported.default ?? imported;
+      if (!config || typeof config !== "object") {
+        warnings.push(`${fullPath} does not export a configuration object.`);
+        continue;
+      }
+      return { config, file: fullPath, warnings };
+    } catch (err) {
+      warnings.push(`Could not load ${fullPath}: ${err.message}`);
+      continue;
+    }
+  }
+  const pkgJsonPath = path4.join(cwd, "package.json");
+  if (fs4.existsSync(pkgJsonPath)) {
+    try {
+      const parsed = parseJsonish(fs4.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
+      const snapshotKey = parsed.snapshot;
+      if (snapshotKey && typeof snapshotKey === "object") {
+        return { config: snapshotKey, file: pkgJsonPath, warnings };
+      }
+    } catch (err) {
+      warnings.push(err.message);
+    }
+  }
+  return { config: null, file: null, warnings };
+}
+var MIN_MAX_PART_BYTES = 4096;
+var ARTIFACT_NAMES = [
+  "readme",
+  "manifest",
+  "parts",
+  "navigation",
+  "projectTree",
+  "audit",
+  "monolith"
+];
+var DEFAULT_ARTIFACTS = {
+  readme: true,
+  manifest: true,
+  parts: true,
+  navigation: true,
+  projectTree: true,
+  audit: true,
+  monolith: false
+};
+function isArtifactName(value) {
+  return ARTIFACT_NAMES.includes(value);
+}
+function resolveArtifacts(requested, skipped, includeMonolith) {
+  const artifacts = {
+    ...DEFAULT_ARTIFACTS,
+    // `includeMonolith` predates this selection and stays the switch for it.
+    monolith: includeMonolith
+  };
+  if (requested !== void 0) {
+    if (typeof requested !== "object" || requested === null || Array.isArray(requested)) {
+      throw new Error("`artifacts` must be an object of boolean flags.");
+    }
+    for (const [name, value] of Object.entries(requested)) {
+      if (!isArtifactName(name)) {
+        throw new Error(
+          `Unknown artifact "${name}". Expected one of: ${ARTIFACT_NAMES.join(", ")}.`
+        );
+      }
+      if (typeof value !== "boolean") {
+        throw new Error(`\`artifacts.${name}\` must be a boolean.`);
+      }
+      artifacts[name] = value;
+    }
+  }
+  for (const name of skipped ?? []) {
+    if (!isArtifactName(name)) {
+      throw new Error(
+        `Unknown artifact "${name}". Expected one of: ${ARTIFACT_NAMES.join(", ")}.`
+      );
+    }
+    artifacts[name] = false;
+  }
+  return artifacts;
+}
+function positiveInteger(value, fallback) {
+  if (!Number.isFinite(value) || value <= 0) return fallback;
+  return Math.floor(value);
+}
+var BYTE_UNITS = {
+  b: 1,
+  k: 1024,
+  kb: 1024,
+  kib: 1024,
+  m: 1024 * 1024,
+  mb: 1024 * 1024,
+  mib: 1024 * 1024,
+  g: 1024 * 1024 * 1024,
+  gb: 1024 * 1024 * 1024,
+  gib: 1024 * 1024 * 1024
+};
+function parseByteSize(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? Math.floor(value) : void 0;
+  }
+  const match = /^\s*(\d+(?:\.\d+)?)\s*(b|k|kb|kib|m|mb|mib|g|gb|gib)?\s*$/i.exec(value);
+  if (!match) return void 0;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount)) return void 0;
+  const multiplier = BYTE_UNITS[(match[2] ?? "b").toLowerCase()] ?? 1;
+  return Math.floor(amount * multiplier);
+}
+function describeBytes(value) {
+  return typeof value === "number" ? String(value) : `"${value}"`;
+}
+function boundedBytes(value, fallback, minimum, label) {
+  if (value === void 0) return fallback;
+  const parsed = parseByteSize(value);
+  if (parsed === void 0) {
+    throw new Error(
+      `${label} must be a byte count such as 120000, "120k" or "1.5mb" (received ${describeBytes(value)}).`
+    );
+  }
+  if (parsed <= 0) return fallback;
+  if (parsed < minimum) {
+    throw new Error(`${label} must be at least ${minimum} bytes (received ${describeBytes(value)}).`);
+  }
+  return parsed;
+}
+function optionalBytes(value, label) {
+  if (value === void 0 || value === null) return null;
+  const parsed = parseByteSize(value);
+  if (parsed === void 0 || parsed <= 0) {
+    throw new Error(
+      `${label} must be a positive byte count such as 1000000 or "1mb" (received ${describeBytes(value)}).`
+    );
+  }
+  return parsed;
+}
+function resolveInclude(include) {
+  if (include === void 0) return [];
+  if (!Array.isArray(include) || include.some((pattern) => typeof pattern !== "string")) {
+    throw new Error("`include` must be an array of glob strings.");
+  }
+  return include.map((pattern) => pattern.trim()).filter(Boolean);
+}
+function resolveLayersMode(mode) {
+  if (mode === void 0) return "merge";
+  if (mode !== "merge" && mode !== "replace") {
+    throw new Error(`\`layersMode\` must be "merge" or "replace" (received ${JSON.stringify(mode)}).`);
+  }
+  return mode;
+}
+function resolveBudgets(budgets, fallback) {
+  const byLayer = {};
+  if (budgets === void 0) return { default: fallback, byLayer };
+  if (typeof budgets !== "object" || budgets === null || Array.isArray(budgets)) {
+    throw new Error("`budgets` must be an object.");
+  }
+  if (budgets.byLayer !== void 0) {
+    if (typeof budgets.byLayer !== "object" || budgets.byLayer === null) {
+      throw new Error("`budgets.byLayer` must be an object of layer name to byte size.");
+    }
+    for (const [layer, value] of Object.entries(budgets.byLayer)) {
+      byLayer[layer] = boundedBytes(
+        value,
+        fallback,
+        MIN_MAX_PART_BYTES,
+        `budgets.byLayer["${layer}"]`
+      );
+    }
+  }
+  return {
+    default: boundedBytes(budgets.default, fallback, MIN_MAX_PART_BYTES, "budgets.default"),
+    byLayer
+  };
+}
+function resolveHooks(hooks) {
+  if (hooks === void 0) return {};
+  if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) {
+    throw new Error("`hooks` must be an object.");
+  }
+  if (hooks.afterGenerate !== void 0 && typeof hooks.afterGenerate !== "function") {
+    throw new Error("`hooks.afterGenerate` must be a function.");
+  }
+  return { ...hooks };
+}
+function resolveCandidateCwd(userConfig, cliOptions, baseDir) {
+  const candidate = cliOptions?.cwd || userConfig?.cwd || baseDir || process.cwd();
+  const resolved = path4.resolve(candidate);
+  if (!fs4.existsSync(resolved)) {
+    throw new Error(`Working directory does not exist: ${resolved}`);
+  }
+  if (!fs4.statSync(resolved).isDirectory()) {
+    throw new Error(`Working directory is not a directory: ${resolved}`);
+  }
+  return resolved;
+}
+function resolveConfig(userConfig, cliOptions, baseDir) {
+  const cwd = resolveCandidateCwd(userConfig ?? null, cliOptions, baseDir);
+  const preset = detectPreset(cwd);
+  const layersMode = resolveLayersMode(userConfig?.layersMode);
+  const layers = userConfig?.layers && userConfig.layers.length > 0 ? layersMode === "replace" ? userConfig.layers : [...userConfig.layers, ...preset.layers] : preset.layers;
+  const kinds = userConfig?.kinds && userConfig.kinds.length > 0 ? layersMode === "replace" ? userConfig.kinds : [...userConfig.kinds, ...preset.kinds] : preset.kinds;
+  const customRules = userConfig?.secrets?.customPatterns ?? [];
+  const rawRules = userConfig?.secrets?.disableDefaultPatterns ? customRules : [...DEFAULT_SECRET_PATTERNS, ...customRules];
+  const secretRules = compileSecretRules(rawRules);
+  const includeMonolith = cliOptions?.includeMonolith ?? userConfig?.includeMonolith ?? false;
+  const artifacts = resolveArtifacts(
+    userConfig?.artifacts,
+    cliOptions?.skipArtifacts,
+    includeMonolith
+  );
+  const maxPartBytes = boundedBytes(
+    cliOptions?.maxPartBytes ?? userConfig?.maxPartBytes,
+    300 * 1024,
+    MIN_MAX_PART_BYTES,
+    "maxPartBytes"
+  );
+  const budgets = resolveBudgets(userConfig?.budgets, maxPartBytes);
+  return markResolvedConfig({
+    cwd,
+    branch: userConfig?.branch || "main",
+    outDir: cliOptions?.outDir || userConfig?.outDir || "snapshot",
+    tmpDir: userConfig?.tmpDir || "snapshot.tmp",
+    maxPartBytes,
+    largeFileBytes: boundedBytes(cliOptions?.largeFileBytes ?? userConfig?.largeFileBytes, 200 * 1024, 1, "largeFileBytes"),
+    previewHeadLines: positiveInteger(userConfig?.previewHeadLines ?? 80, 80),
+    previewTailLines: positiveInteger(userConfig?.previewTailLines ?? 40, 40),
+    includeMonolith: artifacts.monolith,
+    maxMonolithBytes: optionalBytes(
+      cliOptions?.maxMonolithBytes !== void 0 ? cliOptions.maxMonolithBytes : userConfig?.maxMonolithBytes,
+      "maxMonolithBytes"
+    ),
+    includeSensitiveFiles: cliOptions?.includeSensitiveFiles ?? userConfig?.includeSensitiveFiles ?? false,
+    include: resolveInclude(userConfig?.include),
+    artifacts,
+    layersMode,
+    budgets,
+    hooks: resolveHooks(userConfig?.hooks),
+    layers,
+    kinds,
+    excludePatterns: userConfig?.excludePatterns ?? [],
+    secretRules
+  });
+}
+function matchRule(filePath, matcher) {
+  if (typeof matcher === "function") return matcher(filePath);
+  if (matcher instanceof RegExp) {
+    matcher.lastIndex = 0;
+    return matcher.test(filePath);
+  }
+  if (typeof matcher === "string") {
+    const pattern = matcher.replace(/\\/g, "/").trim();
+    if (!pattern) return false;
+    if (pattern.endsWith("/**")) {
+      const prefix = pattern.slice(0, -3).replace(/\/+$/, "");
+      if (!prefix) return true;
+      if (!/[*?]/.test(prefix)) {
+        return filePath === prefix || filePath.startsWith(`${prefix}/`);
+      }
+    }
+    if (pattern.includes("*") || pattern.includes("?")) {
+      return globToRegExp(pattern).test(filePath);
+    }
+    return filePath.includes(pattern);
+  }
+  return false;
+}
+function classifyLayer(filePath, layers) {
+  for (const layer of layers) {
+    if (matchRule(filePath, layer.match)) return layer.name;
+  }
+  return "other";
+}
+function classifyKind(filePath, kinds) {
+  for (const kind of kinds) {
+    if (matchRule(filePath, kind.match)) return kind.kind;
+  }
+  return "other";
+}
+
+// src/partitioner/preview.ts
+function countLines(content) {
+  if (content.length === 0) return 0;
+  return content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+}
+function truncateToBytes(content, maxBytes) {
+  if (maxBytes <= 0) return { content: "", isTruncated: content.length > 0 };
+  const buffer = Buffer.from(content, "utf8");
+  if (buffer.length <= maxBytes) return { content, isTruncated: false };
+  let slice = buffer.subarray(0, maxBytes).toString("utf8");
+  while (slice.endsWith("\uFFFD")) slice = slice.slice(0, -1);
+  return { content: slice, isTruncated: true };
+}
+function truncatePreview(content, headLines, tailLines) {
+  const lines = content.split("\n");
+  const total = countLines(content);
+  if (total <= headLines + tailLines) {
+    return {
+      content,
+      isTruncated: false,
+      originalLines: total,
+      includedLines: total
+    };
+  }
+  const head = lines.slice(0, headLines);
+  const tail = tailLines > 0 ? lines.slice(lines.length - tailLines) : [];
+  const omitted = total - headLines - tailLines;
+  const result = [
+    ...head,
+    `... [${omitted} lines omitted: file exceeds large file size budget] ...`,
+    ...tail
+  ].join("\n");
+  return {
+    content: result,
+    isTruncated: true,
+    originalLines: total,
+    includedLines: headLines + tailLines + 1
+  };
+}
+
+// src/scanner/language.ts
+import * as path5 from "path";
+var LANGUAGE_BY_EXTENSION = {
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "jsx",
+  ".json": "json",
+  ".jsonc": "json",
+  ".md": "markdown",
+  ".mdx": "mdx",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "scss",
+  ".less": "less",
+  ".html": "html",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".sql": "sql",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".ps1": "powershell",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".rb": "ruby",
+  ".php": "php",
+  ".toml": "toml",
+  ".ini": "ini",
+  ".env": "dotenv",
+  ".xml": "xml",
+  ".svg": "xml",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  ".proto": "protobuf",
+  ".tf": "hcl"
+};
+var LANGUAGE_BY_BASENAME = {
+  Dockerfile: "dockerfile",
+  Containerfile: "dockerfile",
+  Makefile: "makefile",
+  ".gitignore": "gitignore",
+  ".npmignore": "gitignore",
+  ".dockerignore": "gitignore",
+  ".editorconfig": "editorconfig"
+};
+function detectLanguage(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const base = path5.posix.basename(normalized);
+  if (LANGUAGE_BY_BASENAME[base]) return LANGUAGE_BY_BASENAME[base];
+  if (base === ".env" || base.startsWith(".env.")) return "dotenv";
+  const ext = path5.posix.extname(base).toLowerCase();
+  return LANGUAGE_BY_EXTENSION[ext] ?? "text";
+}
+
+// src/explain.ts
+function describeMatcher(matcher) {
+  if (typeof matcher === "string") return matcher;
+  if (matcher instanceof RegExp) return String(matcher);
+  if (typeof matcher === "function") {
+    const source = String(matcher).replace(/\s+/g, " ").trim();
+    return source.length > 70 ? `${source.slice(0, 67)}...` : source;
+  }
+  return String(matcher);
+}
+function normalizeTarget(cwd, target) {
+  const absolute = path6.resolve(cwd, target);
+  const relative4 = path6.relative(cwd, absolute);
+  if (relative4.startsWith("..") || path6.isAbsolute(relative4)) return target;
+  return relative4.split(path6.sep).join("/");
+}
+function findRuleMatch(rules, relativePath) {
+  return rules.find(
+    (rule) => matchRule(relativePath, rule.match)
+  );
+}
+function readManifest(config) {
+  const manifestPath = path6.join(config.cwd, config.outDir, "manifest.json");
+  try {
+    return JSON.parse(fs5.readFileSync(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function explainPath(config, target) {
+  const relative4 = normalizeTarget(config.cwd, target);
+  const absolute = path6.join(config.cwd, relative4);
+  const result = {
+    path: relative4,
+    exists: fs5.existsSync(absolute),
+    included: false
+  };
+  const collection = collectFiles(config.cwd, {
+    includePatterns: config.include,
+    excludePatterns: config.excludePatterns,
+    includeSensitiveFiles: config.includeSensitiveFiles
+  });
+  if (!collection.files.includes(relative4)) {
+    const record = collection.skipped.find((entry2) => entry2.path === relative4);
+    if (record) {
+      result.reason = record.reason;
+      result.detail = record.detail;
+    } else if (!result.exists) {
+      result.reason = "missing";
+      result.detail = "no such file or directory, relative to the configured cwd";
+    } else {
+      result.reason = "not-discovered";
+      result.detail = "exists but is not tracked or is otherwise not a candidate";
+    }
+    return result;
+  }
+  result.included = true;
+  result.layer = classifyLayer(relative4, config.layers);
+  result.kind = classifyKind(relative4, config.kinds);
+  result.language = detectLanguage(relative4);
+  const layerRule = findRuleMatch(config.layers, relative4);
+  if (layerRule) result.layerMatch = describeMatcher(layerRule.match);
+  const kindRule = findRuleMatch(config.kinds, relative4);
+  if (kindRule) result.kindMatch = describeMatcher(kindRule.match);
+  if (fs5.existsSync(absolute) && fs5.statSync(absolute).isFile()) {
+    const buffer = fs5.readFileSync(absolute);
+    const text = buffer.toString("utf8");
+    result.bytes = buffer.length;
+    result.lines = countLines(text);
+    const { findings } = scanAndRedactSecrets(text, config.secretRules, relative4);
+    result.secretCount = findings.length;
+    result.secrets = findings.slice(0, 20).map((finding) => ({ rule: finding.rule, line: finding.line }));
+  }
+  const manifest = readManifest(config);
+  const entry = manifest?.files.find((file) => file.relativePath === relative4);
+  result.part = entry?.part ?? null;
+  result.inclusionMode = entry?.inclusionMode;
+  return result;
+}
+function renderExplainText(result) {
+  const lines = [result.path, ""];
+  const row = (label, value) => `  ${label.padEnd(11)}${value}`;
+  if (!result.included) {
+    lines.push(row("included", "no"));
+    lines.push(row("reason", result.reason ?? "unknown"));
+    if (result.detail) lines.push(row("detail", result.detail));
+    return lines.join("\n");
+  }
+  lines.push(row("included", "yes"));
+  lines.push(row("layer", `${result.layer}${result.layerMatch ? `   (rule ${result.layerMatch})` : ""}`));
+  lines.push(row("kind", `${result.kind}${result.kindMatch ? `   (rule ${result.kindMatch})` : ""}`));
+  lines.push(row("language", result.language ?? "text"));
+  if (typeof result.lines === "number") {
+    lines.push(row("size", `${result.bytes} B, ${result.lines} line(s)`));
+  }
+  lines.push(
+    row(
+      "part",
+      result.part ?? "(not in the last snapshot; run generate)"
+    )
+  );
+  if (result.inclusionMode) lines.push(row("inclusion", result.inclusionMode));
+  lines.push(
+    row(
+      "secrets",
+      result.secretCount ? `${result.secretCount} finding(s): ${Array.from(
+        new Set((result.secrets ?? []).map((secret) => secret.rule))
+      ).join(", ")}` : "none"
+    )
+  );
+  return lines.join("\n");
+}
+
+// src/index.ts
+import * as crypto3 from "crypto";
+import * as fs8 from "fs";
+import * as path9 from "path";
+
+// src/ast/structured.ts
+function stripJsonComments2(content) {
+  const text = content.replace(/^\uFEFF/, "");
+  let out = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const next = text[i + 1];
+    if (inLineComment) {
+      if (char === "\n") {
+        inLineComment = false;
+        out += char;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      out += char;
+      if (char === "\\") {
+        if (next !== void 0) {
+          out += next;
+          i += 1;
+        }
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      out += char;
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    out += char;
+  }
+  return out;
+}
+function summarizeJson(content) {
+  try {
+    const parsed = JSON.parse(stripJsonComments2(content));
+    if (Array.isArray(parsed)) {
+      const sample = parsed[0];
+      const sampleKeys = sample && typeof sample === "object" && !Array.isArray(sample) ? Object.keys(sample).slice(0, 10).sort() : [];
+      return {
+        shape: "array",
+        itemCount: parsed.length,
+        keys: [],
+        sampleKeys
+      };
+    }
+    if (parsed && typeof parsed === "object") {
+      const keys = Object.keys(parsed).sort();
+      return {
+        shape: "object",
+        itemCount: keys.length,
+        keys: keys.slice(0, 30),
+        sampleKeys: []
+      };
+    }
+    return {
+      shape: typeof parsed,
+      itemCount: null,
+      keys: [],
+      sampleKeys: []
+    };
+  } catch {
+    return {
+      shape: "invalid-json",
+      itemCount: null,
+      keys: [],
+      sampleKeys: []
+    };
+  }
+}
+function summarizeMarkdown(content) {
+  const headings = [];
+  const frontmatterKeys = [];
+  const lines = content.replace(/^\uFEFF/, "").split("\n");
+  let inFrontmatter = false;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    if (index === 0 && line.trim() === "---") {
+      inFrontmatter = true;
+      continue;
+    }
+    if (inFrontmatter) {
+      if (line.trim() === "---") {
+        inFrontmatter = false;
+        continue;
+      }
+      const match = /^([a-zA-Z0-9_-]+):/.exec(line);
+      if (match) frontmatterKeys.push(match[1]);
+      continue;
+    }
+    const headingMatch = /^(#{1,6})\s+(.+)$/.exec(line.trim());
+    if (headingMatch) {
+      headings.push(`${headingMatch[1]} ${headingMatch[2].trim()}`);
+    }
+  }
+  return {
+    headings: headings.slice(0, 40),
+    frontmatterKeys: Array.from(new Set(frontmatterKeys)).sort()
+  };
+}
+
+// src/ast/ts-parser.ts
+import ts from "typescript";
+var ROUTE_HANDLER_NAMES = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS"
+]);
+function summarizeTypeScriptSource(relativePath, content) {
+  const summary = {
+    directives: [],
+    imports: [],
+    exports: [],
+    reExports: [],
+    functions: [],
+    classes: [],
+    interfaces: [],
+    types: [],
+    enums: [],
+    variables: [],
+    reactComponents: [],
+    hooks: [],
+    routeHandlers: []
+  };
+  const lowerPath = relativePath.toLowerCase();
+  const isJsx = lowerPath.endsWith(".tsx") || lowerPath.endsWith(".jsx");
+  const sourceFile = ts.createSourceFile(
+    relativePath,
+    content,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */
+    false,
+    isJsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const parseErrors = sourceFile.parseDiagnostics?.length ?? 0;
+  if (parseErrors > 0) summary.parseErrors = parseErrors;
+  for (const statement of sourceFile.statements) {
+    if (ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression)) {
+      const text = statement.expression.text;
+      if (text === "use client" || text === "use server") {
+        summary.directives.push(text);
+      }
+      continue;
+    }
+    break;
+  }
+  const isExported = (node) => {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+    return Boolean(modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword));
+  };
+  const isDefault = (node) => {
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+    return Boolean(modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword));
+  };
+  const recordFunctionLike = (name, exported) => {
+    summary.functions.push(name);
+    if (exported) {
+      summary.exports.push(name);
+      if (ROUTE_HANDLER_NAMES.has(name)) summary.routeHandlers.push(name);
+    }
+    if (/^use[A-Z0-9]/.test(name)) summary.hooks.push(name);
+    if (/^[A-Z]/.test(name)) summary.reactComponents.push(name);
+  };
+  const stack = [sourceFile];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+      summary.imports.push(node.moduleSpecifier.text);
+    }
+    if (ts.isExportDeclaration(node)) {
+      if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+        summary.imports.push(node.moduleSpecifier.text);
+        if (node.exportClause && ts.isNamespaceExport(node.exportClause)) {
+          summary.exports.push(node.exportClause.name.text);
+        } else if (!node.exportClause) {
+          summary.reExports.push(node.moduleSpecifier.text);
+        }
+      }
+      if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+        for (const element of node.exportClause.elements) {
+          summary.exports.push(element.name.text);
+        }
+      }
+    }
+    if (ts.isExportAssignment(node)) {
+      summary.exports.push("default");
+    }
+    if (ts.isFunctionDeclaration(node)) {
+      const exported = isExported(node);
+      if (node.name) {
+        recordFunctionLike(node.name.text, exported);
+        if (isDefault(node)) summary.exports.push("default");
+      } else if (isDefault(node)) {
+        summary.exports.push("default");
+      }
+    }
+    if (ts.isClassDeclaration(node)) {
+      if (node.name) {
+        summary.classes.push(node.name.text);
+        if (isExported(node)) summary.exports.push(node.name.text);
+        if (isDefault(node)) summary.exports.push("default");
+        if (/^[A-Z]/.test(node.name.text)) summary.reactComponents.push(node.name.text);
+      } else if (isDefault(node)) {
+        summary.exports.push("default");
+      }
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      summary.interfaces.push(node.name.text);
+      if (isExported(node)) summary.exports.push(node.name.text);
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      summary.types.push(node.name.text);
+      if (isExported(node)) summary.exports.push(node.name.text);
+    }
+    if (ts.isEnumDeclaration(node)) {
+      summary.enums.push(node.name.text);
+      if (isExported(node)) summary.exports.push(node.name.text);
+    }
+    if (ts.isVariableStatement(node)) {
+      const exported = isExported(node);
+      for (const declaration of node.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name)) continue;
+        const name = declaration.name.text;
+        summary.variables.push(name);
+        if (exported) {
+          summary.exports.push(name);
+          if (ROUTE_HANDLER_NAMES.has(name)) summary.routeHandlers.push(name);
+        }
+        if (/^use[A-Z0-9]/.test(name)) summary.hooks.push(name);
+        if (/^[A-Z]/.test(name)) summary.reactComponents.push(name);
+      }
+    }
+    const children = [];
+    ts.forEachChild(node, (child) => {
+      children.push(child);
+    });
+    for (let index = children.length - 1; index >= 0; index--) {
+      stack.push(children[index]);
+    }
+  }
+  const dedupeSorted = (values) => Array.from(new Set(values)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  summary.directives = dedupeSorted(summary.directives);
+  summary.imports = dedupeSorted(summary.imports);
+  summary.exports = dedupeSorted(summary.exports);
+  summary.reExports = dedupeSorted(summary.reExports);
+  summary.functions = dedupeSorted(summary.functions);
+  summary.classes = dedupeSorted(summary.classes);
+  summary.interfaces = dedupeSorted(summary.interfaces);
+  summary.types = dedupeSorted(summary.types);
+  summary.enums = dedupeSorted(summary.enums);
+  summary.variables = dedupeSorted(summary.variables);
+  summary.reactComponents = dedupeSorted(summary.reactComponents);
+  summary.hooks = dedupeSorted(summary.hooks);
+  summary.routeHandlers = dedupeSorted(summary.routeHandlers);
+  return summary;
+}
+
+// src/generator/audit.ts
+function generateAuditReport(manifest, secretFindings) {
+  const lines = [
+    "# Codebase Health & Security Audit",
+    "",
+    `**Generated:** ${manifest.generatedAt}  `,
+    `**Git Branch:** \`${manifest.git.branch}\` (\`${manifest.git.commit.slice(0, 8)}\`${manifest.git.isDirty ? " - dirty" : ""})  `,
+    `**Total Files:** ${manifest.counts.totalFiles}  `,
+    `**Total Lines:** ${manifest.counts.totalLines.toLocaleString()}  `,
+    `**Total Size:** ${(manifest.counts.totalSizeBytes / (1024 * 1024)).toFixed(2)} MB  `,
+    `**Redacted Content Bytes:** ${manifest.totals.totalContentBytes.toLocaleString()}  `,
+    "",
+    "## 1. Security Scan & Redaction",
+    "",
+    "Matched values are replaced in place in `parts/*.md`; no excerpt of a matched",
+    "line is reproduced in this report or anywhere else in the snapshot.",
+    ""
+  ];
+  if (secretFindings.length === 0) {
+    lines.push("\u2705 **No secret-like patterns detected.** Clean security scan.", "");
+  } else {
+    const byRule = /* @__PURE__ */ new Map();
+    for (const finding of secretFindings) {
+      byRule.set(finding.rule, (byRule.get(finding.rule) ?? 0) + 1);
+    }
+    lines.push(
+      `\u26A0\uFE0F **${secretFindings.length} secret-like pattern(s) identified and redacted:**`,
+      "",
+      "| File | Line | Rule |",
+      "| :--- | :--- | :--- |"
+    );
+    for (const finding of secretFindings) {
+      lines.push(`| \`${finding.path ?? "unknown"}\` | ${finding.line} | \`${finding.rule}\` |`);
+    }
+    lines.push("", "### Matches by rule", "", "| Rule | Matches |", "| :--- | :--- |");
+    for (const [rule, count] of Array.from(byRule.entries()).sort((a, b) => b[1] - a[1])) {
+      lines.push(`| \`${rule}\` | ${count} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## 2. Large Files Analysis", "");
+  const largeFiles = manifest.files.filter((file) => file.isLarge);
+  if (largeFiles.length === 0) {
+    lines.push("\u2705 No files exceeded the large file budget.", "");
+  } else {
+    lines.push(
+      `Found ${largeFiles.length} file(s) exceeding the large file budget (${(manifest.budgets.largeFileBytes / 1024).toFixed(0)} KB):`,
+      "",
+      "| File | Size (KB) | Lines | Preview Status |",
+      "| :--- | :--- | :--- | :--- |"
+    );
+    for (const file of largeFiles) {
+      const sizeKb = (file.sizeBytes / 1024).toFixed(1);
+      const status = file.isPreviewTruncated ? "Truncated Head/Tail" : "Full";
+      lines.push(`| \`${file.relativePath}\` | ${sizeKb} KB | ${file.lines} | ${status} |`);
+    }
+    lines.push("");
+  }
+  lines.push(
+    "## 3. Architecture Layer Distribution",
+    "",
+    "| Layer | File Count | Percentage |",
+    "| :--- | :--- | :--- |"
+  );
+  const totalFiles = manifest.counts.totalFiles || 1;
+  for (const [layer, count] of Object.entries(manifest.layers).sort(
+    (a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+  )) {
+    const pct = (count / totalFiles * 100).toFixed(1);
+    lines.push(`| \`${layer}\` | ${count} | ${pct}% |`);
+  }
+  lines.push("");
+  lines.push(
+    "## 4. File Kind Distribution",
+    "",
+    "| Kind | File Count | Percentage |",
+    "| :--- | :--- | :--- |"
+  );
+  for (const [kind, count] of Object.entries(manifest.kinds).sort(
+    (a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+  )) {
+    const pct = (count / totalFiles * 100).toFixed(1);
+    lines.push(`| \`${kind}\` | ${count} | ${pct}% |`);
+  }
+  lines.push("");
+  lines.push("## 5. Skipped / Non-Text Files", "");
+  if (manifest.skipped.length === 0) {
+    lines.push("No files were skipped.", "");
+  } else {
+    lines.push(
+      `Total skipped: ${manifest.skipped.length}`,
+      "",
+      "| File | Reason | Detail |",
+      "| :--- | :--- | :--- |"
+    );
+    for (const skip of manifest.skipped) {
+      lines.push(`| \`${skip.path}\` | \`${skip.reason}\` | ${skip.detail ?? "-"} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/partitioner/chunker.ts
+import * as crypto from "crypto";
+var HEADER_RESERVE_BYTES = 2048;
+var MIN_SECTION_BUDGET_BYTES = 512;
+var MAX_SPLIT_PASSES = 64;
+function partitionFiles(files, maxPartBytes, contentFingerprint) {
+  if (files.length === 0) return [];
+  const budget = Math.max(MIN_SECTION_BUDGET_BYTES + HEADER_RESERVE_BYTES, maxPartBytes);
+  const sectionBudget = budget - HEADER_RESERVE_BYTES;
+  const prepared = files.map((file) => prepareSection(file, sectionBudget));
+  let groups = greedyGroups(prepared, budget);
+  for (let pass = 0; pass < MAX_SPLIT_PASSES; pass++) {
+    const rendered = renderGroups(groups, contentFingerprint);
+    const oversized = rendered.findIndex((part) => part.metadata.byteSize > budget);
+    if (oversized === -1) return rendered;
+    const group = groups[oversized];
+    if (group.length > 1) {
+      const moved = group.pop();
+      groups.splice(oversized + 1, 0, [moved]);
+      continue;
+    }
+    const [section] = group;
+    const overflow = rendered[oversized].metadata.byteSize - budget;
+    const currentContent = section.file.content ?? "";
+    const shrinkTo = Math.max(
+      0,
+      Buffer.byteLength(currentContent, "utf8") - overflow - 64
+    );
+    const shrunk = truncateToBytes(currentContent, shrinkTo);
+    if (shrunk.isTruncated) {
+      applyTruncatedContent(section.file, shrunk.content);
+      section.text = renderFileSection(section.file);
+      section.byteSize = Buffer.byteLength(section.text, "utf8");
+      continue;
+    }
+    const marker = "\n... [part truncated: cannot fit budget] ...\n";
+    const target = Math.max(0, budget - Buffer.byteLength(marker, "utf8"));
+    const clipped = truncateToBytes(rendered[oversized].markdown, target);
+    rendered[oversized] = rehashPart(rendered[oversized], clipped.content + marker);
+    return rendered;
+  }
+  return enforceBudget(renderGroups(groups, contentFingerprint), budget);
+}
+function enforceBudget(parts, budget) {
+  const marker = "\n... [part truncated: cannot fit budget] ...\n";
+  const target = Math.max(0, budget - Buffer.byteLength(marker, "utf8"));
+  return parts.map((part) => {
+    if (part.metadata.byteSize <= budget) return part;
+    const clipped = truncateToBytes(part.markdown, target);
+    return rehashPart(part, clipped.content + marker);
+  });
+}
+function renumberParts(parts, contentFingerprint) {
+  const total = parts.length;
+  if (total === 0) return [];
+  const zeroPad = (index) => String(index).padStart(Math.max(3, String(total).length), "0");
+  const nameFor = (position) => `part-${zeroPad(position)}.md`;
+  const marker = "## Contents\n";
+  return parts.map((part, index) => {
+    const markerIndex = part.markdown.indexOf(marker);
+    const body = markerIndex === -1 ? "" : part.markdown.slice(markerIndex + marker.length);
+    const included = part.metadata.includedFiles;
+    if (markerIndex === -1) {
+      throw new Error(`${part.filename} has no "## Contents" section to re-number.`);
+    }
+    const layerCounts = {};
+    const kindCounts = {};
+    for (const file of included) {
+      layerCounts[file.layer] = (layerCounts[file.layer] || 0) + 1;
+      kindCounts[file.kind] = (kindCounts[file.kind] || 0) + 1;
+    }
+    const header = [
+      `# Codebase Snapshot Part ${zeroPad(index + 1)} of ${zeroPad(total)}`,
+      "",
+      `- Previous: ${index === 0 ? "none" : nameFor(index)}`,
+      `- Next: ${index === total - 1 ? "none" : nameFor(index + 2)}`,
+      `- Files: ${included.length}`,
+      `- Content Fingerprint: ${contentFingerprint || "none"}`,
+      `- Layers: ${topEntries(layerCounts, 6) || "none"}`,
+      `- Kinds: ${topEntries(kindCounts, 8) || "none"}`,
+      "",
+      "## Files",
+      "",
+      "```text",
+      ...included.map((file) => displayPath(file.relativePath)),
+      "```",
+      "",
+      "## Contents",
+      ""
+    ].join("\n");
+    const markdown = (header + body).replace(/\r\n/g, "\n");
+    const metadata = {
+      ...part.metadata,
+      index: index + 1,
+      filename: nameFor(index + 1),
+      byteSize: Buffer.byteLength(markdown, "utf8"),
+      sha256: crypto.createHash("sha256").update(markdown).digest("hex"),
+      lines: countLines(markdown),
+      fileCount: included.length,
+      layersCovered: Object.keys(layerCounts).sort()
+    };
+    return { filename: metadata.filename, markdown, metadata };
+  });
+}
+var SECTION_TRUNCATION_NOTICE = "\n... [section truncated: metadata alone exceeds the part budget] ...\n";
+var METADATA_VALUE_MAX = 200;
+var DISPLAY_PATH_MAX = 300;
+function capValue(value, max) {
+  if (value.length <= max) return value;
+  const half = Math.floor((max - 1) / 2);
+  return `${value.slice(0, half)}\u2026${value.slice(value.length - half)}`;
+}
+var capMetadata = (value) => capValue(value, METADATA_VALUE_MAX);
+var displayPath = (value) => capValue(value, DISPLAY_PATH_MAX);
+function topEntries(counts, limit) {
+  return Object.entries(counts).sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).slice(0, limit).map(([key, value]) => `${capMetadata(key)} (${value})`).join(", ");
+}
+function prepareSection(file, sectionBudget) {
+  let text = renderFileSection(file);
+  let byteSize = Buffer.byteLength(text, "utf8");
+  if (byteSize <= sectionBudget) return { file, text, byteSize };
+  const shrinkBody = () => {
+    const content = file.content ?? "";
+    const overhead = byteSize - Buffer.byteLength(content, "utf8");
+    const allowed = sectionBudget - overhead - 96;
+    if (allowed <= 0) return;
+    const truncated = truncateToBytes(content, allowed);
+    if (!truncated.isTruncated) return;
+    applyTruncatedContent(file, truncated.content);
+    text = renderFileSection(file);
+    byteSize = Buffer.byteLength(text, "utf8");
+  };
+  shrinkBody();
+  if (byteSize > sectionBudget && file.summary) {
+    file.summary = void 0;
+    file.summaryOmitted = true;
+    text = renderFileSection(file);
+    byteSize = Buffer.byteLength(text, "utf8");
+    shrinkBody();
+  }
+  if (byteSize > sectionBudget) {
+    const target = sectionBudget - Buffer.byteLength(SECTION_TRUNCATION_NOTICE, "utf8");
+    const truncated = truncateToBytes(text, Math.max(0, target));
+    text = truncated.content + SECTION_TRUNCATION_NOTICE;
+    byteSize = Buffer.byteLength(text, "utf8");
+  }
+  return { file, text, byteSize };
+}
+function applyTruncatedContent(file, content) {
+  file.content = content;
+  file.isPreviewTruncated = true;
+  file.inclusionMode = "preview";
+  file.includedBytes = Buffer.byteLength(content, "utf8");
+  file.includedLines = countLines(content);
+}
+function rehashPart(part, markdown) {
+  return {
+    filename: part.filename,
+    markdown,
+    metadata: {
+      ...part.metadata,
+      byteSize: Buffer.byteLength(markdown, "utf8"),
+      sha256: crypto.createHash("sha256").update(markdown).digest("hex"),
+      lines: countLines(markdown)
+    }
+  };
+}
+function greedyGroups(sections, budget) {
+  const groups = [];
+  let current = [];
+  let bodyBytes = 0;
+  let pathBytes = 0;
+  for (const section of sections) {
+    const sectionPathBytes = Buffer.byteLength(
+      `${displayPath(section.file.relativePath)}
+`,
+      "utf8"
+    );
+    const projected = bodyBytes + section.byteSize + pathBytes + sectionPathBytes + HEADER_RESERVE_BYTES;
+    if (current.length > 0 && projected > budget) {
+      groups.push(current);
+      current = [];
+      bodyBytes = 0;
+      pathBytes = 0;
+    }
+    current.push(section);
+    bodyBytes += section.byteSize;
+    pathBytes += sectionPathBytes;
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+function renderGroups(groups, contentFingerprint) {
+  const total = groups.length;
+  const zeroPad = (index) => String(index).padStart(Math.max(3, String(total).length), "0");
+  return groups.map((group, index) => {
+    const filename = `part-${zeroPad(index + 1)}.md`;
+    const prev = index === 0 ? "none" : `part-${zeroPad(index)}.md`;
+    const next = index === total - 1 ? "none" : `part-${zeroPad(index + 2)}.md`;
+    for (const section of group) {
+      section.file.part = filename;
+    }
+    const layersCovered = Array.from(new Set(group.map((s) => s.file.layer))).sort();
+    const layerCounts = {};
+    const kindCounts = {};
+    for (const section of group) {
+      layerCounts[section.file.layer] = (layerCounts[section.file.layer] || 0) + 1;
+      kindCounts[section.file.kind] = (kindCounts[section.file.kind] || 0) + 1;
+    }
+    const header = [
+      `# Codebase Snapshot Part ${zeroPad(index + 1)} of ${zeroPad(total)}`,
+      "",
+      `- Previous: ${prev}`,
+      `- Next: ${next}`,
+      `- Files: ${group.length}`,
+      `- Content Fingerprint: ${contentFingerprint || "none"}`,
+      `- Layers: ${topEntries(layerCounts, 6) || "none"}`,
+      `- Kinds: ${topEntries(kindCounts, 8) || "none"}`,
+      "",
+      "## Files",
+      "",
+      "```text",
+      ...group.map((s) => displayPath(s.file.relativePath)),
+      "```",
+      "",
+      "## Contents",
+      ""
+    ].join("\n");
+    const content = (header + group.map((s) => s.text).join("")).replace(/\r\n/g, "\n");
+    const byteSize = Buffer.byteLength(content, "utf8");
+    const sha256 = crypto.createHash("sha256").update(content).digest("hex");
+    const includedFiles = group.map(({ file }) => ({
+      relativePath: file.relativePath,
+      sourceBytes: file.sizeBytes,
+      includedBytes: file.includedBytes,
+      lines: file.includedLines,
+      layer: file.layer,
+      kind: file.kind
+    }));
+    const metadata = {
+      index: index + 1,
+      filename,
+      byteSize,
+      sha256,
+      lines: countLines(content),
+      fileCount: group.length,
+      layersCovered,
+      includedFiles
+    };
+    return { filename, markdown: content, metadata };
+  });
+}
+function renderFileSection(file) {
+  const content = file.content ?? "";
+  const fence = fenceForContent(content);
+  const anchor = anchorForPath(file.relativePath);
+  return [
+    `<a id="${anchor}"></a>`,
+    `### FILE: ${displayPath(file.relativePath)}`,
+    "",
+    `- Layer: ${capMetadata(file.layer)}`,
+    `- Kind: ${capMetadata(file.kind)}`,
+    `- Language: ${capMetadata(file.language)}`,
+    `- Inclusion: ${file.inclusionMode}`,
+    `- Source Bytes: ${file.sizeBytes}`,
+    `- Source Lines: ${file.originalLines}`,
+    `- Included Lines: ${file.includedLines}`,
+    `- SHA-256: ${file.hashSha256}`,
+    ...renderSummary(file.summary),
+    ...file.summaryOmitted ? ["- Summary: (omitted: exceeds the part budget)"] : [],
+    "",
+    file.inclusionMode === "preview" ? "#### Bounded Preview" : "#### Content",
+    "",
+    `${fence}${capMetadata(file.language)}`,
+    content.endsWith("\n") ? content.slice(0, -1) : content,
+    fence,
+    "",
+    ""
+  ].join("\n");
+}
+function fenceForContent(content) {
+  const matches = content.match(/`+/g);
+  const maxRun = matches?.reduce((max, run) => Math.max(max, run.length), 0) ?? 0;
+  return "`".repeat(Math.max(4, maxRun + 1));
+}
+function renderSummary(summary) {
+  if (!summary) return [];
+  if (typeof summary === "string") return [`- Summary: ${summary}`];
+  return ["- Summary:", "```json", JSON.stringify(summary, null, 2), "```"];
+}
+function anchorForPath(filePath) {
+  const slug = filePath.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  const digest = crypto.createHash("sha256").update(filePath).digest("hex").slice(0, 8);
+  return `${slug || "file"}-${digest}`;
+}
+
+// src/generator/monolith.ts
+function generateMonolithJson(manifest, filesWithContent) {
+  return JSON.stringify({ manifest, files: filesWithContent }, null, 2);
+}
+function generateMonolithMarkdown(manifest, filesWithContent) {
+  const sections = filesWithContent.map((file) => {
+    const content = (file.content ?? "").replace(/\r\n/g, "\n");
+    const fence = fenceForContent(content);
+    return [
+      `## File: ${file.relativePath}`,
+      "",
+      `- **Layer:** \`${file.layer}\``,
+      `- **Kind:** \`${file.kind}\``,
+      `- **Lines:** \`${file.originalLines}\``,
+      `- **Size:** \`${file.sizeBytes} B\``,
+      `- **Inclusion:** \`${file.inclusionMode}\``,
+      "",
+      `${fence}${file.language}`,
+      content.endsWith("\n") ? content.slice(0, -1) : content,
+      fence,
+      "",
+      "---",
+      ""
+    ].join("\n");
+  });
+  return [
+    `# Complete Codebase Monolith`,
+    "",
+    `**Generated:** ${manifest.generatedAt}  `,
+    `**Total Files:** ${manifest.counts.totalFiles}  `,
+    `**Total Lines:** ${manifest.counts.totalLines}  `,
+    "",
+    "---",
+    "",
+    ...sections
+  ].join("\n");
+}
+
+// src/generator/navigation.ts
+function generateNavigation(manifest) {
+  const lines = [
+    "# Codebase Navigation Index",
+    "",
+    "Fast lookup index mapping every file to its snapshot chunk.",
+    "",
+    "## Parts Overview",
+    "",
+    "| Part | File Count | Size (KB) | Layers Covered |",
+    "| :--- | :--- | :--- | :--- |"
+  ];
+  for (const part of manifest.parts) {
+    const sizeKb = (part.byteSize / 1024).toFixed(1);
+    lines.push(
+      `| [${part.filename}](../parts/${part.filename}) | ${part.fileCount} | ${sizeKb} KB | ${part.layersCovered.join(", ")} |`
+    );
+  }
+  lines.push(
+    "",
+    "## File Directory",
+    "",
+    "| File | Part | Layer | Kind | Lines | Size |",
+    "| :--- | :--- | :--- | :--- | :--- | :--- |"
+  );
+  const filePartMap = /* @__PURE__ */ new Map();
+  for (const part of manifest.parts) {
+    for (const file of part.includedFiles) {
+      filePartMap.set(file.relativePath, part.filename);
+    }
+  }
+  for (const file of manifest.files) {
+    const partFilename = filePartMap.get(file.relativePath) || file.part || "none";
+    const anchor = anchorForPath(file.relativePath);
+    const link = `[${file.relativePath}](../parts/${partFilename}#${anchor})`;
+    const sizeStr = `${(file.sizeBytes / 1024).toFixed(1)} KB`;
+    lines.push(
+      `| ${link} | \`${partFilename}\` | \`${file.layer}\` | \`${file.kind}\` | ${file.lines} | ${sizeStr} |`
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/generator/readme.ts
+function generateReadme(manifest) {
+  const lines = [
+    "# Codebase Snapshot",
+    "",
+    "This directory contains a complete, partitioned, and audited snapshot of this codebase, optimized for Large Language Models (LLMs) and automated agents.",
+    "",
+    "## Snapshot Metrics",
+    "",
+    `- **Generated At:** \`${manifest.generatedAt}\``,
+    `- **Schema Version:** \`${manifest.schemaVersion}\``,
+    `- **Branch:** \`${manifest.git.branch}\` (\`${manifest.git.commit.slice(0, 8)}\`${manifest.git.isDirty ? " - dirty" : ""})`,
+    `- **Total Tracked Files:** \`${manifest.counts.totalFiles}\``,
+    `- **Total Code Lines:** \`${manifest.counts.totalLines.toLocaleString()}\``,
+    `- **Total Size:** \`${(manifest.counts.totalSizeBytes / (1024 * 1024)).toFixed(2)} MB\``,
+    `- **Emitted Content:** \`${(manifest.totals.totalContentBytes / (1024 * 1024)).toFixed(2)} MB\``,
+    `- **Part Count:** \`${manifest.counts.partsCount}\` (budget \`${(manifest.budgets.maxPartBytes / 1024).toFixed(0)} KB\` per part)`,
+    `- **Generator:** \`${manifest.generator.name}@${manifest.generator.version}\``,
+    "",
+    "## Documentation & Reports",
+    "",
+    "- [reports/navigation.md](reports/navigation.md) \u2014 Comprehensive file directory mapping files to chunk files.",
+    "- [reports/project-tree.md](reports/project-tree.md) \u2014 Full visual ASCII directory tree of the repository.",
+    "- [reports/audit.md](reports/audit.md) \u2014 Security scan counts, large files report, and architectural breakdown.",
+    "- [manifest.json](manifest.json) \u2014 Complete machine-readable metadata and AST symbol registry.",
+    "",
+    "## Snapshot Parts",
+    "",
+    "The codebase is partitioned into budget-safe chunks under `parts/` to avoid context window degradation:",
+    "",
+    "| Part | File Count | Size (KB) | Layers Covered |",
+    "| :--- | :--- | :--- | :--- |"
+  ];
+  for (const part of manifest.parts) {
+    const sizeKb = (part.byteSize / 1024).toFixed(1);
+    lines.push(
+      `| [${part.filename}](parts/${part.filename}) | ${part.fileCount} | ${sizeKb} KB | ${part.layersCovered.join(", ")} |`
+    );
+  }
+  lines.push(
+    "",
+    "## AI Agent Ingestion Guide",
+    "",
+    "1. Read `reports/navigation.md` or `reports/project-tree.md` first to locate target features or files.",
+    "2. Open only the specific `parts/part-XXX.md` file holding the target modules.",
+    "3. Inspect `manifest.json` for precise dependency and AST symbol maps.",
+    "4. Check `manifest.validation.status` before trusting the snapshot; `snapshot validate` re-checks it against disk.",
+    ""
+  );
+  return lines.join("\n");
+}
+
+// src/generator/tree.ts
+var MAX_TREE_LINES = 2e4;
+function generateProjectTree(filePaths) {
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const filePath of filePaths) {
+    const parts = filePath.split("/").filter((part) => part.length > 0);
+    let current = root;
+    for (const part of parts) {
+      let child = current.children.get(part);
+      if (!child) {
+        child = { children: /* @__PURE__ */ new Map() };
+        current.children.set(part, child);
+      }
+      current = child;
+    }
+  }
+  const lines = ["# Project Tree", "", "```text", "."];
+  let truncatedAt = -1;
+  function walk(node, prefix) {
+    if (truncatedAt !== -1) return;
+    const keys = Array.from(node.children.keys()).sort((a, b) => {
+      const aIsDir = node.children.get(a).children.size > 0;
+      const bIsDir = node.children.get(b).children.size > 0;
+      if (aIsDir !== bIsDir) return aIsDir ? -1 : 1;
+      return a < b ? -1 : a > b ? 1 : 0;
+    });
+    keys.forEach((key, index) => {
+      if (truncatedAt !== -1) return;
+      const isLast = index === keys.length - 1;
+      const child = node.children.get(key);
+      const isDirectory = child.children.size > 0;
+      lines.push(`${prefix}${isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 "}${key}${isDirectory ? "/" : ""}`);
+      if (lines.length >= MAX_TREE_LINES) {
+        truncatedAt = lines.length;
+        return;
+      }
+      walk(child, prefix + (isLast ? "    " : "\u2502   "));
+    });
+  }
+  walk(root, "");
+  if (truncatedAt !== -1) {
+    lines.push(`... [tree truncated at ${MAX_TREE_LINES} lines] ...`);
+  }
+  lines.push("```", "");
+  return lines.join("\n");
+}
+
+// src/scanner/binary.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".ico",
+  ".bmp",
+  ".tiff",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".tgz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".mov",
+  ".avi",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".wasm",
+  ".node",
+  ".exe",
+  ".dll",
+  ".dylib",
+  ".so"
+]);
+function isBinaryExtension(filePath) {
+  const ext = path7.extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+function isBinaryBuffer(buffer) {
+  const checkLength = Math.min(buffer.length, 8192);
+  for (let index = 0; index < checkLength; index++) {
+    if (buffer[index] === 0) return true;
+  }
+  return false;
+}
+function isBinaryFile(absolutePath) {
+  if (isBinaryExtension(absolutePath)) return true;
+  let fd;
+  try {
+    fd = fs6.openSync(absolutePath, "r");
+    const buffer = Buffer.alloc(8192);
+    const bytesRead = fs6.readSync(fd, buffer, 0, 8192, 0);
+    if (bytesRead === 0) return false;
+    return isBinaryBuffer(buffer.subarray(0, bytesRead));
+  } catch {
+    return false;
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs6.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/validator/validate.ts
+import * as crypto2 from "crypto";
+import * as fs7 from "fs";
+import * as path8 from "path";
+function emptyDrift() {
+  return {
+    missingInSnapshot: [],
+    missingOnDisk: [],
+    hashMismatches: [],
+    partIssues: [],
+    totalsMismatches: [],
+    configMismatches: []
+  };
+}
+function sha256Hex(buffer) {
+  return crypto2.createHash("sha256").update(buffer).digest("hex");
+}
+function validateSnapshot(configInput) {
+  assertUsableConfigInput(configInput);
+  const config = isResolvedConfig(configInput) ? normalizeResolvedConfig(configInput) : resolveConfig(configInput);
+  const manifestPath = path8.join(config.cwd, config.outDir, "manifest.json");
+  if (!fs7.existsSync(manifestPath)) {
+    return {
+      valid: false,
+      manifestPresent: false,
+      drift: emptyDrift(),
+      errors: [`Snapshot manifest not found at: ${manifestPath}`],
+      warnings: []
+    };
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(fs7.readFileSync(manifestPath, "utf8"));
+  } catch (err) {
+    return {
+      valid: false,
+      manifestPresent: true,
+      drift: emptyDrift(),
+      errors: [`Failed to parse snapshot manifest: ${err.message}`],
+      warnings: []
+    };
+  }
+  if (!manifest || typeof manifest !== "object" || !Array.isArray(manifest.files) || !Array.isArray(manifest.skipped) || !Array.isArray(manifest.parts)) {
+    return {
+      valid: false,
+      manifestPresent: true,
+      drift: emptyDrift(),
+      errors: [
+        `${manifestPath} is not a snapshot manifest v3: expected arrays for "files", "skipped" and "parts".`
+      ],
+      warnings: []
+    };
+  }
+  const drift = emptyDrift();
+  const warnings = [];
+  const snapshotDir = path8.join(config.cwd, config.outDir);
+  const manifestFileMap = /* @__PURE__ */ new Map();
+  for (const file of manifest.files) {
+    if (file && typeof file.relativePath === "string") {
+      manifestFileMap.set(file.relativePath, file.hashSha256);
+    }
+  }
+  const skippedSet = new Set(
+    manifest.skipped.filter((entry) => entry && typeof entry.path === "string").map((entry) => entry.path)
+  );
+  const collection = collectFiles(config.cwd, {
+    includePatterns: config.include,
+    excludePatterns: config.excludePatterns,
+    includeSensitiveFiles: config.includeSensitiveFiles
+  });
+  for (const diskFile of collection.files) {
+    if (skippedSet.has(diskFile)) continue;
+    const snapshotHash = manifestFileMap.get(diskFile);
+    if (!snapshotHash) {
+      drift.missingInSnapshot.push(diskFile);
+      continue;
+    }
+    let diskHash;
+    try {
+      diskHash = sha256Hex(fs7.readFileSync(path8.join(config.cwd, diskFile)));
+    } catch {
+      drift.missingOnDisk.push(diskFile);
+      continue;
+    }
+    if (diskHash !== snapshotHash) {
+      drift.hashMismatches.push({ path: diskFile, diskHash, snapshotHash });
+    }
+  }
+  for (const snapshotFile of manifestFileMap.keys()) {
+    if (!fs7.existsSync(path8.join(config.cwd, snapshotFile))) {
+      drift.missingOnDisk.push(snapshotFile);
+    }
+  }
+  const maxEffectiveBudget = Math.max(
+    config.maxPartBytes,
+    config.budgets.default,
+    ...Object.values(config.budgets.byLayer)
+  );
+  const partNames = /* @__PURE__ */ new Set();
+  for (const part of manifest.parts) {
+    if (!part || typeof part.filename !== "string") continue;
+    partNames.add(part.filename);
+    if (!config.artifacts.parts) continue;
+    const partPath = path8.join(snapshotDir, "parts", part.filename);
+    let buffer;
+    try {
+      buffer = fs7.readFileSync(partPath);
+    } catch {
+      drift.partIssues.push({ part: part.filename, issue: "missing from snapshot/parts" });
+      continue;
+    }
+    if (buffer.length !== part.byteSize) {
+      drift.partIssues.push({
+        part: part.filename,
+        issue: `byteSize is ${part.byteSize} in the manifest but ${buffer.length} on disk`
+      });
+    }
+    if (sha256Hex(buffer) !== part.sha256) {
+      drift.partIssues.push({ part: part.filename, issue: "sha256 does not match the manifest" });
+    }
+    if (buffer.length > maxEffectiveBudget) {
+      drift.partIssues.push({
+        part: part.filename,
+        issue: `${buffer.length} B exceeds the effective part budget ${maxEffectiveBudget} B`
+      });
+    }
+  }
+  const filesInParts = manifest.parts.reduce(
+    (total, part) => total + (typeof part?.fileCount === "number" ? part.fileCount : 0),
+    0
+  );
+  if (filesInParts !== manifest.files.length) {
+    drift.partIssues.push({
+      part: "(totals)",
+      issue: `parts list ${filesInParts} file(s) but the manifest lists ${manifest.files.length}`
+    });
+  }
+  for (const file of manifest.files) {
+    if (file?.part && !partNames.has(file.part)) {
+      drift.partIssues.push({
+        part: file.part,
+        issue: `${file.relativePath} points at a part that is not in the manifest`
+      });
+    }
+  }
+  const recorded = manifest.config;
+  if (recorded && typeof recorded === "object") {
+    if (recorded.maxPartBytes !== config.maxPartBytes) {
+      drift.configMismatches.push(
+        `maxPartBytes: manifest ${recorded.maxPartBytes} vs current ${config.maxPartBytes}`
+      );
+    }
+    if (recorded.largeFileBytes !== config.largeFileBytes) {
+      drift.configMismatches.push(
+        `largeFileBytes: manifest ${recorded.largeFileBytes} vs current ${config.largeFileBytes}`
+      );
+    }
+    if (recorded.previewHeadLines !== config.previewHeadLines) {
+      drift.configMismatches.push(
+        `previewHeadLines: manifest ${recorded.previewHeadLines} vs current ${config.previewHeadLines}`
+      );
+    }
+    if (recorded.previewTailLines !== config.previewTailLines) {
+      drift.configMismatches.push(
+        `previewTailLines: manifest ${recorded.previewTailLines} vs current ${config.previewTailLines}`
+      );
+    }
+    if (recorded.includeSensitiveFiles !== config.includeSensitiveFiles) {
+      drift.configMismatches.push(
+        `includeSensitiveFiles: manifest ${recorded.includeSensitiveFiles} vs current ${config.includeSensitiveFiles}`
+      );
+    }
+    const recordedExcludes = Array.isArray(recorded.excludePatterns) ? recorded.excludePatterns : [];
+    if (recordedExcludes.join("\0") !== config.excludePatterns.join("\0")) {
+      drift.configMismatches.push(
+        `excludePatterns: manifest [${recordedExcludes.join(", ")}] vs current [${config.excludePatterns.join(", ")}]`
+      );
+    }
+    const recordedInclude = Array.isArray(recorded.include) ? recorded.include : [];
+    if (recordedInclude.join("\0") !== config.include.join("\0")) {
+      drift.configMismatches.push(
+        `include: manifest [${recordedInclude.join(", ")}] vs current [${config.include.join(", ")}]`
+      );
+    }
+    if (recorded?.artifacts && typeof recorded.artifacts === "object") {
+      for (const name of ARTIFACT_NAMES) {
+        if (recorded.artifacts[name] !== config.artifacts[name]) {
+          drift.configMismatches.push(
+            `artifacts.${name}: manifest ${recorded.artifacts[name]} vs current ${config.artifacts[name]}`
+          );
+        }
+      }
+    }
+    if (recorded?.layersMode !== void 0 && recorded.layersMode !== config.layersMode) {
+      drift.configMismatches.push(
+        `layersMode: manifest ${recorded.layersMode} vs current ${config.layersMode}`
+      );
+    }
+    const recordedBudgets = recorded?.budgets;
+    if (recordedBudgets && typeof recordedBudgets === "object") {
+      if (recordedBudgets.default !== config.budgets.default) {
+        drift.configMismatches.push(
+          `budgets.default: manifest ${recordedBudgets.default} vs current ${config.budgets.default}`
+        );
+      }
+      const recordedByLayer = recordedBudgets.byLayer ?? {};
+      const layerNames = /* @__PURE__ */ new Set([
+        ...Object.keys(recordedByLayer),
+        ...Object.keys(config.budgets.byLayer)
+      ]);
+      for (const layer of Array.from(layerNames).sort()) {
+        if (recordedByLayer[layer] !== config.budgets.byLayer[layer]) {
+          drift.configMismatches.push(
+            `budgets.byLayer.${layer}: manifest ${recordedByLayer[layer]} vs current ${config.budgets.byLayer[layer]}`
+          );
+        }
+      }
+    }
+  } else {
+    drift.configMismatches.push("manifest does not record the effective configuration");
+  }
+  const totalsMismatches = drift.totalsMismatches;
+  const expectEqual = (label, recordedValue, actual) => {
+    if (recordedValue !== actual) {
+      totalsMismatches.push(`${label}: manifest ${String(recordedValue)} vs actual ${actual}`);
+    }
+  };
+  const counts = manifest.counts ?? {};
+  const totals = manifest.totals ?? {};
+  const sumSourceBytes = manifest.files.reduce(
+    (total, file) => total + (typeof file?.sizeBytes === "number" ? file.sizeBytes : 0),
+    0
+  );
+  const sumIncludedBytes = manifest.parts.reduce(
+    (total, part) => total + (Array.isArray(part?.includedFiles) ? part.includedFiles.reduce(
+      (inner, entry) => inner + (typeof entry?.includedBytes === "number" ? entry.includedBytes : 0),
+      0
+    ) : 0),
+    0
+  );
+  expectEqual("counts.totalFiles", counts.totalFiles, manifest.files.length);
+  expectEqual("counts.partsCount", counts.partsCount, manifest.parts.length);
+  expectEqual("counts.skippedCount", counts.skippedCount, manifest.skipped.length);
+  expectEqual("counts.totalSizeBytes", counts.totalSizeBytes, sumSourceBytes);
+  expectEqual("totals.includedFiles", totals.includedFiles, manifest.files.length);
+  expectEqual("totals.partCount", totals.partCount, manifest.parts.length);
+  expectEqual("totals.skippedFiles", totals.skippedFiles, manifest.skipped.length);
+  expectEqual("totals.totalSourceBytes", totals.totalSourceBytes, sumSourceBytes);
+  expectEqual("totals.totalContentBytes", totals.totalContentBytes, sumIncludedBytes);
+  expectEqual(
+    "totals.candidateFiles",
+    totals.candidateFiles,
+    manifest.files.length + manifest.skipped.length
+  );
+  expectEqual(
+    "totals.warningCount",
+    totals.warningCount,
+    Array.isArray(manifest.warnings) ? manifest.warnings.length : 0
+  );
+  if (typeof totals.fullFiles === "number" && typeof totals.previewFiles === "number" && totals.fullFiles + totals.previewFiles !== manifest.files.length) {
+    totalsMismatches.push(
+      `totals.fullFiles + previewFiles (${totals.fullFiles} + ${totals.previewFiles}) != ${manifest.files.length} files`
+    );
+  }
+  if (manifest.budgets && manifest.budgets.maxPartBytes !== config.maxPartBytes) {
+    totalsMismatches.push(
+      `budgets.maxPartBytes: manifest ${manifest.budgets.maxPartBytes} vs current ${config.maxPartBytes}`
+    );
+  }
+  if (manifest.budgets && manifest.budgets.largeFileBytes !== config.largeFileBytes) {
+    totalsMismatches.push(
+      `budgets.largeFileBytes: manifest ${manifest.budgets.largeFileBytes} vs current ${config.largeFileBytes}`
+    );
+  }
+  if (manifest.git && typeof manifest.git.commit === "string") {
+    const current = getGitInfo(config.cwd, config.branch);
+    if (manifest.git.commit !== "unknown" && current.commit !== "unknown" && manifest.git.commit !== current.commit) {
+      warnings.push(
+        `Snapshot was generated at commit ${manifest.git.commit.slice(0, 8)} but HEAD is ${current.commit.slice(0, 8)}.`
+      );
+    }
+    if (current.isDirty) {
+      warnings.push("Working tree has uncommitted changes.");
+    }
+  }
+  if (manifest.validation && manifest.validation.status === "failed") {
+    const declared = Array.isArray(manifest.validation.errors) ? manifest.validation.errors : [];
+    for (const error of declared) {
+      drift.configMismatches.push(`manifest declared itself invalid: ${error}`);
+    }
+  }
+  for (const [key, artifact] of [
+    ["full-codebase.json", manifest.artifacts?.fullJson],
+    ["full-codebase.md", manifest.artifacts?.fullMarkdown]
+  ]) {
+    if (!artifact) continue;
+    const artifactPath = path8.join(snapshotDir, key);
+    try {
+      const buffer = fs7.readFileSync(artifactPath);
+      if (sha256Hex(buffer) !== artifact.sha256 || buffer.length !== artifact.byteSize) {
+        drift.partIssues.push({ part: key, issue: "artifact does not match its recorded digest" });
+      }
+    } catch {
+      drift.partIssues.push({ part: key, issue: "declared artifact is missing" });
+    }
+  }
+  if (manifest.git && manifest.git.branch && manifest.git.branch !== config.branch) {
+    warnings.push(
+      `Snapshot was generated on branch "${manifest.git.branch}" but the configured branch is "${config.branch}".`
+    );
+  }
+  const errors = [];
+  if (drift.missingInSnapshot.length > 0) {
+    errors.push(`${drift.missingInSnapshot.length} file(s) on disk are missing from the snapshot.`);
+  }
+  if (drift.missingOnDisk.length > 0) {
+    errors.push(`${drift.missingOnDisk.length} file(s) in snapshot no longer exist on disk.`);
+  }
+  if (drift.hashMismatches.length > 0) {
+    errors.push(
+      `${drift.hashMismatches.length} file(s) have been modified since the snapshot was generated.`
+    );
+  }
+  if (drift.partIssues.length > 0) {
+    errors.push(`${drift.partIssues.length} snapshot artefact problem(s) detected.`);
+  }
+  if (drift.totalsMismatches.length > 0) {
+    errors.push(
+      `${drift.totalsMismatches.length} manifest bookkeeping value(s) disagree with the snapshot contents.`
+    );
+  }
+  if (drift.configMismatches.length > 0) {
+    errors.push(
+      `${drift.configMismatches.length} configuration mismatch(es) between the manifest and this run.`
+    );
+  }
+  return {
+    valid: errors.length === 0,
+    manifestPresent: true,
+    drift,
+    errors,
+    warnings
+  };
+}
+
+// src/index.ts
+var GENERATOR_NAME = "@ankurhalder/codebase-snapshot";
+var GENERATOR_VERSION = "2.0.0";
+var SCHEMA_VERSION = "3.0.0";
+function sha256Hex2(input) {
+  return crypto3.createHash("sha256").update(input).digest("hex");
+}
+var SUMMARY_EXTENSIONS = [
+  ".ts",
+  ".mts",
+  ".cts",
+  ".tsx",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".jsx",
+  ".json",
+  ".jsonc",
+  ".md",
+  ".mdx"
+];
+function summarizeFile(relativePath, redactedContent) {
+  const lower = relativePath.toLowerCase();
+  if (!SUMMARY_EXTENSIONS.some((extension) => lower.endsWith(extension))) {
+    return void 0;
+  }
+  if (lower.endsWith(".json") || lower.endsWith(".jsonc")) {
+    return summarizeJson(redactedContent);
+  }
+  if (lower.endsWith(".md") || lower.endsWith(".mdx")) {
+    return summarizeMarkdown(redactedContent);
+  }
+  return summarizeTypeScriptSource(relativePath, redactedContent);
+}
+function isSourceSummary(summary) {
+  return Boolean(summary && typeof summary === "object" && "imports" in summary);
+}
+function bump(counts, key) {
+  counts[key] = (counts[key] ?? 0) + 1;
+}
+var RELATIVE_SPECIFIER = /^\.{1,2}\//;
+var IMPORT_CANDIDATE_SUFFIXES = [
+  "",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  "/index.ts",
+  "/index.tsx",
+  "/index.js",
+  "/index.mjs"
+];
+function resolveSpecifier(fromFile, specifier, knownFiles) {
+  if (!RELATIVE_SPECIFIER.test(specifier)) return null;
+  const baseDir = path9.posix.dirname(fromFile);
+  const joined = path9.posix.normalize(path9.posix.join(baseDir, specifier));
+  const candidate = joined.replace(/\.(?:js|mjs|cjs|jsx)$/, "");
+  for (const suffix of IMPORT_CANDIDATE_SUFFIXES) {
+    const withSuffix = `${joined}${suffix}`;
+    if (knownFiles.has(withSuffix)) return withSuffix;
+  }
+  const extensionSwap = new RegExp(`${candidate}\\.(?:ts|tsx|mts|cts|js|jsx|mjs|cjs)$`);
+  for (const file of knownFiles) {
+    if (extensionSwap.test(file)) return file;
+  }
+  return null;
+}
+function buildIndexes(files) {
+  const knownFiles = new Set(files.map((file) => file.relativePath));
+  const importerCounts = /* @__PURE__ */ new Map();
+  const byFile = files.filter((file) => isSourceSummary(file.summary)).map((file) => {
+    const summary = file.summary;
+    return {
+      path: file.relativePath,
+      imports: summary.imports,
+      exports: summary.exports
+    };
+  });
+  for (const entry of byFile) {
+    for (const specifier of entry.imports) {
+      const resolved = resolveSpecifier(entry.path, specifier, knownFiles);
+      if (resolved) importerCounts.set(resolved, (importerCounts.get(resolved) ?? 0) + 1);
+    }
+  }
+  const featureCounts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const match = /(?:^|\/)features\/([^/]+)\//.exec(file.relativePath);
+    if (match) featureCounts.set(match[1], (featureCounts.get(match[1]) ?? 0) + 1);
+  }
+  return {
+    routes: files.filter((file) => file.kind === "route").map((file) => ({
+      path: file.relativePath,
+      methods: isSourceSummary(file.summary) ? file.summary.routeHandlers : [],
+      part: file.part
+    })),
+    components: files.filter((file) => file.kind === "component").map((file) => ({
+      path: file.relativePath,
+      symbols: isSourceSummary(file.summary) ? file.summary.reactComponents : [],
+      part: file.part,
+      layer: file.layer
+    })),
+    handlers: files.filter((file) => file.kind === "handler").map((file) => ({
+      path: file.relativePath,
+      exports: isSourceSummary(file.summary) ? file.summary.exports : [],
+      part: file.part
+    })),
+    features: Array.from(featureCounts.entries()).map(([name, count]) => ({ name, files: count })).sort((a, b) => b.files - a.files || (a.name < b.name ? -1 : 1)),
+    imports: {
+      byFile,
+      centralFiles: Array.from(importerCounts.entries()).map(([filePath, importedByCount]) => ({ path: filePath, importedByCount })).sort((a, b) => b.importedByCount - a.importedByCount || (a.path < b.path ? -1 : 1)).slice(0, 50)
+    },
+    directives: files.filter((file) => isSourceSummary(file.summary) && file.summary.directives.length > 0).map((file) => ({
+      path: file.relativePath,
+      directives: file.summary.directives
+    }))
+  };
+}
+function verifyInMemory(files, parts, maxPartBytes) {
+  const errors = [];
+  const partNames = new Set(parts.map((part) => part.filename));
+  for (const file of files) {
+    if (!file.part || !partNames.has(file.part)) {
+      errors.push(`${file.relativePath} was not assigned to a snapshot part.`);
+    }
+  }
+  for (const part of parts) {
+    if (sha256Hex2(part.markdown) !== part.metadata.sha256) {
+      errors.push(`${part.filename} content does not match its recorded sha256.`);
+    }
+    const actualBytes = Buffer.byteLength(part.markdown, "utf8");
+    if (actualBytes !== part.metadata.byteSize) {
+      errors.push(`${part.filename} byteSize ${part.metadata.byteSize} != actual ${actualBytes}.`);
+    }
+    if (actualBytes > maxPartBytes) {
+      errors.push(`${part.filename} (${actualBytes} B) exceeds the part budget of ${maxPartBytes} B.`);
+    }
+    if (part.metadata.includedFiles.length !== part.metadata.fileCount) {
+      errors.push(`${part.filename} fileCount does not match its included files.`);
+    }
+  }
+  const filesInParts = parts.reduce((total, part) => total + part.metadata.fileCount, 0);
+  if (filesInParts !== files.length) {
+    errors.push(`Parts contain ${filesInParts} file(s) but ${files.length} were scanned.`);
+  }
+  return errors;
+}
+function resolveSafeOutputDirs(config) {
+  const cwd = path9.resolve(config.cwd);
+  const outDir = path9.resolve(cwd, config.outDir);
+  const tmpDir = path9.resolve(cwd, config.tmpDir);
+  const root = path9.parse(cwd).root;
+  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path9.sep}`);
+  const reject = (reason) => {
+    throw new Error(
+      `Refusing to generate: ${reason}. outDir=${outDir} tmpDir=${tmpDir} cwd=${cwd}`
+    );
+  };
+  if (outDir === root) reject("outDir resolves to the filesystem root");
+  if (outDir === cwd || contains(outDir, cwd)) {
+    reject("outDir is the working directory or one of its ancestors");
+  }
+  if (tmpDir === root) reject("tmpDir resolves to the filesystem root");
+  if (tmpDir === cwd || contains(tmpDir, cwd)) {
+    reject("tmpDir is the working directory or one of its ancestors");
+  }
+  if (tmpDir === outDir) reject("outDir and tmpDir are the same directory");
+  if (contains(outDir, tmpDir)) reject("tmpDir is inside outDir");
+  if (contains(tmpDir, outDir)) reject("outDir is inside tmpDir");
+  return { outDir, tmpDir };
+}
+function swapIntoPlace(tmpDir, outDir) {
+  const backupDir = `${outDir}.backup-${process.pid}-${Date.now()}`;
+  const hadPrevious = fs8.existsSync(outDir);
+  if (hadPrevious) fs8.renameSync(outDir, backupDir);
+  try {
+    try {
+      fs8.renameSync(tmpDir, outDir);
+    } catch (err) {
+      if (err.code === "EXDEV") {
+        fs8.cpSync(tmpDir, outDir, { recursive: true });
+        fs8.rmSync(tmpDir, { recursive: true, force: true });
+      } else {
+        throw err;
+      }
+    }
+    if (hadPrevious) fs8.rmSync(backupDir, { recursive: true, force: true });
+  } catch (err) {
+    if (hadPrevious && fs8.existsSync(backupDir)) {
+      if (fs8.existsSync(outDir)) fs8.rmSync(outDir, { recursive: true, force: true });
+      fs8.renameSync(backupDir, outDir);
+    }
+    throw err;
+  }
+}
+function artifactWarnings(artifacts) {
+  const messages = [];
+  if (!artifacts.manifest) {
+    messages.push("manifest.json is disabled: `validate` and `report` cannot inspect this snapshot.");
+  }
+  if (!artifacts.parts && artifacts.navigation) {
+    messages.push(
+      "parts are disabled but navigation.md is enabled: its links point at part files that were not written."
+    );
+  }
+  if (ARTIFACT_NAMES.every((name) => artifacts[name] === false)) {
+    messages.push("every artifact is disabled: the snapshot directory will be empty.");
+  }
+  return messages;
+}
+function runAfterGenerate(config, manifest) {
+  const hook = config.hooks.afterGenerate;
+  if (!hook) return;
+  try {
+    hook(manifest);
+  } catch (err) {
+    manifest.warnings.push(`hooks.afterGenerate failed: ${err.message}`);
+    manifest.totals.warningCount = manifest.warnings.length;
+  }
+}
+function partitionByBudget(files, config, fingerprint) {
+  const budgetFor = (file) => config.budgets.byLayer[file.layer] ?? config.budgets.default;
+  const buckets = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const budget = budgetFor(file);
+    const bucket = buckets.get(budget);
+    if (bucket) bucket.push(file);
+    else buckets.set(budget, [file]);
+  }
+  if (buckets.size <= 1) {
+    const only = buckets.size === 1 ? Array.from(buckets.keys())[0] : config.maxPartBytes;
+    return partitionFiles(files, only, fingerprint);
+  }
+  const parts = [];
+  for (const budget of Array.from(buckets.keys()).sort((a, b) => a - b)) {
+    parts.push(...partitionFiles(buckets.get(budget) ?? [], budget, fingerprint));
+  }
+  const merged = renumberParts(parts, fingerprint);
+  const byPath = new Map(files.map((file) => [file.relativePath, file]));
+  for (const part of merged) {
+    for (const included of part.metadata.includedFiles) {
+      const file = byPath.get(included.relativePath);
+      if (file) file.part = part.filename;
+    }
+  }
+  return merged;
+}
+function generateSnapshot(configInput, options) {
+  assertUsableConfigInput(configInput);
+  const config = isResolvedConfig(configInput) ? normalizeResolvedConfig(configInput) : resolveConfig(configInput ?? null);
+  const dryRun = options?.dryRun ?? false;
+  const gitInfo = getGitInfo(config.cwd, config.branch);
+  const collection = collectFiles(config.cwd, {
+    includePatterns: config.include,
+    excludePatterns: config.excludePatterns,
+    includeSensitiveFiles: config.includeSensitiveFiles
+  });
+  const files = [];
+  const skipped = [...collection.skipped];
+  const secretFindings = [];
+  const warnings = [];
+  const layerCounts = {};
+  const kindCounts = {};
+  let totalLines = 0;
+  let totalSizeBytes = 0;
+  let largeFileCount = 0;
+  for (const relativePath of collection.files) {
+    const absolutePath = path9.join(config.cwd, relativePath);
+    let stats;
+    try {
+      stats = fs8.statSync(absolutePath);
+      if (!stats.isFile()) {
+        skipped.push({ path: relativePath, reason: "not-file" });
+        continue;
+      }
+    } catch {
+      skipped.push({ path: relativePath, reason: "read-error" });
+      continue;
+    }
+    if (isBinaryFile(absolutePath)) {
+      skipped.push({ path: relativePath, reason: "binary", detail: `Size: ${stats.size} B` });
+      continue;
+    }
+    let buffer;
+    try {
+      buffer = fs8.readFileSync(absolutePath);
+    } catch {
+      skipped.push({ path: relativePath, reason: "read-error" });
+      continue;
+    }
+    const hashSha256 = sha256Hex2(buffer);
+    const rawContent = buffer.toString("utf8");
+    const lineCount = countLines(rawContent);
+    totalLines += lineCount;
+    totalSizeBytes += stats.size;
+    const layer = classifyLayer(relativePath, config.layers);
+    const kind = classifyKind(relativePath, config.kinds);
+    const language = detectLanguage(relativePath);
+    bump(layerCounts, layer);
+    bump(kindCounts, kind);
+    const { redacted, findings } = scanAndRedactSecrets(
+      rawContent,
+      config.secretRules,
+      relativePath
+    );
+    secretFindings.push(...findings);
+    const isLarge = stats.size > config.largeFileBytes;
+    if (isLarge) largeFileCount += 1;
+    let finalContent = redacted;
+    let isPreviewTruncated = false;
+    let includedLines = lineCount;
+    if (isLarge) {
+      const preview = truncatePreview(
+        redacted,
+        config.previewHeadLines,
+        config.previewTailLines
+      );
+      finalContent = preview.content;
+      isPreviewTruncated = preview.isTruncated;
+      includedLines = preview.includedLines;
+    }
+    let summary;
+    try {
+      summary = summarizeFile(relativePath, redacted);
+      if (isSourceSummary(summary) && summary.parseErrors) {
+        warnings.push(
+          `Parse errors in ${relativePath} (${summary.parseErrors}); its summary is incomplete.`
+        );
+      }
+    } catch (err) {
+      warnings.push(
+        `Summary skipped for ${relativePath}: ${err.message}`.replace(/\s+/g, " ")
+      );
+    }
+    files.push({
+      relativePath,
+      sizeBytes: stats.size,
+      lines: lineCount,
+      hashSha256,
+      part: "",
+      layer,
+      kind,
+      language,
+      inclusionMode: isPreviewTruncated ? "preview" : "full",
+      isLarge,
+      isPreviewTruncated,
+      originalLines: lineCount,
+      includedLines,
+      includedBytes: Buffer.byteLength(finalContent, "utf8"),
+      summary,
+      content: finalContent
+    });
+  }
+  const fingerprint = sha256Hex2(
+    files.map(
+      (file) => `${file.relativePath}:${file.hashSha256}:${file.sizeBytes}:${file.inclusionMode}`
+    ).join("\n")
+  );
+  const fullContents = /* @__PURE__ */ new Map();
+  for (const file of files) fullContents.set(file.relativePath, file.content ?? "");
+  const parts = partitionByBudget(files, config, fingerprint);
+  const maxEffectiveBudget = Math.max(
+    config.maxPartBytes,
+    config.budgets.default,
+    ...Object.values(config.budgets.byLayer)
+  );
+  const truncatedPreviewCount = files.filter((file) => file.isPreviewTruncated).length;
+  const validationErrors = verifyInMemory(files, parts, maxEffectiveBudget);
+  const totalContentBytes = files.reduce((total, file) => total + file.includedBytes, 0);
+  const manifest = {
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    generator: {
+      name: GENERATOR_NAME,
+      version: GENERATOR_VERSION
+    },
+    git: gitInfo,
+    budgets: {
+      maxPartBytes: config.maxPartBytes,
+      largeFileBytes: config.largeFileBytes
+    },
+    config: {
+      maxPartBytes: config.maxPartBytes,
+      largeFileBytes: config.largeFileBytes,
+      previewHeadLines: config.previewHeadLines,
+      previewTailLines: config.previewTailLines,
+      includeMonolith: config.includeMonolith,
+      includeSensitiveFiles: config.includeSensitiveFiles,
+      artifacts: { ...config.artifacts },
+      include: [...config.include],
+      layersMode: config.layersMode,
+      budgets: { default: config.budgets.default, byLayer: { ...config.budgets.byLayer } },
+      excludePatterns: [...config.excludePatterns],
+      layers: config.layers.map((layer) => layer.name),
+      kinds: config.kinds.map((kind) => kind.kind)
+    },
+    counts: {
+      totalFiles: files.length,
+      totalSizeBytes,
+      totalLines,
+      partsCount: parts.length,
+      skippedCount: skipped.length,
+      largeFileCount,
+      truncatedPreviewCount
+    },
+    totals: {
+      candidateFiles: files.length + skipped.length,
+      includedFiles: files.length,
+      fullFiles: files.filter((file) => !file.isPreviewTruncated).length,
+      previewFiles: files.filter((file) => file.isPreviewTruncated).length,
+      skippedFiles: skipped.length,
+      totalSourceBytes: totalSizeBytes,
+      totalContentBytes,
+      partCount: parts.length,
+      warningCount: 0
+    },
+    fingerprint,
+    validation: {
+      status: validationErrors.length === 0 ? "passed" : "failed",
+      errors: validationErrors
+    },
+    artifacts: {
+      fullJson: null,
+      fullMarkdown: null
+    },
+    layers: layerCounts,
+    kinds: kindCounts,
+    indexes: buildIndexes(files),
+    parts: parts.map((part) => part.metadata),
+    files: files.map((file) => {
+      const { content: _content, ...rest } = file;
+      return rest;
+    }),
+    skipped,
+    warnings
+  };
+  manifest.warnings = [
+    ...warnings,
+    ...secretFindings.map((finding) => `${finding.rule} at ${finding.path ?? "unknown"}:${finding.line}`)
+  ];
+  manifest.totals.warningCount = manifest.warnings.length;
+  let monolithJson = null;
+  let monolithMarkdown = null;
+  if (config.includeMonolith) {
+    const fullFiles = files.map((file) => ({
+      ...file,
+      content: fullContents.get(file.relativePath) ?? ""
+    }));
+    const json = generateMonolithJson(manifest, fullFiles);
+    const markdown = generateMonolithMarkdown(manifest, fullFiles);
+    const jsonBytes = Buffer.byteLength(json, "utf8");
+    const markdownBytes = Buffer.byteLength(markdown, "utf8");
+    if (!config.maxMonolithBytes || jsonBytes <= config.maxMonolithBytes) {
+      monolithJson = json;
+      manifest.artifacts.fullJson = { byteSize: jsonBytes, sha256: sha256Hex2(json) };
+    } else {
+      manifest.warnings.push(
+        `full-codebase.json skipped: ${jsonBytes} B exceeds maxMonolithBytes ${config.maxMonolithBytes} B`
+      );
+    }
+    if (!config.maxMonolithBytes || markdownBytes <= config.maxMonolithBytes) {
+      monolithMarkdown = markdown;
+      manifest.artifacts.fullMarkdown = {
+        byteSize: markdownBytes,
+        sha256: sha256Hex2(markdown)
+      };
+    } else {
+      manifest.warnings.push(
+        `full-codebase.md skipped: ${markdownBytes} B exceeds maxMonolithBytes ${config.maxMonolithBytes} B`
+      );
+    }
+    manifest.totals.warningCount = manifest.warnings.length;
+  }
+  for (const message of artifactWarnings(config.artifacts)) manifest.warnings.push(message);
+  manifest.totals.warningCount = manifest.warnings.length;
+  if (dryRun) {
+    runAfterGenerate(config, manifest);
+    return manifest;
+  }
+  const { outDir, tmpDir } = resolveSafeOutputDirs(config);
+  const { artifacts } = config;
+  fs8.rmSync(tmpDir, { recursive: true, force: true });
+  fs8.mkdirSync(tmpDir, { recursive: true });
+  const partsDir = path9.join(tmpDir, "parts");
+  const reportsDir = path9.join(tmpDir, "reports");
+  if (artifacts.parts) fs8.mkdirSync(partsDir, { recursive: true });
+  if (artifacts.navigation || artifacts.projectTree || artifacts.audit) {
+    fs8.mkdirSync(reportsDir, { recursive: true });
+  }
+  if (artifacts.parts) {
+    for (const part of parts) {
+      fs8.writeFileSync(path9.join(partsDir, part.filename), part.markdown, "utf8");
+    }
+  }
+  if (artifacts.projectTree) {
+    const projectTree = generateProjectTree(files.map((file) => file.relativePath));
+    fs8.writeFileSync(path9.join(reportsDir, "project-tree.md"), projectTree, "utf8");
+  }
+  if (artifacts.navigation) {
+    fs8.writeFileSync(path9.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
+  }
+  if (artifacts.audit) {
+    fs8.writeFileSync(
+      path9.join(reportsDir, "audit.md"),
+      generateAuditReport(manifest, secretFindings),
+      "utf8"
+    );
+  }
+  if (artifacts.readme) {
+    fs8.writeFileSync(path9.join(tmpDir, "README.md"), generateReadme(manifest), "utf8");
+  }
+  if (artifacts.manifest) {
+    fs8.writeFileSync(path9.join(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+  }
+  if (monolithJson !== null) {
+    fs8.writeFileSync(path9.join(tmpDir, "full-codebase.json"), monolithJson, "utf8");
+  }
+  if (monolithMarkdown !== null) {
+    fs8.writeFileSync(path9.join(tmpDir, "full-codebase.md"), monolithMarkdown, "utf8");
+  }
+  swapIntoPlace(tmpDir, outDir);
+  runAfterGenerate(config, manifest);
+  return manifest;
+}
+
+// src/cli.ts
+var VERSION = GENERATOR_VERSION;
+var COMMAND_ALIASES = /* @__PURE__ */ new Map([
+  ["generate", "generate"],
+  ["validate", "validate"],
+  ["check", "validate"],
+  ["report", "report"],
+  ["init", "init"],
+  ["explain", "explain"],
+  ["diff", "diff"]
+]);
+var COMMAND_ARITY = {
+  generate: 0,
+  validate: 0,
+  report: 0,
+  init: 0,
+  explain: 1,
+  diff: 2
+};
+var CLI_OPTIONS = {
+  cwd: { type: "string" },
+  "out-dir": { type: "string" },
+  "max-part-bytes": { type: "string" },
+  "large-file-bytes": { type: "string" },
+  "max-monolith-bytes": { type: "string" },
+  "include-monolith": { type: "boolean" },
+  "include-sensitive-files": { type: "boolean" },
+  "skip-artifacts": { type: "string" },
+  "only-artifacts": { type: "string" },
+  format: { type: "string" },
+  mode: { type: "string" },
+  "dry-run": { type: "boolean" },
+  watch: { type: "boolean" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" }
+};
+var UsageError = class extends Error {
+};
+var USAGE = `
+${GENERATOR_NAME} v${VERSION}
+Production-grade LLM codebase snapshot generator, auditor, and AST partitioner
+
+Usage:
+  codebase-snapshot [command] [options]
+  snap [command] [options]
+
+Commands:
+  generate (default)   Generate a complete partitioned codebase snapshot
+  validate, check      Validate snapshot integrity and check for drift
+  init                 Generate a starter snapshot.config file
+  report               Print codebase health, layer metrics, and secret audit
+  explain <path>       Show how one path would be treated: layer, kind, part, skips
+  diff <a> <b>         Compare two snapshots (directories or manifest.json files)
+
+Options:
+  --cwd <path>                  Target repository directory (default: current directory)
+  --out-dir <path>              Snapshot output directory (default: snapshot)
+  --include-monolith            Also generate full-codebase.json and full-codebase.md
+  --max-monolith-bytes <n>      Skip monolith artefacts larger than n bytes
+  --max-part-bytes <n>          Maximum byte budget per markdown part (default: 307200).
+                                Accepts units: 120k, 1.5mb
+  --large-file-bytes <n>        Threshold for head/tail truncation (default: 204800)
+  --include-sensitive-files     Emit .env / *.pem / .npmrc / credential files
+  --skip-artifacts <names>      Comma-separated artifacts to omit
+                                (readme, manifest, parts, navigation,
+                                 projectTree, audit, monolith)
+  --only-artifacts <names>      Write *only* these artifacts
+  --format <text|json>          CLI output format (default: text)
+  --dry-run                     Compute the snapshot without writing anything
+  --watch                       Re-generate whenever the repository changes
+  -h, --help                    Display this help message
+  -v, --version                 Display version
+
+All options also accept the --option=value form.
+Human-readable progress is written to stderr; payloads (--format json) go to stdout.
+`.trim();
+function parseByteOption(raw, optionName, minimum) {
+  if (raw === void 0) return void 0;
+  const value = parseByteSize(raw);
+  if (value === void 0 || !Number.isSafeInteger(value)) {
+    throw new UsageError(
+      `--${optionName} expects a byte count such as 120000 or "120k", received "${raw}".`
+    );
+  }
+  if (value < minimum) {
+    throw new UsageError(`--${optionName} must be at least ${minimum}, received "${raw}".`);
+  }
+  return value;
+}
+function parseArtifactList(raw, flag) {
+  const names = raw.split(",").map((name) => name.trim()).filter(Boolean);
+  if (names.length === 0) {
+    throw new UsageError(
+      `${flag} expects at least one artifact name (${ARTIFACT_NAMES.join(", ")}).`
+    );
+  }
+  const unknown = names.filter((name) => !ARTIFACT_NAMES.includes(name));
+  if (unknown.length > 0) {
+    throw new UsageError(
+      `Unknown artifact(s): ${unknown.join(", ")}. Expected one of: ${ARTIFACT_NAMES.join(", ")}.`
+    );
+  }
+  return names;
+}
+function parseCliArgs(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      options: CLI_OPTIONS,
+      allowPositionals: true,
+      strict: true
+    });
+  } catch (err) {
+    throw new UsageError(err.message);
+  }
+  const values = parsed.values;
+  if (values.help) {
+    process.stdout.write(`${USAGE}
+`);
+    throw new HelpRequested();
+  }
+  if (values.version) {
+    process.stdout.write(`v${VERSION}
+`);
+    throw new HelpRequested();
+  }
+  const positionals = parsed.positionals;
+  let command = "generate";
+  let args = [];
+  const explicitMode = values.mode ? String(values.mode) : void 0;
+  const firstPositional = positionals[0];
+  if (firstPositional !== void 0) {
+    const resolved = COMMAND_ALIASES.get(firstPositional);
+    if (!resolved) {
+      throw new UsageError(
+        `Unknown command "${firstPositional}". Expected one of: ${Array.from(COMMAND_ALIASES.keys()).join(", ")}.`
+      );
+    }
+    command = resolved;
+    args = positionals.slice(1);
+  } else if (explicitMode !== void 0) {
+    const resolved = COMMAND_ALIASES.get(explicitMode);
+    if (!resolved) {
+      throw new UsageError(
+        `Unknown --mode "${explicitMode}". Expected one of: ${Array.from(COMMAND_ALIASES.keys()).join(", ")}.`
+      );
+    }
+    command = resolved;
+  }
+  const expectedArgs = COMMAND_ARITY[command];
+  if (args.length !== expectedArgs) {
+    if (command === "explain") {
+      throw new UsageError("explain expects exactly one path.");
+    }
+    if (command === "diff") {
+      throw new UsageError(
+        "diff expects exactly two arguments: two snapshot directories or manifest.json files."
+      );
+    }
+    throw new UsageError(
+      `Unexpected argument(s): ${args.join(" ")}. ${command} takes no positional arguments.`
+    );
+  }
+  const rawFormat = values.format === void 0 ? "text" : String(values.format);
+  if (rawFormat !== "text" && rawFormat !== "json") {
+    throw new UsageError(`--format must be "text" or "json", received "${rawFormat}".`);
+  }
+  const rawSkip = values["skip-artifacts"];
+  const rawOnly = values["only-artifacts"];
+  if (rawSkip !== void 0 && rawOnly !== void 0) {
+    throw new UsageError("--skip-artifacts and --only-artifacts cannot be combined.");
+  }
+  let skipArtifacts;
+  if (rawOnly !== void 0) {
+    const keep = parseArtifactList(String(rawOnly), "--only-artifacts");
+    skipArtifacts = ARTIFACT_NAMES.filter(
+      (name) => !keep.includes(name)
+    );
+  } else if (rawSkip !== void 0) {
+    skipArtifacts = parseArtifactList(String(rawSkip), "--skip-artifacts");
+  }
+  return {
+    command,
+    args,
+    format: rawFormat,
+    dryRun: values["dry-run"] === true,
+    watch: values.watch === true,
+    cwd: values.cwd === void 0 ? process.cwd() : path10.resolve(String(values.cwd)),
+    outDir: values["out-dir"] === void 0 ? void 0 : String(values["out-dir"]),
+    includeMonolith: values["include-monolith"] === true ? true : void 0,
+    includeSensitiveFiles: values["include-sensitive-files"] === true ? true : void 0,
+    maxPartBytes: parseByteOption(
+      values["max-part-bytes"],
+      "max-part-bytes",
+      MIN_MAX_PART_BYTES
+    ),
+    largeFileBytes: parseByteOption(
+      values["large-file-bytes"],
+      "large-file-bytes",
+      1
+    ),
+    maxMonolithBytes: parseByteOption(
+      values["max-monolith-bytes"],
+      "max-monolith-bytes",
+      1
+    ),
+    skipArtifacts
+  };
+}
+var HelpRequested = class extends Error {
+};
+function info(message) {
+  process.stderr.write(`${message}
+`);
+}
+function warn(message) {
+  process.stderr.write(`${message}
+`);
+}
+function emit(format, payload, textRenderer) {
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return;
+  }
+  textRenderer();
+}
+function runInit(cwd) {
+  const targetName = supportsTypeScriptImports() ? "snapshot.config.ts" : "snapshot.config.mjs";
+  const targetPath = path10.join(cwd, targetName);
+  if (fs9.existsSync(targetPath)) {
+    warn(`\u274C ${targetName} already exists in ${cwd}.`);
+    return 1;
+  }
+  const importPath = JSON.stringify(GENERATOR_NAME);
+  const starter = `import { defineConfig } from ${importPath};
+
+export default defineConfig({
+  branch: "main",
+  outDir: "snapshot",
+  maxPartBytes: 300 * 1024,
+  largeFileBytes: 200 * 1024,
+  excludePatterns: [],
+});
+`;
+  fs9.writeFileSync(targetPath, starter, "utf8");
+  info(`\u2705 Created ${targetName} in ${cwd}`);
+  if (targetName.endsWith(".mjs")) {
+    info(
+      "   (a .ts config needs Node >= 22.6 to import natively; this Node writes a .mjs instead)"
+    );
+  }
+  return 0;
+}
+function renderValidateText(result) {
+  if (result.valid) {
+    info("\u2705 Snapshot is valid and up to date with disk.");
+  } else {
+    warn("\u274C Snapshot validation failed:");
+    for (const error of result.errors) warn(`  - ${error}`);
+    for (const drift of result.drift.hashMismatches.slice(0, 20)) {
+      warn(`  - modified: ${drift.path}`);
+    }
+    for (const issue of result.drift.partIssues.slice(0, 20)) {
+      warn(`  - part: ${issue.part} (${issue.issue})`);
+    }
+    for (const mismatch of result.drift.configMismatches.slice(0, 20)) {
+      warn(`  - config: ${mismatch}`);
+    }
+    for (const missing of result.drift.missingInSnapshot.slice(0, 20)) {
+      warn(`  - new file: ${missing}`);
+    }
+    for (const missing of result.drift.missingOnDisk.slice(0, 20)) {
+      warn(`  - deleted: ${missing}`);
+    }
+  }
+  for (const warning of result.warnings) warn(`  \u26A0 ${warning}`);
+}
+async function main(argv = process.argv.slice(2)) {
+  let invocation;
+  try {
+    invocation = parseCliArgs(argv);
+  } catch (err) {
+    if (err instanceof HelpRequested) return 0;
+    if (err instanceof UsageError) {
+      process.stderr.write(`\u274C ${err.message}
+
+${USAGE}
+`);
+      return 2;
+    }
+    throw err;
+  }
+  if (invocation.command === "init") {
+    return runInit(invocation.cwd);
+  }
+  const loaded = await loadConfigFileDetailed(invocation.cwd);
+  for (const warning of loaded.warnings) warn(`\u26A0 Config: ${warning}`);
+  if (loaded.file) info(`\u2699  Using config ${path10.relative(process.cwd(), loaded.file) || loaded.file}`);
+  const resolved = resolveConfig(
+    loaded.config,
+    {
+      mode: invocation.command,
+      format: invocation.format,
+      dryRun: invocation.dryRun,
+      cwd: invocation.cwd,
+      outDir: invocation.outDir,
+      includeMonolith: invocation.includeMonolith,
+      includeSensitiveFiles: invocation.includeSensitiveFiles,
+      maxPartBytes: invocation.maxPartBytes,
+      largeFileBytes: invocation.largeFileBytes,
+      maxMonolithBytes: invocation.maxMonolithBytes,
+      skipArtifacts: invocation.skipArtifacts
+    },
+    invocation.cwd
+  );
+  if (invocation.command === "validate") {
+    const result = validateSnapshot(resolved);
+    emit(invocation.format, result, () => renderValidateText(result));
+    return result.valid ? 0 : 1;
+  }
+  if (invocation.command === "report") {
+    const manifestPath = path10.join(resolved.cwd, resolved.outDir, "manifest.json");
+    if (!fs9.existsSync(manifestPath)) {
+      warn(`\u274C Manifest not found at ${manifestPath}. Run generate first.`);
+      return 1;
+    }
+    let manifest;
+    try {
+      manifest = JSON.parse(fs9.readFileSync(manifestPath, "utf8"));
+    } catch (err) {
+      warn(`\u274C Could not read ${manifestPath}: ${err.message}`);
+      return 1;
+    }
+    const validation = validateSnapshot(resolved);
+    emit(invocation.format, { manifest, validation }, () => {
+      info(`
+\u{1F4CA} Codebase Snapshot Report (${resolved.cwd})`);
+      info(`   - Generated at:   ${manifest.generatedAt}`);
+      info(`   - Schema:         ${manifest.schemaVersion}`);
+      info(`   - Fingerprint:    ${manifest.fingerprint}`);
+      info(`   - Files included: ${manifest.counts.totalFiles}`);
+      info(`   - Total lines:    ${manifest.counts.totalLines.toLocaleString()}`);
+      info(
+        `   - Total size:     ${(manifest.counts.totalSizeBytes / (1024 * 1024)).toFixed(2)} MB`
+      );
+      info(`   - Total parts:    ${manifest.counts.partsCount}`);
+      info(`   - Integrity:      ${validation.valid ? "\u2705 Clean (no drift)" : "\u274C Drift detected"}`);
+      info(`   - Warnings:       ${manifest.warnings?.length ?? 0}`);
+      info("\n   Layers:");
+      for (const [layer, count] of Object.entries(manifest.layers)) {
+        info(`     - ${layer.padEnd(16)}: ${count} files`);
+      }
+    });
+    return validation.valid ? 0 : 1;
+  }
+  if (invocation.command === "explain") {
+    const result = explainPath(resolved, invocation.args[0]);
+    emit(invocation.format, result, () => info(renderExplainText(result)));
+    return result.included ? 0 : 1;
+  }
+  if (invocation.command === "diff") {
+    try {
+      const [beforePath, afterPath] = invocation.args;
+      const diff = compareManifests(loadManifest(beforePath), loadManifest(afterPath));
+      emit(invocation.format, diff, () => info(renderDiffText(diff)));
+      return 0;
+    } catch (err) {
+      warn(`\u274C ${err.message}`);
+      return 1;
+    }
+  }
+  const started = performance.now();
+  info(`\u{1F4F8} ${invocation.dryRun ? "Planning snapshot (dry run)" : "Generating snapshot"} for: ${resolved.cwd}`);
+  info(
+    `   Branch: ${resolved.branch} | Part budget: ${(resolved.maxPartBytes / 1024).toFixed(0)} KB`
+  );
+  try {
+    const manifest = generateSnapshot(resolved, { dryRun: invocation.dryRun });
+    const elapsed = ((performance.now() - started) / 1e3).toFixed(2);
+    if (invocation.dryRun) {
+      info("\n\u{1F9EA} Dry run \u2014 nothing was written:");
+      info(`   - Would track:  ${manifest.counts.totalFiles} files`);
+      info(`   - Would write:  ${manifest.counts.partsCount} part(s) under ${resolved.outDir}/parts/`);
+      info(`   - Skipped:      ${manifest.counts.skippedCount} file(s)`);
+      info(`   - Warnings:     ${manifest.warnings.length}`);
+      info(`   - Integrity:    ${manifest.validation.status}`);
+      for (const error of manifest.validation.errors.slice(0, 10)) info(`     - ${error}`);
+    } else {
+      info(`
+\u2705 Snapshot generated in ${elapsed}s:`);
+      info(`   - Tracked files: ${manifest.counts.totalFiles}`);
+      info(`   - Total lines:   ${manifest.counts.totalLines.toLocaleString()}`);
+      info(
+        `   - Total size:    ${(manifest.counts.totalSizeBytes / (1024 * 1024)).toFixed(2)} MB`
+      );
+      info(`   - Parts written: ${manifest.counts.partsCount} under ${resolved.outDir}/parts/`);
+      info(`   - Reports:       ${resolved.outDir}/reports/ (project-tree, navigation, audit)`);
+      info(`   - Manifest:      ${resolved.outDir}/manifest.json`);
+      info(`   - Fingerprint:   ${manifest.fingerprint}`);
+      info(`   - Integrity:     ${manifest.validation.status}`);
+      if (manifest.warnings.length > 0) {
+        info(`   - Warnings:      ${manifest.warnings.length}`);
+        for (const warning of manifest.warnings.slice(0, 10)) info(`     - ${warning}`);
+      }
+    }
+    if (invocation.format === "json") {
+      process.stdout.write(`${JSON.stringify(manifest, null, 2)}
+`);
+    }
+    if (invocation.watch) {
+      return await runWatchLoop(invocation, resolved);
+    }
+    return manifest.validation.status === "passed" ? 0 : 1;
+  } catch (err) {
+    warn(`\u274C Failed to generate snapshot: ${err.message}`);
+    return 1;
+  }
+}
+async function runWatchLoop(invocation, resolved) {
+  const outDir = path10.resolve(resolved.cwd, resolved.outDir);
+  const tmpDir = path10.resolve(resolved.cwd, resolved.tmpDir);
+  const outName = path10.basename(outDir).toLowerCase();
+  const tmpName = path10.basename(tmpDir).toLowerCase();
+  const isGenerated = (candidate) => candidate.toLowerCase().split(/[\\/]/).some(
+    (segment) => segment === outName || segment === tmpName || segment.startsWith(`${outName}.backup-`)
+  );
+  let running = false;
+  const regenerate = () => {
+    if (running) return;
+    running = true;
+    const started = performance.now();
+    try {
+      const manifest = generateSnapshot(resolved, { dryRun: invocation.dryRun });
+      const elapsed = ((performance.now() - started) / 1e3).toFixed(2);
+      info(
+        `\u267B\uFE0F  ${(/* @__PURE__ */ new Date()).toISOString()}  ${manifest.counts.totalFiles} file(s), ${manifest.counts.partsCount} part(s), ${manifest.validation.status} (${elapsed}s)`
+      );
+    } catch (err) {
+      warn(`\u274C ${err.message}`);
+    } finally {
+      running = false;
+    }
+  };
+  info("\u{1F440} Watching for changes. Press Ctrl+C to stop.");
+  regenerate();
+  let timer = null;
+  const watcher = fs9.watch(resolved.cwd, { recursive: true }, (_event, filename) => {
+    if (filename) {
+      const changed = path10.resolve(resolved.cwd, filename.toString());
+      if (isGenerated(changed)) return;
+    }
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(regenerate, 250);
+  });
+  await new Promise((resolve5) => {
+    const stop = () => {
+      if (timer) clearTimeout(timer);
+      watcher.close();
+      resolve5();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  return 0;
+}
+
+// src/bin.ts
+main().then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    process.stderr.write(`\u274C ${err.message}
+`);
+    process.exitCode = 1;
+  }
+);
+//# sourceMappingURL=bin.js.map