@ankurhalder/codebase-snapshot 2.0.0 → 2.1.1

package/dist/index.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
 var crypto = require('crypto');
-var fs8 = require('fs');
-var path9 = require('path');
+var fs9 = require('fs');
+var path10 = require('path');
 var ts = require('typescript');
 var url = require('url');
 var childProcess = require('child_process');
+var readline = require('readline');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -28,135 +29,498 @@ function _interopNamespace(e) {
 }
 
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
-var fs8__namespace = /*#__PURE__*/_interopNamespace(fs8);
-var path9__namespace = /*#__PURE__*/_interopNamespace(path9);
+var fs9__namespace = /*#__PURE__*/_interopNamespace(fs9);
+var path10__namespace = /*#__PURE__*/_interopNamespace(path10);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
 var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
+var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 // src/index.ts
 
-// src/ast/structured.ts
-function stripJsonComments(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;
+// src/ast/profiles/shared.ts
+var MAX_SUMMARY_CHARS = 1e6;
+function emptySummary() {
+  return {
+    directives: [],
+    imports: [],
+    exports: [],
+    reExports: [],
+    functions: [],
+    classes: [],
+    interfaces: [],
+    types: [],
+    enums: [],
+    variables: [],
+    reactComponents: [],
+    hooks: [],
+    routeHandlers: []
+  };
+}
+function dedupeSorted(values) {
+  return Array.from(new Set(values.filter(Boolean))).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function finalizeSummary(summary) {
+  return {
+    directives: dedupeSorted(summary.directives),
+    imports: dedupeSorted(summary.imports),
+    exports: dedupeSorted(summary.exports),
+    reExports: dedupeSorted(summary.reExports),
+    functions: dedupeSorted(summary.functions),
+    classes: dedupeSorted(summary.classes),
+    interfaces: dedupeSorted(summary.interfaces),
+    types: dedupeSorted(summary.types),
+    enums: dedupeSorted(summary.enums),
+    variables: dedupeSorted(summary.variables),
+    reactComponents: dedupeSorted(summary.reactComponents),
+    hooks: dedupeSorted(summary.hooks),
+    routeHandlers: dedupeSorted(summary.routeHandlers)
+  };
+}
+function eachLine(content, visit) {
+  const text2 = content.length > MAX_SUMMARY_CHARS ? content.slice(0, MAX_SUMMARY_CHARS) : content;
+  for (const line of text2.split(/\r?\n/)) visit(line);
+}
+function isTopLevel(line) {
+  return !/^[\s]/.test(line);
+}
+function isPublicName(name) {
+  return name.length > 0 && !name.startsWith("_") && /^[A-Za-z]/.test(name);
+}
+function isCapitalizedName(name) {
+  return /^[A-Z]/.test(name);
+}
+
+// src/ast/profiles/cfamily.ts
+var INCLUDE = /^#\s*include\s*[<"]([^>"]+)[>"]/;
+var DEFINE = /^#\s*define\s+([A-Za-z_]\w*)/;
+var USING = /^using\s+(?:namespace\s+)?([\w:]+)\s*;/;
+var TYPE_DECL = /^(?:typedef\s+)?(?:struct|union|class|enum)\s+([A-Za-z_]\w*)/;
+var TYPEDEF = /^typedef\b[^;{}]*?\b([A-Za-z_]\w*)\s*;/;
+var FUNCTION = /^[A-Za-z_][\w \t*&:<>,]*?\b([A-Za-z_]\w*)\s*\([^;]*\)\s*\{?\s*$/;
+var NOT_A_FUNCTION = /^(?:if|for|while|switch|return|else|do|case|sizeof|catch|throw)\b/;
+var cfamilyProfile = {
+  id: "cfamily",
+  extensions: [".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hxx", ".m", ".mm"],
+  summarize(_path, content) {
+    const summary = emptySummary();
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) {
+        return;
       }
-      continue;
-    }
-    if (inBlockComment) {
-      if (char === "*" && next === "/") {
-        inBlockComment = false;
-        i += 1;
+      const included = INCLUDE.exec(trimmed);
+      if (included) {
+        summary.imports.push(included[1]);
+        return;
       }
-      continue;
-    }
-    if (inString) {
-      out += char;
-      if (char === "\\") {
-        if (next !== void 0) {
-          out += next;
-          i += 1;
+      const used = USING.exec(trimmed);
+      if (used) {
+        summary.imports.push(used[1]);
+        return;
+      }
+      const macro = DEFINE.exec(trimmed);
+      if (macro) {
+        summary.variables.push(macro[1]);
+        return;
+      }
+      if (!isTopLevel(line)) return;
+      const declared = TYPE_DECL.exec(line);
+      if (declared) {
+        const kind = /^typedef\s+enum/.test(line) || /^enum\b/.test(trimmed) ? "enum" : "type";
+        if (kind === "enum") summary.enums.push(declared[1]);
+        else summary.classes.push(declared[1]);
+        summary.exports.push(declared[1]);
+        return;
+      }
+      const aliased = TYPEDEF.exec(line);
+      if (aliased) {
+        summary.types.push(aliased[1]);
+        summary.exports.push(aliased[1]);
+        return;
+      }
+      if (NOT_A_FUNCTION.test(trimmed)) return;
+      const fn = FUNCTION.exec(line);
+      if (fn) {
+        summary.functions.push(fn[1]);
+        summary.exports.push(fn[1]);
+      }
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
+  }
+};
+
+// src/ast/profiles/dotnet.ts
+var USING2 = /^using\s+([\w.]+)\s*;/;
+var TYPE_DECL2 = /^\s*(?:public\s+|internal\s+|private\s+|protected\s+|sealed\s+|abstract\s+|static\s+|partial\s+|readonly\s+)*(class|interface|struct|record|enum)\s+([A-Za-z_]\w*)/;
+var METHOD = /^\s*(?:public|private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:virtual\s+|override\s+|sealed\s+)?[\w<>[\],?]+\s+([A-Za-z_]\w*)\s*[<(]/;
+var dotnetProfile = {
+  id: "dotnet",
+  extensions: [".cs"],
+  summarize(_path, content) {
+    const summary = emptySummary();
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) {
+        return;
+      }
+      const used = USING2.exec(trimmed);
+      if (used) {
+        summary.imports.push(used[1]);
+        return;
+      }
+      const declaration = TYPE_DECL2.exec(line);
+      if (declaration) {
+        const kind = declaration[1];
+        const name = declaration[2];
+        if (kind === "interface") summary.interfaces.push(name);
+        else if (kind === "enum") summary.enums.push(name);
+        else summary.classes.push(name);
+        if (/^\s*public\b/.test(line)) summary.exports.push(name);
+        return;
+      }
+      const method = METHOD.exec(line);
+      if (method) {
+        summary.functions.push(method[1]);
+        if (/^\s*public\b/.test(line)) summary.exports.push(method[1]);
+      }
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
+  }
+};
+
+// src/ast/profiles/go.ts
+var FUNC = /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/;
+var TYPE = /^type\s+([A-Za-z_]\w*)\s+(.*)$/;
+var VAR_CONST = /^(?:var|const)\s+([A-Za-z_]\w*)/;
+var IMPORT_SINGLE = /^import\s+(?:[\w.]+\s+)?"([^"]+)"/;
+var IMPORT_OPEN = /^import\s*\(/;
+var IMPORT_ENTRY = /^\s*(?:[\w.]+\s+)?"([^"]+)"/;
+var goProfile = {
+  id: "go",
+  extensions: [".go"],
+  summarize(_path, content) {
+    const summary = emptySummary();
+    let inImportBlock = false;
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//")) return;
+      if (inImportBlock) {
+        if (trimmed.startsWith(")")) {
+          inImportBlock = false;
+          return;
         }
-      } else if (char === '"') {
-        inString = false;
+        const entry = IMPORT_ENTRY.exec(line);
+        if (entry) summary.imports.push(entry[1]);
+        return;
       }
-      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;
+      if (IMPORT_OPEN.test(trimmed)) {
+        inImportBlock = true;
+        return;
+      }
+      const single = IMPORT_SINGLE.exec(trimmed);
+      if (single) {
+        summary.imports.push(single[1]);
+        return;
+      }
+      if (!isTopLevel(line)) return;
+      const method = FUNC.exec(line);
+      if (method) {
+        const name = method[1];
+        summary.functions.push(name);
+        if (isCapitalizedName(name)) summary.exports.push(name);
+        return;
+      }
+      const declared = TYPE.exec(line);
+      if (declared) {
+        const name = declared[1];
+        const body = declared[2].trim();
+        if (body.startsWith("struct")) summary.classes.push(name);
+        else if (body.startsWith("interface")) summary.interfaces.push(name);
+        else summary.types.push(name);
+        if (isCapitalizedName(name)) summary.exports.push(name);
+        return;
+      }
+      const value = VAR_CONST.exec(line);
+      if (value) {
+        summary.variables.push(value[1]);
+        if (isCapitalizedName(value[1])) summary.exports.push(value[1]);
+      }
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
   }
-  return out;
-}
-function summarizeJson(content) {
-  try {
-    const parsed = JSON.parse(stripJsonComments(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: []
-    };
+};
+
+// src/ast/profiles/jvm.ts
+var IMPORT = /^import\s+(?:static\s+)?([\w.]+?)(?:\.\*)?;?\s*$/;
+var TYPE_DECL3 = /^\s*(?:public\s+|private\s+|protected\s+|internal\s+)?(?:final\s+|abstract\s+|open\s+|sealed\s+|data\s+|static\s+|partial\s+)*(class|interface|enum|record|object|trait)\s+(?:class\s+)?([A-Za-z_]\w*)/;
+var KOTLIN_FUN = /^\s*(?:public\s+|private\s+|protected\s+|internal\s+|override\s+|suspend\s+|inline\s+|open\s+|operator\s+)*fun\s+(?:<[^>]*>\s*)?(?:[\w.]+\.)?([A-Za-z_]\w*)/;
+var SCALA_DEF = /^\s*def\s+([A-Za-z_]\w*)/;
+var JAVA_METHOD = /^\s+(?:public|private|protected)\s+(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:abstract\s+)?[\w<>[\],.?]+\s+([A-Za-z_]\w*)\s*\(/;
+var jvmProfile = {
+  id: "jvm",
+  extensions: [".java", ".kt", ".kts", ".scala"],
+  summarize(path11, content) {
+    const summary = emptySummary();
+    const lower = path11.toLowerCase();
+    const isJava = lower.endsWith(".java");
+    const isKotlin = lower.endsWith(".kt") || lower.endsWith(".kts");
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) {
+        return;
+      }
+      const imported = IMPORT.exec(trimmed);
+      if (imported) {
+        summary.imports.push(imported[1]);
+        return;
+      }
+      const declaration = TYPE_DECL3.exec(line);
+      if (declaration) {
+        const kind = declaration[1];
+        const name = declaration[2];
+        if (kind === "interface" || kind === "trait") summary.interfaces.push(name);
+        else if (kind === "enum") summary.enums.push(name);
+        else summary.classes.push(name);
+        const hidden = /^\s*(?:private|protected|internal)\b/.test(line);
+        if (isJava ? /^\s*public\b/.test(line) : !hidden) summary.exports.push(name);
+        return;
+      }
+      const kotlinFunction = KOTLIN_FUN.exec(line);
+      if (kotlinFunction && isKotlin) {
+        summary.functions.push(kotlinFunction[1]);
+        const hidden = /^\s*(?:private|protected|internal)\b/.test(line);
+        if (!hidden) summary.exports.push(kotlinFunction[1]);
+        return;
+      }
+      const scalaFunction = SCALA_DEF.exec(line);
+      if (scalaFunction && !isJava && !isKotlin) {
+        summary.functions.push(scalaFunction[1]);
+        const hidden = /^\s*(?:private|protected)\b/.test(line);
+        if (!hidden) summary.exports.push(scalaFunction[1]);
+        return;
+      }
+      if (isJava) {
+        const method = JAVA_METHOD.exec(line);
+        if (method) {
+          summary.functions.push(method[1]);
+          if (/^\s*public\b/.test(line)) summary.exports.push(method[1]);
+        }
+      }
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
   }
-}
-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;
+};
+
+// src/ast/profiles/php.ts
+var USE = /^use\s+([\w\\]+)\s*(?:as\s+\w+)?;/;
+var DECLARE = /^(?:abstract\s+|final\s+|readonly\s+)*(class|interface|trait|enum)\s+([A-Za-z_]\w*)/;
+var FUNCTION2 = /^(?:public\s+|protected\s+|private\s+|static\s+|final\s+|abstract\s+)*function\s+([A-Za-z_]\w*)/;
+var phpProfile = {
+  id: "php",
+  extensions: [".php"],
+  summarize(_path, content) {
+    const summary = emptySummary();
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("/*")) {
+        return;
       }
-      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()}`);
-    }
+      const used = USE.exec(trimmed);
+      if (used) {
+        summary.imports.push(used[1].replace(/\\\\/g, "\\"));
+        return;
+      }
+      const declaration = DECLARE.exec(trimmed);
+      if (declaration) {
+        const kind = declaration[1];
+        const name = declaration[2];
+        if (kind === "interface" || kind === "trait") summary.interfaces.push(name);
+        else if (kind === "enum") summary.enums.push(name);
+        else summary.classes.push(name);
+        summary.exports.push(name);
+        return;
+      }
+      const fn = FUNCTION2.exec(trimmed);
+      if (fn) {
+        summary.functions.push(fn[1]);
+        if (!/^private\b/.test(trimmed)) summary.exports.push(fn[1]);
+      }
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
   }
-  return {
-    headings: headings.slice(0, 40),
-    frontmatterKeys: Array.from(new Set(frontmatterKeys)).sort()
-  };
-}
+};
+
+// src/ast/profiles/python.ts
+var IMPORT2 = /^import\s+(.+)$/;
+var FROM_IMPORT = /^from\s+([\w.]+)\s+import\s+(.+)$/;
+var CLASS = /^class\s+([A-Za-z_]\w*)/;
+var DEF = /^(?:async\s+)?def\s+([A-Za-z_]\w*)/;
+var CONSTANT = /^([A-Z_][A-Z0-9_]*)\s*(?::[^=]+)?=/;
+var ALL_DUNDER = /^__all__\s*=\s*\[([^\]]*)\]/;
+var ROUTE_DECORATOR = /^\s*@[\w.]*\b(?:get|post|put|patch|delete|head|options|route)\s*\(/i;
+var pythonProfile = {
+  id: "python",
+  extensions: [".py", ".pyi"],
+  summarize(_path, content) {
+    const summary = emptySummary();
+    let routePending = false;
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) return;
+      if (ROUTE_DECORATOR.test(line)) {
+        routePending = true;
+        return;
+      }
+      const from = FROM_IMPORT.exec(trimmed);
+      if (from) {
+        summary.imports.push(from[1]);
+        routePending = false;
+        return;
+      }
+      const imported = IMPORT2.exec(trimmed);
+      if (imported) {
+        for (const part of imported[1].split(",")) {
+          const name = part.trim().split(/\s+as\s+/)[0].trim();
+          if (name) summary.imports.push(name);
+        }
+        routePending = false;
+        return;
+      }
+      if (isTopLevel(line)) {
+        const klass = CLASS.exec(line);
+        if (klass) {
+          summary.classes.push(klass[1]);
+          if (isPublicName(klass[1])) summary.exports.push(klass[1]);
+          routePending = false;
+          return;
+        }
+        const definition = DEF.exec(line);
+        if (definition) {
+          const name = definition[1];
+          summary.functions.push(name);
+          if (routePending) {
+            summary.routeHandlers.push(name);
+            routePending = false;
+          }
+          if (isPublicName(name)) summary.exports.push(name);
+          return;
+        }
+        const all = ALL_DUNDER.exec(trimmed);
+        if (all) {
+          for (const entry of all[1].split(",")) {
+            const name = entry.trim().replace(/['"]/g, "").trim();
+            if (name) summary.exports.push(name);
+          }
+          return;
+        }
+        const constant = CONSTANT.exec(line);
+        if (constant) summary.variables.push(constant[1]);
+      }
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
+  }
+};
+
+// src/ast/profiles/ruby.ts
+var REQUIRE = /^require(?:_relative)?\s+["']([^"']+)["']/;
+var CLASS_OR_MODULE = /^(?:class|module)\s+([A-Z][\w:]*)/;
+var METHOD2 = /^def\s+(?:self\.)?([A-Za-z_]\w*[?!=]?)/;
+var rubyProfile = {
+  id: "ruby",
+  extensions: [".rb", ".rake", ".gemspec"],
+  summarize(_path, content) {
+    const summary = emptySummary();
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) return;
+      const required = REQUIRE.exec(trimmed);
+      if (required) {
+        summary.imports.push(required[1]);
+        return;
+      }
+      if (!isTopLevel(line)) return;
+      const declaration = CLASS_OR_MODULE.exec(line);
+      if (declaration) {
+        summary.classes.push(declaration[1]);
+        summary.exports.push(declaration[1]);
+        return;
+      }
+      const method = METHOD2.exec(line);
+      if (method) {
+        summary.functions.push(method[1]);
+        summary.exports.push(method[1]);
+      }
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
+  }
+};
+
+// src/ast/profiles/rust.ts
+var USE2 = /^use\s+([^;]+);/;
+var FN = /^(pub(?:\([^)]*\))?\s+)?(?:const\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+([A-Za-z_]\w*)/;
+var STRUCT = /^(pub(?:\([^)]*\))?\s+)?struct\s+([A-Za-z_]\w*)/;
+var TRAIT = /^(pub(?:\([^)]*\))?\s+)?(?:unsafe\s+)?trait\s+([A-Za-z_]\w*)/;
+var ENUM = /^(pub(?:\([^)]*\))?\s+)?enum\s+([A-Za-z_]\w*)/;
+var TYPE2 = /^(pub(?:\([^)]*\))?\s+)?type\s+([A-Za-z_]\w*)/;
+var MOD = /^(pub(?:\([^)]*\))?\s+)?mod\s+([A-Za-z_]\w*)/;
+var IMPL = /^impl(?:<[^>]*>)?\s+(?:[\w:<>]+\s+for\s+)?([A-Za-z_]\w*)/;
+var rustProfile = {
+  id: "rust",
+  extensions: [".rs"],
+  summarize(_path, content) {
+    const summary = emptySummary();
+    eachLine(content, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//")) return;
+      const used = USE2.exec(trimmed);
+      if (used) {
+        summary.imports.push(used[1].trim());
+        return;
+      }
+      if (!isTopLevel(line)) return;
+      const isPublic = /^pub\b/.test(trimmed);
+      const fn = FN.exec(line);
+      if (fn) {
+        summary.functions.push(fn[2]);
+        if (isPublic) summary.exports.push(fn[2]);
+        return;
+      }
+      const struct = STRUCT.exec(line);
+      if (struct) {
+        summary.classes.push(struct[2]);
+        if (isPublic) summary.exports.push(struct[2]);
+        return;
+      }
+      const trait = TRAIT.exec(line);
+      if (trait) {
+        summary.interfaces.push(trait[2]);
+        if (isPublic) summary.exports.push(trait[2]);
+        return;
+      }
+      const enumeration = ENUM.exec(line);
+      if (enumeration) {
+        summary.enums.push(enumeration[2]);
+        if (isPublic) summary.exports.push(enumeration[2]);
+        return;
+      }
+      const alias = TYPE2.exec(line);
+      if (alias) {
+        summary.types.push(alias[2]);
+        if (isPublic) summary.exports.push(alias[2]);
+        return;
+      }
+      const module = MOD.exec(line);
+      if (module) {
+        summary.variables.push(module[2]);
+        if (isPublic) summary.exports.push(module[2]);
+        return;
+      }
+      const implementation = IMPL.exec(line);
+      if (implementation) summary.classes.push(implementation[1]);
+    });
+    return { summary: finalizeSummary(summary), quality: "heuristic" };
+  }
+};
 var ROUTE_HANDLER_NAMES = /* @__PURE__ */ new Set([
   "GET",
   "POST",
@@ -196,9 +560,9 @@ function summarizeTypeScriptSource(relativePath, content) {
   if (parseErrors > 0) summary.parseErrors = parseErrors;
   for (const statement of sourceFile.statements) {
     if (ts__default.default.isExpressionStatement(statement) && ts__default.default.isStringLiteral(statement.expression)) {
-      const text = statement.expression.text;
-      if (text === "use client" || text === "use server") {
-        summary.directives.push(text);
+      const text2 = statement.expression.text;
+      if (text2 === "use client" || text2 === "use server") {
+        summary.directives.push(text2);
       }
       continue;
     }
@@ -298,23 +662,344 @@ function summarizeTypeScriptSource(relativePath, content) {
       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);
+  const dedupeSorted2 = (values) => Array.from(new Set(values)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  summary.directives = dedupeSorted2(summary.directives);
+  summary.imports = dedupeSorted2(summary.imports);
+  summary.exports = dedupeSorted2(summary.exports);
+  summary.reExports = dedupeSorted2(summary.reExports);
+  summary.functions = dedupeSorted2(summary.functions);
+  summary.classes = dedupeSorted2(summary.classes);
+  summary.interfaces = dedupeSorted2(summary.interfaces);
+  summary.types = dedupeSorted2(summary.types);
+  summary.enums = dedupeSorted2(summary.enums);
+  summary.variables = dedupeSorted2(summary.variables);
+  summary.reactComponents = dedupeSorted2(summary.reactComponents);
+  summary.hooks = dedupeSorted2(summary.hooks);
+  summary.routeHandlers = dedupeSorted2(summary.routeHandlers);
   return summary;
 }
 
+// src/ast/profiles/sfc.ts
+var SCRIPT_BLOCK = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+var ASTRO_FRONTMATTER = /^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?=\r?\n|$)/;
+function componentName(path11) {
+  const base = path11.split("/").pop() ?? path11;
+  return base.replace(/\.[^.]+$/, "");
+}
+var sfcProfile = {
+  id: "sfc",
+  extensions: [".vue", ".svelte", ".astro"],
+  summarize(path11, content) {
+    let script = "";
+    if (path11.toLowerCase().endsWith(".astro")) {
+      const frontmatter = ASTRO_FRONTMATTER.exec(content);
+      if (frontmatter) script += `${frontmatter[1]}
+`;
+    }
+    for (const match of content.matchAll(SCRIPT_BLOCK)) {
+      script += `${match[1]}
+`;
+    }
+    const name = componentName(path11);
+    if (!script.trim()) {
+      const summary2 = emptySummary();
+      if (name) {
+        summary2.exports.push(name);
+        summary2.reactComponents.push(name);
+      }
+      return { summary: finalizeSummary(summary2), quality: "heuristic" };
+    }
+    const summary = summarizeTypeScriptSource(`${name}.ts`, script);
+    summary.reactComponents.push(name);
+    summary.exports.push(name);
+    return { summary, quality: "ast" };
+  }
+};
+
+// src/ast/profiles/index.ts
+var LANGUAGE_PROFILES = [
+  pythonProfile,
+  goProfile,
+  rustProfile,
+  jvmProfile,
+  dotnetProfile,
+  phpProfile,
+  rubyProfile,
+  cfamilyProfile,
+  sfcProfile
+];
+var BY_EXTENSION = /* @__PURE__ */ new Map();
+for (const profile of LANGUAGE_PROFILES) {
+  for (const extension of profile.extensions) {
+    BY_EXTENSION.set(extension.toLowerCase(), profile);
+  }
+}
+function profileForPath(path11) {
+  const lower = path11.toLowerCase();
+  const dot = lower.lastIndexOf(".");
+  if (dot === -1) return null;
+  return BY_EXTENSION.get(lower.slice(dot)) ?? null;
+}
+function summarizeWithProfile(path11, content) {
+  const profile = profileForPath(path11);
+  return profile ? profile.summarize(path11, content) : null;
+}
+
+// src/ast/structured.ts
+function stripJsonComments(content) {
+  const text2 = content.replace(/^\uFEFF/, "");
+  let out = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < text2.length; i++) {
+    const char = text2[i];
+    const next = text2[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(stripJsonComments(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()
+  };
+}
+var MANIFEST_FILES = [
+  "package.json",
+  "pyproject.toml",
+  "requirements.txt",
+  "setup.py",
+  "go.mod",
+  "Cargo.toml",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "composer.json",
+  "Gemfile"
+];
+var MANIFEST_MAX_BYTES = 1e5;
+function readManifest(cwd, name) {
+  const full = path10__namespace.join(cwd, name);
+  try {
+    const stats = fs9__namespace.statSync(full);
+    if (!stats.isFile() || stats.size > MANIFEST_MAX_BYTES) return null;
+    return fs9__namespace.readFileSync(full, "utf8");
+  } catch {
+    return null;
+  }
+}
+function collectDependencies(manifests) {
+  const names = /* @__PURE__ */ new Set();
+  const raw = manifests["package.json"];
+  if (!raw) return names;
+  try {
+    const parsed = JSON.parse(raw);
+    for (const section of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const block = parsed[section];
+      if (block && typeof block === "object") {
+        for (const name of Object.keys(block)) names.add(name);
+      }
+    }
+  } catch {
+  }
+  return names;
+}
+function buildPresetContext(cwd) {
+  const files = /* @__PURE__ */ new Set();
+  const dirs = /* @__PURE__ */ new Set();
+  try {
+    for (const entry of fs9__namespace.readdirSync(cwd, { withFileTypes: true })) {
+      if (entry.isDirectory()) dirs.add(entry.name);
+      else if (entry.isFile()) files.add(entry.name);
+    }
+  } catch {
+  }
+  const manifests = {};
+  for (const name of MANIFEST_FILES) {
+    const content = readManifest(cwd, name);
+    if (content !== null) manifests[name] = content;
+  }
+  return {
+    cwd,
+    files,
+    dirs,
+    dependencies: collectDependencies(manifests),
+    manifests
+  };
+}
+function hasFile(context, name) {
+  return context.files.has(name);
+}
+function hasFileStartingWith(context, prefix) {
+  for (const file of context.files) {
+    if (file.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function manifestContains(context, manifest, needle) {
+  const content = context.manifests[manifest];
+  if (!content) return false;
+  return content.toLowerCase().includes(needle.toLowerCase());
+}
+function hasDependency(context, ...names) {
+  return names.some((name) => context.dependencies.has(name));
+}
+
+// src/presets/helpers.ts
+function layer(name, ...prefixes) {
+  return {
+    name,
+    match: (filePath) => prefixes.some((prefix) => filePath.startsWith(prefix))
+  };
+}
+function kindOf(name, ...needles) {
+  return {
+    kind: name,
+    match: (filePath) => needles.some((needle) => filePath.includes(needle))
+  };
+}
+function suffixKind(name, ...suffixes) {
+  return {
+    kind: name,
+    match: (filePath) => suffixes.some((suffix) => filePath.endsWith(suffix))
+  };
+}
+function commonLayers() {
+  return [
+    layer("scripts", "scripts/", "tools/"),
+    layer("docs", "docs/", "documentation/"),
+    {
+      name: "config",
+      match: (filePath) => filePath.startsWith(".github/") || filePath.startsWith(".husky/") || filePath.startsWith(".vscode/") || filePath.startsWith(".") || filePath.includes("config")
+    },
+    { name: "root", match: (filePath) => !filePath.includes("/") }
+  ];
+}
+function commonKinds() {
+  return [
+    {
+      kind: "test",
+      match: (filePath) => {
+        const lower = filePath.toLowerCase();
+        return lower.includes(".test.") || lower.includes(".spec.") || lower.startsWith("test/") || lower.startsWith("tests/") || lower.includes("_test.") || lower.endsWith("_test.go") || lower.includes("__tests__");
+      }
+    },
+    suffixKind("doc", ".md", ".mdx", ".rst", ".txt"),
+    suffixKind("data", ".json", ".yaml", ".yml", ".csv", ".toml"),
+    {
+      kind: "script",
+      match: (filePath) => filePath.startsWith("scripts/") || /\.(sh|ps1|bat)$/i.test(filePath)
+    },
+    {
+      kind: "config",
+      match: (filePath) => filePath.startsWith(".") || filePath.includes("config") || filePath === "package.json" || filePath === "tsconfig.json"
+    }
+  ];
+}
+
 // src/presets/nextjs.ts
 var NEXTJS_LAYERS = [
   { name: "app", match: (p) => p.startsWith("src/app/") || p.startsWith("app/") },
@@ -370,6 +1055,47 @@ var NEXTJS_KINDS = [
   }
 ];
 
+// 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/vite.ts
 var VITE_LAYERS = [
   { name: "pages", match: (p) => p.startsWith("src/pages/") || p.startsWith("src/views/") },
@@ -417,44 +1143,419 @@ var VITE_KINDS = [
   }
 ];
 
-// 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/") },
+// src/presets/js-presets.ts
+var NEXT_LIKE_EXCLUDES = [".svelte-kit", ".astro", ".vite", ".output"];
+var JS_PRESETS = [
+  {
+    name: "nextjs",
+    priority: 100,
+    detect: (context) => hasFileStartingWith(context, "next.config") || hasDependency(context, "next"),
+    layers: NEXTJS_LAYERS,
+    kinds: NEXTJS_KINDS,
+    exclude: NEXT_LIKE_EXCLUDES,
+    recommendedBudget: "300k"
+  },
+  {
+    name: "nuxt",
+    priority: 98,
+    detect: (context) => hasFileStartingWith(context, "nuxt.config") || hasDependency(context, "nuxt", "nuxt3"),
+    layers: [
+      layer("pages", "pages/", "src/pages/"),
+      layer("components", "components/", "src/components/"),
+      layer("composables", "composables/", "src/composables/"),
+      layer("server", "server/", "src/server/", "api/"),
+      layer("stores", "stores/", "src/stores/"),
+      layer("layouts", "layouts/", "src/layouts/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("api-route", "server/api/", "server/routes/"),
+      suffixKind("component", ".vue"),
+      kindOf("composable", "composables/"),
+      kindOf("store", "stores/", "store/"),
+      kindOf("layout", "layouts/"),
+      ...commonKinds()
+    ],
+    exclude: [".nuxt", ".output"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "sveltekit",
+    priority: 96,
+    detect: (context) => hasFileStartingWith(context, "svelte.config") || hasDependency(context, "@sveltejs/kit", "svelte"),
+    layers: [
+      layer("routes", "src/routes/", "routes/"),
+      layer("lib", "src/lib/", "lib/"),
+      layer("components", "src/lib/components/", "src/components/"),
+      layer("stores", "src/lib/stores/", "src/stores/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("route", "+page.", "+server.", "+layout."),
+      suffixKind("component", ".svelte"),
+      kindOf("store", "stores/"),
+      kindOf("params", "params/"),
+      ...commonKinds()
+    ],
+    exclude: [".svelte-kit", ".vercel"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "remix",
+    priority: 94,
+    detect: (context) => hasDependency(context, "@remix-run/react", "@remix-run/node", "@remix-run/dev"),
+    layers: [
+      layer("routes", "app/routes/", "routes/"),
+      layer("components", "app/components/"),
+      layer("lib", "app/lib/", "app/utils/"),
+      ...commonLayers()
+    ],
+    kinds: [kindOf("route", "routes/"), ...commonKinds()],
+    exclude: [".cache", "public/build"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "astro",
+    priority: 92,
+    detect: (context) => hasFileStartingWith(context, "astro.config") || hasDependency(context, "astro"),
+    layers: [
+      layer("pages", "src/pages/"),
+      layer("layouts", "src/layouts/"),
+      layer("components", "src/components/"),
+      layer("content", "src/content/"),
+      ...commonLayers()
+    ],
+    kinds: [suffixKind("page", ".astro"), kindOf("layout", "layouts/"), ...commonKinds()],
+    exclude: [".astro", "dist"],
+    recommendedBudget: "150k"
+  },
+  {
+    name: "angular",
+    priority: 90,
+    detect: (context) => hasFile(context, "angular.json") || hasDependency(context, "@angular/core"),
+    layers: [
+      layer("app", "src/app/"),
+      layer("features", "src/app/features/"),
+      layer("shared", "src/app/shared/"),
+      layer("core", "src/app/core/"),
+      layer("assets", "src/assets/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      suffixKind("component", ".component.ts"),
+      suffixKind("service", ".service.ts"),
+      suffixKind("module", ".module.ts"),
+      suffixKind("guard", ".guard.ts"),
+      suffixKind("pipe", ".pipe.ts"),
+      suffixKind("directive", ".directive.ts"),
+      ...commonKinds()
+    ],
+    exclude: [".angular", "dist"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "solid",
+    priority: 88,
+    detect: (context) => hasDependency(context, "solid-js", "solid-start"),
+    layers: [
+      layer("pages", "src/routes/", "src/pages/"),
+      layer("components", "src/components/"),
+      ...commonLayers()
+    ],
+    kinds: [kindOf("route", "routes/"), ...commonKinds()],
+    exclude: [".solid", "dist"],
+    recommendedBudget: "120k"
+  },
+  {
+    name: "vue-vite",
+    priority: 86,
+    detect: (context) => hasDependency(context, "vue") && (hasDependency(context, "vite") || hasFileStartingWith(context, "vite.config")),
+    layers: [
+      layer("pages", "src/pages/", "src/views/"),
+      layer("components", "src/components/"),
+      layer("composables", "src/composables/", "src/hooks/"),
+      layer("stores", "src/stores/", "src/store/"),
+      layer("services", "src/services/", "src/api/"),
+      layer("shared", "src/shared/", "src/common/"),
+      layer("styles", "src/styles/", "src/assets/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      suffixKind("component", ".vue"),
+      kindOf("composable", "composables/", "use"),
+      kindOf("store", "stores/", "store/"),
+      kindOf("service", "services/", "api/"),
+      suffixKind("style", ".css", ".scss", ".sass", ".less"),
+      ...commonKinds()
+    ],
+    exclude: [".vite", "dist"],
+    recommendedBudget: "120k"
+  },
   {
-    name: "config",
-    match: (p) => p.startsWith(".github/") || p.startsWith(".husky/") || p.startsWith(".") || p.includes("config")
+    name: "react-vite",
+    priority: 84,
+    detect: (context) => hasDependency(context, "react") && (hasDependency(context, "vite") || hasFileStartingWith(context, "vite.config")),
+    layers: VITE_LAYERS,
+    kinds: VITE_KINDS,
+    exclude: [".vite", "dist"],
+    recommendedBudget: "120k"
   },
-  { name: "root", match: (p) => !p.includes("/") }
+  {
+    name: "nest",
+    priority: 80,
+    detect: (context) => hasDependency(context, "@nestjs/core"),
+    layers: [
+      layer("modules", "src/modules/", "modules/"),
+      layer("controllers", "src/controllers/", "controllers/"),
+      layer("providers", "src/providers/", "providers/"),
+      layer("core", "src/core/"),
+      layer("security", "src/security/", "src/auth/"),
+      layer("db", "src/db/", "src/database/", "prisma/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      suffixKind("controller", ".controller.ts"),
+      suffixKind("service", ".service.ts"),
+      suffixKind("module", ".module.ts"),
+      suffixKind("guard", ".guard.ts"),
+      suffixKind("dto", ".dto.ts"),
+      suffixKind("entity", ".entity.ts"),
+      kindOf("migration", "migrations/"),
+      ...commonKinds()
+    ],
+    exclude: ["dist", "node_modules"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "node-express",
+    priority: 78,
+    detect: (context) => hasDependency(context, "express", "fastify", "koa", "@hapi/hapi"),
+    layers: NODE_LAYERS,
+    kinds: NODE_KINDS,
+    exclude: ["dist"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "node-lib",
+    // A bare package.json is often just tooling around a non-JS project, so it
+    // ranks below every definitive language manifest.
+    priority: 45,
+    detect: (context) => hasFile(context, "package.json"),
+    layers: [
+      layer("src", "src/"),
+      layer("lib", "lib/"),
+      layer("test", "test/", "tests/", "__tests__/"),
+      ...commonLayers()
+    ],
+    kinds: [suffixKind("type", ".d.ts"), ...commonKinds()],
+    exclude: ["dist"],
+    recommendedBudget: "120k"
+  }
 ];
-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") },
+
+// src/presets/lang-presets.ts
+var anyFileEndingWith = (context, suffix) => Array.from(context.files).some((file) => file.endsWith(suffix));
+var DIR = (name) => `${name}/`;
+var LANGUAGE_PRESETS = [
   {
-    kind: "config",
-    match: (p) => {
-      const base = p.split("/").pop() || "";
-      return ["package.json", "tsconfig.json", "Dockerfile"].includes(base) || base.startsWith(".");
-    }
+    name: "python-django",
+    priority: 56,
+    detect: (context) => hasFile(context, "manage.py") || manifestContains(context, "pyproject.toml", "django") || manifestContains(context, "requirements.txt", "django"),
+    layers: [
+      layer("views", DIR("views"), DIR("app/views"), DIR("apps/views")),
+      layer("models", DIR("models"), DIR("app/models"), DIR("apps/models")),
+      layer("serializers", DIR("serializers")),
+      layer("urls", "urls.py"),
+      layer("migrations", DIR("migrations")),
+      layer("settings", "settings.py", "settings/"),
+      layer("templates", DIR("templates")),
+      ...commonLayers()
+    ],
+    kinds: [
+      suffixKind("model", "models.py"),
+      suffixKind("view", "views.py"),
+      suffixKind("serializer", "serializers.py"),
+      suffixKind("urlconf", "urls.py"),
+      kindOf("migration", "migrations/"),
+      suffixKind("settings", "settings.py"),
+      ...commonKinds()
+    ],
+    exclude: ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache", ".tox", ".eggs", "staticfiles", "media"],
+    recommendedBudget: "150k"
+  },
+  {
+    name: "python-fastapi",
+    priority: 54,
+    detect: (context) => manifestContains(context, "requirements.txt", "fastapi") || manifestContains(context, "requirements.txt", "flask") || manifestContains(context, "pyproject.toml", "fastapi") || manifestContains(context, "pyproject.toml", "flask"),
+    layers: [
+      layer("routers", DIR("routers"), DIR("routes"), DIR("api")),
+      layer("models", DIR("models"), DIR("db")),
+      layer("schemas", DIR("schemas")),
+      layer("services", DIR("services")),
+      layer("core", DIR("core")),
+      layer("tests", DIR("tests")),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("router", "routers/", "routes/", "api/"),
+      kindOf("model", "models/"),
+      kindOf("schema", "schemas/"),
+      kindOf("service", "services/"),
+      ...commonKinds()
+    ],
+    exclude: ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache", ".tox", ".eggs"],
+    recommendedBudget: "150k"
+  },
+  {
+    name: "python-lib",
+    // Below node-lib: a Node repo with a stray .py file is still a Node repo.
+    priority: 30,
+    detect: (context) => hasFile(context, "pyproject.toml") || hasFile(context, "setup.py") || hasFile(context, "requirements.txt") || anyFileEndingWith(context, ".py"),
+    layers: [
+      layer("package", DIR("src"), DIR("lib")),
+      layer("tests", DIR("tests"), DIR("test")),
+      ...commonLayers()
+    ],
+    kinds: [suffixKind("module", ".py"), ...commonKinds()],
+    exclude: ["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache", ".tox", ".eggs"],
+    recommendedBudget: "120k"
+  },
+  {
+    name: "go",
+    priority: 50,
+    detect: (context) => hasFile(context, "go.mod"),
+    layers: [
+      layer("cmd", "cmd/"),
+      layer("internal", "internal/"),
+      layer("pkg", "pkg/"),
+      layer("api", "api/", "proto/"),
+      layer("migrations", "migrations/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("main", "cmd/"),
+      kindOf("handler", "handler", "server", "http"),
+      kindOf("service", "service"),
+      kindOf("repository", "repository", "store", "repo"),
+      kindOf("model", "model", "entity"),
+      suffixKind("test", "_test.go"),
+      ...commonKinds()
+    ],
+    exclude: ["vendor", "testdata"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "rust",
+    priority: 48,
+    detect: (context) => hasFile(context, "Cargo.toml"),
+    layers: [
+      layer("src", "src/"),
+      layer("crates", "crates/"),
+      layer("bins", "src/bin/"),
+      layer("tests", "tests/"),
+      layer("benches", "benches/"),
+      ...commonLayers()
+    ],
+    kinds: [suffixKind("module", ".rs"), suffixKind("test", "_test.rs"), ...commonKinds()],
+    exclude: ["target"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "java-spring",
+    priority: 46,
+    detect: (context) => hasFile(context, "pom.xml") || hasFile(context, "build.gradle") || hasFile(context, "build.gradle.kts"),
+    layers: [
+      layer("api", "src/main/java/"),
+      layer("test", "src/test/java/"),
+      layer("resources", "src/main/resources/"),
+      layer("migrations", "src/main/resources/db/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("controller", "controller"),
+      kindOf("service", "service"),
+      kindOf("repository", "repository", "dao"),
+      kindOf("entity", "entity", "model"),
+      kindOf("dto", "dto", "request", "response"),
+      kindOf("migration", "migration", "db/migration"),
+      ...commonKinds()
+    ],
+    exclude: [".gradle", "out", "target"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "dotnet",
+    priority: 44,
+    detect: (context) => anyFileEndingWith(context, ".csproj") || anyFileEndingWith(context, ".sln") || hasFile(context, "global.json"),
+    layers: [
+      layer("web", "src/", "Web/"),
+      layer("domain", "Domain/", "Core/"),
+      layer("infrastructure", "Infrastructure/", "Data/"),
+      layer("tests", "Tests/", "test/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("controller", "Controller"),
+      kindOf("service", "Service"),
+      kindOf("repository", "Repository"),
+      kindOf("model", "Model", "Entity"),
+      kindOf("dto", "Dto", "Request", "Response"),
+      suffixKind("test", "Tests.cs"),
+      ...commonKinds()
+    ],
+    exclude: ["bin", "obj", ".vs"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "php-laravel",
+    priority: 42,
+    detect: (context) => hasFile(context, "artisan") || manifestContains(context, "composer.json", "laravel") || hasFile(context, "composer.json"),
+    layers: [
+      layer("app", "app/"),
+      layer("routes", "routes/"),
+      layer("http", "app/Http/"),
+      layer("models", "app/Models/"),
+      layer("providers", "app/Providers/"),
+      layer("database", "database/"),
+      layer("tests", "tests/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("controller", "Http/Controllers/"),
+      kindOf("model", "Models/"),
+      kindOf("migration", "migrations/"),
+      kindOf("middleware", "Middleware/"),
+      kindOf("request", "Requests/"),
+      kindOf("provider", "Providers/"),
+      ...commonKinds()
+    ],
+    exclude: ["vendor", "storage", "bootstrap/cache", "public/build"],
+    recommendedBudget: "150k"
+  },
+  {
+    name: "ruby-rails",
+    priority: 40,
+    detect: (context) => hasFile(context, "Gemfile") || hasFile(context, "config.ru") || hasFile(context, "Rakefile"),
+    layers: [
+      layer("app", "app/"),
+      layer("controllers", "app/controllers/"),
+      layer("models", "app/models/"),
+      layer("config", "config/"),
+      layer("db", "db/"),
+      layer("spec", "spec/", "test/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      kindOf("controller", "controllers/"),
+      kindOf("model", "models/"),
+      kindOf("migration", "migrate/"),
+      kindOf("job", "jobs/"),
+      kindOf("mailer", "mailers/"),
+      suffixKind("test", "_spec.rb", "_test.rb"),
+      ...commonKinds()
+    ],
+    exclude: [".bundle", "log", "tmp", "vendor/bundle", "public/assets"],
+    recommendedBudget: "150k"
   }
 ];
 
@@ -500,57 +1601,118 @@ var DEFAULT_KINDS = [
   }
 ];
 
-// src/presets/index.ts
-function detectPreset(cwd) {
-  const hasNextConfig = fs8__namespace.existsSync(path9__namespace.join(cwd, "next.config.ts")) || fs8__namespace.existsSync(path9__namespace.join(cwd, "next.config.js")) || fs8__namespace.existsSync(path9__namespace.join(cwd, "next.config.mjs"));
-  const hasViteConfig = fs8__namespace.existsSync(path9__namespace.join(cwd, "vite.config.ts")) || fs8__namespace.existsSync(path9__namespace.join(cwd, "vite.config.js")) || fs8__namespace.existsSync(path9__namespace.join(cwd, "vite.config.mjs"));
-  const pkgJsonPath = path9__namespace.join(cwd, "package.json");
-  let pkgDependencies = {};
-  if (fs8__namespace.existsSync(pkgJsonPath)) {
-    try {
-      const parsed = JSON.parse(fs8__namespace.readFileSync(pkgJsonPath, "utf8"));
-      pkgDependencies = {
-        ...parsed.dependencies || {},
-        ...parsed.devDependencies || {}
-      };
-    } catch {
-      pkgDependencies = {};
-    }
-  }
-  if (hasNextConfig || pkgDependencies["next"]) {
-    return {
-      presetName: "nextjs",
-      layers: NEXTJS_LAYERS,
-      kinds: NEXTJS_KINDS
-    };
+// src/presets/shape-presets.ts
+var SHAPE_PRESETS = [
+  {
+    name: "monorepo",
+    priority: 70,
+    detect: (context) => hasFile(context, "pnpm-workspace.yaml") || hasFile(context, "nx.json") || hasFile(context, "turbo.json") || hasFile(context, "lerna.json") || manifestContains(context, "package.json", '"workspaces"'),
+    layers: [
+      layer("apps", "apps/"),
+      layer("packages", "packages/"),
+      layer("tooling", "tooling/", "tools/", "scripts/"),
+      ...commonLayers()
+    ],
+    kinds: commonKinds(),
+    exclude: [".turbo", ".nx"],
+    recommendedBudget: "200k"
+  },
+  {
+    name: "infra",
+    priority: 24,
+    detect: (context) => Array.from(context.files).some((file) => file.endsWith(".tf")) || hasFile(context, "Chart.yaml") || hasFile(context, "kustomization.yaml") || hasFile(context, "docker-compose.yml") || hasFile(context, "docker-compose.yaml"),
+    layers: [
+      layer("modules", "modules/"),
+      layer("environments", "env/", "environments/"),
+      layer("manifests", "k8s/", "helm/", "charts/", "deploy/"),
+      ...commonLayers()
+    ],
+    kinds: [
+      { kind: "terraform", match: (filePath) => filePath.endsWith(".tf") },
+      { kind: "kubernetes", match: (filePath) => /\.(ya?ml)$/i.test(filePath) && /k8s|helm|charts|deploy/.test(filePath) },
+      ...commonKinds()
+    ],
+    exclude: [".terraform", ".terragrunt-cache"],
+    recommendedBudget: "100k"
+  },
+  {
+    name: "docs",
+    priority: 22,
+    detect: (context) => {
+      const markdown = Array.from(context.files).filter((file) => /\.mdx?$/i.test(file)).length;
+      return markdown >= 3 && !hasFile(context, "package.json");
+    },
+    layers: [
+      layer("content", "content/", "docs/"),
+      layer("assets", "assets/", "static/", "public/"),
+      ...commonLayers()
+    ],
+    kinds: commonKinds(),
+    exclude: [".docusaurus", ".vitepress/dist", "site"],
+    recommendedBudget: "100k"
+  },
+  {
+    name: "generic",
+    priority: 0,
+    detect: () => true,
+    layers: DEFAULT_LAYERS,
+    kinds: DEFAULT_KINDS,
+    exclude: [],
+    recommendedBudget: "120k"
   }
-  if (hasViteConfig || pkgDependencies["vite"]) {
-    return {
-      presetName: "vite",
-      layers: VITE_LAYERS,
-      kinds: VITE_KINDS
-    };
+];
+
+// src/presets/registry.ts
+function compare(a, b) {
+  if (b.priority !== a.priority) return b.priority - a.priority;
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+var PRESETS = [
+  ...JS_PRESETS,
+  ...LANGUAGE_PRESETS,
+  ...SHAPE_PRESETS
+].sort(compare);
+var BY_NAME = new Map(PRESETS.map((preset) => [preset.name, preset]));
+function listPresetNames() {
+  return PRESETS.map((preset) => preset.name);
+}
+function getPreset(name) {
+  return BY_NAME.get(name);
+}
+function unknownPresetMessage(name) {
+  return `Unknown preset "${name}". Expected one of: ${listPresetNames().join(", ")}.`;
+}
+function detectPresetFromContext(context, forced) {
+  if (forced !== void 0) {
+    const preset = BY_NAME.get(forced);
+    if (!preset) throw new Error(unknownPresetMessage(forced));
+    return toDetected(preset);
   }
-  if (pkgDependencies["express"] || pkgDependencies["fastify"] || pkgDependencies["@nestjs/core"] || fs8__namespace.existsSync(path9__namespace.join(cwd, "src/core")) || fs8__namespace.existsSync(path9__namespace.join(cwd, "src/protocols"))) {
-    return {
-      presetName: "node",
-      layers: NODE_LAYERS,
-      kinds: NODE_KINDS
-    };
+  for (const preset of PRESETS) {
+    if (preset.detect(context)) return toDetected(preset);
   }
+  return toDetected(PRESETS[PRESETS.length - 1]);
+}
+function toDetected(preset) {
   return {
-    presetName: "default",
-    layers: DEFAULT_LAYERS,
-    kinds: DEFAULT_KINDS
+    presetName: preset.name,
+    layers: preset.layers,
+    kinds: preset.kinds,
+    exclude: preset.exclude ? [...preset.exclude] : [],
+    recommendedBudget: preset.recommendedBudget ?? null
   };
 }
+function detectPreset(cwd, forced) {
+  return detectPresetFromContext(buildPresetContext(cwd), forced);
+}
 function getGitInfo(cwd, fallbackBranch = "main") {
   try {
-    const branch = childProcess__namespace.execSync("git rev-parse --abbrev-ref HEAD", {
+    const reported = childProcess__namespace.execSync("git rev-parse --abbrev-ref HEAD", {
       cwd,
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf8"
-    }).trim() || fallbackBranch;
+    }).trim();
+    const branch = !reported || reported === "HEAD" ? fallbackBranch : reported;
     const commit = childProcess__namespace.execSync("git rev-parse HEAD", {
       cwd,
       stdio: ["ignore", "pipe", "ignore"],
@@ -678,10 +1840,10 @@ function matchesExclude(relativePath, pattern) {
   return posixPath === cleaned || posixPath.startsWith(`${cleaned}/`) || posixPath.includes(`/${cleaned}/`) || posixPath.endsWith(`/${cleaned}`);
 }
 function readGitignoreMatcher(dir) {
-  const gitignorePath = path9__namespace.join(dir, ".gitignore");
+  const gitignorePath = path10__namespace.join(dir, ".gitignore");
   let raw;
   try {
-    raw = fs8__namespace.readFileSync(gitignorePath, "utf8");
+    raw = fs9__namespace.readFileSync(gitignorePath, "utf8");
   } catch {
     return () => false;
   }
@@ -784,7 +1946,7 @@ function walkDirectory(dir, baseDir, visited) {
   const results = { files: [], skipped: [] };
   let realDir;
   try {
-    realDir = fs8__namespace.realpathSync(dir);
+    realDir = fs9__namespace.realpathSync(dir);
   } catch {
     realDir = dir;
   }
@@ -793,21 +1955,21 @@ function walkDirectory(dir, baseDir, visited) {
   const ignoredByGitignore = dir === baseDir ? readGitignoreMatcher(baseDir) : () => false;
   let entries;
   try {
-    entries = fs8__namespace.readdirSync(dir, { withFileTypes: true });
+    entries = fs9__namespace.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 = path9__namespace.join(dir, entry.name);
-    const relPath = path9__namespace.relative(baseDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path10__namespace.join(dir, entry.name);
+    const relPath = path10__namespace.relative(baseDir, fullPath).replace(/\\/g, "/");
     if (ignoredByGitignore(relPath)) continue;
     let isDirectory = entry.isDirectory();
     let isFile = entry.isFile();
     if (entry.isSymbolicLink()) {
       try {
-        const stats = fs8__namespace.statSync(fullPath);
+        const stats = fs9__namespace.statSync(fullPath);
         isDirectory = stats.isDirectory();
         isFile = stats.isFile();
         if (!isDirectory && !isFile) {
@@ -1072,6 +2234,8 @@ function normalizeResolvedConfig(config) {
       config.includeMonolith === true
     ),
     include: resolveInclude(config.include),
+    preset: typeof config.preset === "string" ? config.preset : "generic",
+    presetExclude: Array.isArray(config.presetExclude) ? config.presetExclude : [],
     layersMode: config.layersMode === "replace" ? "replace" : "merge",
     budgets: config.budgets && typeof config.budgets === "object" ? config.budgets : { default: config.maxPartBytes, byLayer: {} },
     hooks: resolveHooks(config.hooks),
@@ -1119,18 +2283,22 @@ function parseJsonish(raw, file) {
 }
 async function loadConfigFileDetailed(cwd) {
   const warnings = [];
+  const errors = [];
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path9__namespace.join(cwd, filename);
-    if (!fs8__namespace.existsSync(fullPath)) continue;
+    const fullPath = path10__namespace.join(cwd, filename);
+    if (!fs9__namespace.existsSync(fullPath)) continue;
     if (filename.endsWith(".json") || filename === ".snapshotrc") {
       try {
         return {
-          config: parseJsonish(fs8__namespace.readFileSync(fullPath, "utf8"), fullPath),
+          config: parseJsonish(fs9__namespace.readFileSync(fullPath, "utf8"), fullPath),
           file: fullPath,
-          warnings
+          warnings,
+          errors
         };
       } catch (err) {
-        warnings.push(err.message);
+        const message = err.message;
+        warnings.push(message);
+        errors.push(message);
         continue;
       }
     }
@@ -1144,28 +2312,37 @@ async function loadConfigFileDetailed(cwd) {
       const imported = await import(url.pathToFileURL(fullPath).href);
       const config = imported.default ?? imported;
       if (!config || typeof config !== "object") {
-        warnings.push(`${fullPath} does not export a configuration object.`);
+        const message = `${fullPath} does not export a configuration object.`;
+        warnings.push(message);
+        errors.push(message);
         continue;
       }
-      return { config, file: fullPath, warnings };
+      return { config, file: fullPath, warnings, errors };
     } catch (err) {
-      warnings.push(`Could not load ${fullPath}: ${err.message}`);
+      const message = `Could not load ${fullPath}: ${err.message}`;
+      warnings.push(message);
+      errors.push(message);
       continue;
     }
   }
-  const pkgJsonPath = path9__namespace.join(cwd, "package.json");
-  if (fs8__namespace.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path10__namespace.join(cwd, "package.json");
+  if (fs9__namespace.existsSync(pkgJsonPath)) {
     try {
-      const parsed = parseJsonish(fs8__namespace.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
+      const parsed = parseJsonish(fs9__namespace.readFileSync(pkgJsonPath, "utf8"), pkgJsonPath);
       const snapshotKey = parsed.snapshot;
       if (snapshotKey && typeof snapshotKey === "object") {
-        return { config: snapshotKey, file: pkgJsonPath, warnings };
+        return { config: snapshotKey, file: pkgJsonPath, warnings, errors };
+      }
+      if (snapshotKey !== void 0) {
+        warnings.push(`${pkgJsonPath}: the "snapshot" key must be an object; it was ignored.`);
       }
     } catch (err) {
-      warnings.push(err.message);
+      const message = err.message;
+      warnings.push(message);
+      errors.push(message);
     }
   }
-  return { config: null, file: null, warnings };
+  return { config: null, file: null, warnings, errors };
 }
 async function loadConfigFile(cwd) {
   const loaded = await loadConfigFileDetailed(cwd);
@@ -1264,7 +2441,9 @@ function boundedBytes(value, fallback, minimum, label) {
       `${label} must be a byte count such as 120000, "120k" or "1.5mb" (received ${describeBytes(value)}).`
     );
   }
-  if (parsed <= 0) return fallback;
+  if (parsed <= 0) {
+    throw new Error(`${label} must be a positive byte count (received ${describeBytes(value)}).`);
+  }
   if (parsed < minimum) {
     throw new Error(`${label} must be at least ${minimum} bytes (received ${describeBytes(value)}).`);
   }
@@ -1304,12 +2483,12 @@ function resolveBudgets(budgets, fallback) {
     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(
+    for (const [layer2, value] of Object.entries(budgets.byLayer)) {
+      byLayer[layer2] = boundedBytes(
         value,
         fallback,
         MIN_MAX_PART_BYTES,
-        `budgets.byLayer["${layer}"]`
+        `budgets.byLayer["${layer2}"]`
       );
     }
   }
@@ -1330,18 +2509,22 @@ function resolveHooks(hooks) {
 }
 function resolveCandidateCwd(userConfig, cliOptions, baseDir) {
   const candidate = cliOptions?.cwd || userConfig?.cwd || baseDir || process.cwd();
-  const resolved = path9__namespace.resolve(candidate);
-  if (!fs8__namespace.existsSync(resolved)) {
+  const resolved = path10__namespace.resolve(candidate);
+  if (!fs9__namespace.existsSync(resolved)) {
     throw new Error(`Working directory does not exist: ${resolved}`);
   }
-  if (!fs8__namespace.statSync(resolved).isDirectory()) {
+  if (!fs9__namespace.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 forcedPreset = userConfig?.preset;
+  if (forcedPreset !== void 0 && !getPreset(forcedPreset)) {
+    throw new Error(unknownPresetMessage(forcedPreset));
+  }
+  const preset = detectPreset(cwd, forcedPreset);
   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;
@@ -1377,6 +2560,8 @@ function resolveConfig(userConfig, cliOptions, baseDir) {
     ),
     includeSensitiveFiles: cliOptions?.includeSensitiveFiles ?? userConfig?.includeSensitiveFiles ?? false,
     include: resolveInclude(userConfig?.include),
+    preset: preset.presetName,
+    presetExclude: [...preset.exclude],
     artifacts,
     layersMode,
     budgets,
@@ -1411,8 +2596,8 @@ function matchRule(filePath, matcher) {
   return false;
 }
 function classifyLayer(filePath, layers) {
-  for (const layer of layers) {
-    if (matchRule(filePath, layer.match)) return layer.name;
+  for (const layer2 of layers) {
+    if (matchRule(filePath, layer2.match)) return layer2.name;
   }
   return "other";
 }
@@ -1493,11 +2678,11 @@ function generateAuditReport(manifest, secretFindings) {
     "| :--- | :--- | :--- |"
   );
   const totalFiles = manifest.counts.totalFiles || 1;
-  for (const [layer, count] of Object.entries(manifest.layers).sort(
+  for (const [layer2, 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(`| \`${layer2}\` | ${count} | ${pct}% |`);
   }
   lines.push("");
   lines.push(
@@ -1605,21 +2790,21 @@ function partitionFiles(files, maxPartBytes, contentFingerprint) {
       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 marker2 = "\n... [part truncated: cannot fit budget] ...\n";
+    const target = Math.max(0, budget - Buffer.byteLength(marker2, "utf8"));
     const clipped = truncateToBytes(rendered[oversized].markdown, target);
-    rendered[oversized] = rehashPart(rendered[oversized], clipped.content + marker);
+    rendered[oversized] = rehashPart(rendered[oversized], clipped.content + marker2);
     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"));
+  const marker2 = "\n... [part truncated: cannot fit budget] ...\n";
+  const target = Math.max(0, budget - Buffer.byteLength(marker2, "utf8"));
   return parts.map((part) => {
     if (part.metadata.byteSize <= budget) return part;
     const clipped = truncateToBytes(part.markdown, target);
-    return rehashPart(part, clipped.content + marker);
+    return rehashPart(part, clipped.content + marker2);
   });
 }
 function renumberParts(parts, contentFingerprint) {
@@ -1627,10 +2812,10 @@ function renumberParts(parts, contentFingerprint) {
   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";
+  const marker2 = "## Contents\n";
   return parts.map((part, index) => {
-    const markerIndex = part.markdown.indexOf(marker);
-    const body = markerIndex === -1 ? "" : part.markdown.slice(markerIndex + marker.length);
+    const markerIndex = part.markdown.indexOf(marker2);
+    const body = markerIndex === -1 ? "" : part.markdown.slice(markerIndex + marker2.length);
     const included = part.metadata.includedFiles;
     if (markerIndex === -1) {
       throw new Error(`${part.filename} has no "## Contents" section to re-number.`);
@@ -1688,9 +2873,9 @@ 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 };
+  let text2 = renderFileSection(file);
+  let byteSize = Buffer.byteLength(text2, "utf8");
+  if (byteSize <= sectionBudget) return { file, text: text2, byteSize };
   const shrinkBody = () => {
     const content = file.content ?? "";
     const overhead = byteSize - Buffer.byteLength(content, "utf8");
@@ -1699,24 +2884,24 @@ function prepareSection(file, sectionBudget) {
     const truncated = truncateToBytes(content, allowed);
     if (!truncated.isTruncated) return;
     applyTruncatedContent(file, truncated.content);
-    text = renderFileSection(file);
-    byteSize = Buffer.byteLength(text, "utf8");
+    text2 = renderFileSection(file);
+    byteSize = Buffer.byteLength(text2, "utf8");
   };
   shrinkBody();
   if (byteSize > sectionBudget && file.summary) {
     file.summary = void 0;
     file.summaryOmitted = true;
-    text = renderFileSection(file);
-    byteSize = Buffer.byteLength(text, "utf8");
+    text2 = renderFileSection(file);
+    byteSize = Buffer.byteLength(text2, "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");
+    const truncated = truncateToBytes(text2, Math.max(0, target));
+    text2 = truncated.content + SECTION_TRUNCATION_NOTICE;
+    byteSize = Buffer.byteLength(text2, "utf8");
   }
-  return { file, text, byteSize };
+  return { file, text: text2, byteSize };
 }
 function applyTruncatedContent(file, content) {
   file.content = content;
@@ -1838,6 +3023,7 @@ function renderFileSection(file) {
     `- Source Lines: ${file.originalLines}`,
     `- Included Lines: ${file.includedLines}`,
     `- SHA-256: ${file.hashSha256}`,
+    ...file.summaryQuality ? [`- Summary Quality: ${file.summaryQuality}`] : [],
     ...renderSummary(file.summary),
     ...file.summaryOmitted ? ["- Summary: (omitted: exceeds the part budget)"] : [],
     "",
@@ -2085,7 +3271,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".so"
 ]);
 function isBinaryExtension(filePath) {
-  const ext = path9__namespace.extname(filePath).toLowerCase();
+  const ext = path10__namespace.extname(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
 function isBinaryBuffer(buffer) {
@@ -2099,9 +3285,9 @@ function isBinaryFile(absolutePath) {
   if (isBinaryExtension(absolutePath)) return true;
   let fd;
   try {
-    fd = fs8__namespace.openSync(absolutePath, "r");
+    fd = fs9__namespace.openSync(absolutePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs8__namespace.readSync(fd, buffer, 0, 8192, 0);
+    const bytesRead = fs9__namespace.readSync(fd, buffer, 0, 8192, 0);
     if (bytesRead === 0) return false;
     return isBinaryBuffer(buffer.subarray(0, bytesRead));
   } catch {
@@ -2109,7 +3295,7 @@ function isBinaryFile(absolutePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        fs8__namespace.closeSync(fd);
+        fs9__namespace.closeSync(fd);
       } catch {
       }
     }
@@ -2169,10 +3355,10 @@ var LANGUAGE_BY_BASENAME = {
 };
 function detectLanguage(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const base = path9__namespace.posix.basename(normalized);
+  const base = path10__namespace.posix.basename(normalized);
   if (LANGUAGE_BY_BASENAME[base]) return LANGUAGE_BY_BASENAME[base];
   if (base === ".env" || base.startsWith(".env.")) return "dotenv";
-  const ext = path9__namespace.posix.extname(base).toLowerCase();
+  const ext = path10__namespace.posix.extname(base).toLowerCase();
   return LANGUAGE_BY_EXTENSION[ext] ?? "text";
 }
 function emptyDrift() {
@@ -2191,8 +3377,8 @@ function sha256Hex(buffer) {
 function validateSnapshot(configInput) {
   assertUsableConfigInput(configInput);
   const config = isResolvedConfig(configInput) ? normalizeResolvedConfig(configInput) : resolveConfig(configInput);
-  const manifestPath = path9__namespace.join(config.cwd, config.outDir, "manifest.json");
-  if (!fs8__namespace.existsSync(manifestPath)) {
+  const manifestPath = path10__namespace.resolve(config.cwd, config.outDir, "manifest.json");
+  if (!fs9__namespace.existsSync(manifestPath)) {
     return {
       valid: false,
       manifestPresent: false,
@@ -2203,7 +3389,7 @@ function validateSnapshot(configInput) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs8__namespace.readFileSync(manifestPath, "utf8"));
+    manifest = JSON.parse(fs9__namespace.readFileSync(manifestPath, "utf8"));
   } catch (err) {
     return {
       valid: false,
@@ -2226,7 +3412,7 @@ function validateSnapshot(configInput) {
   }
   const drift = emptyDrift();
   const warnings = [];
-  const snapshotDir = path9__namespace.join(config.cwd, config.outDir);
+  const snapshotDir = path10__namespace.resolve(config.cwd, config.outDir);
   const manifestFileMap = /* @__PURE__ */ new Map();
   for (const file of manifest.files) {
     if (file && typeof file.relativePath === "string") {
@@ -2238,7 +3424,7 @@ function validateSnapshot(configInput) {
   );
   const collection = collectFiles(config.cwd, {
     includePatterns: config.include,
-    excludePatterns: config.excludePatterns,
+    excludePatterns: [...config.excludePatterns, ...config.presetExclude],
     includeSensitiveFiles: config.includeSensitiveFiles
   });
   for (const diskFile of collection.files) {
@@ -2250,7 +3436,7 @@ function validateSnapshot(configInput) {
     }
     let diskHash;
     try {
-      diskHash = sha256Hex(fs8__namespace.readFileSync(path9__namespace.join(config.cwd, diskFile)));
+      diskHash = sha256Hex(fs9__namespace.readFileSync(path10__namespace.join(config.cwd, diskFile)));
     } catch {
       drift.missingOnDisk.push(diskFile);
       continue;
@@ -2260,10 +3446,11 @@ function validateSnapshot(configInput) {
     }
   }
   for (const snapshotFile of manifestFileMap.keys()) {
-    if (!fs8__namespace.existsSync(path9__namespace.join(config.cwd, snapshotFile))) {
+    if (!fs9__namespace.existsSync(path10__namespace.join(config.cwd, snapshotFile))) {
       drift.missingOnDisk.push(snapshotFile);
     }
   }
+  drift.missingOnDisk = [...new Set(drift.missingOnDisk)];
   const maxEffectiveBudget = Math.max(
     config.maxPartBytes,
     config.budgets.default,
@@ -2274,10 +3461,10 @@ function validateSnapshot(configInput) {
     if (!part || typeof part.filename !== "string") continue;
     partNames.add(part.filename);
     if (!config.artifacts.parts) continue;
-    const partPath = path9__namespace.join(snapshotDir, "parts", part.filename);
+    const partPath = path10__namespace.join(snapshotDir, "parts", part.filename);
     let buffer;
     try {
-      buffer = fs8__namespace.readFileSync(partPath);
+      buffer = fs9__namespace.readFileSync(partPath);
     } catch {
       drift.partIssues.push({ part: part.filename, issue: "missing from snapshot/parts" });
       continue;
@@ -2364,6 +3551,11 @@ function validateSnapshot(configInput) {
         }
       }
     }
+    if (recorded?.preset !== void 0 && recorded.preset !== config.preset) {
+      drift.configMismatches.push(
+        `preset: manifest ${recorded.preset} vs current ${config.preset}`
+      );
+    }
     if (recorded?.layersMode !== void 0 && recorded.layersMode !== config.layersMode) {
       drift.configMismatches.push(
         `layersMode: manifest ${recorded.layersMode} vs current ${config.layersMode}`
@@ -2381,10 +3573,10 @@ function validateSnapshot(configInput) {
         ...Object.keys(recordedByLayer),
         ...Object.keys(config.budgets.byLayer)
       ]);
-      for (const layer of Array.from(layerNames).sort()) {
-        if (recordedByLayer[layer] !== config.budgets.byLayer[layer]) {
+      for (const layer2 of Array.from(layerNames).sort()) {
+        if (recordedByLayer[layer2] !== config.budgets.byLayer[layer2]) {
           drift.configMismatches.push(
-            `budgets.byLayer.${layer}: manifest ${recordedByLayer[layer]} vs current ${config.budgets.byLayer[layer]}`
+            `budgets.byLayer.${layer2}: manifest ${recordedByLayer[layer2]} vs current ${config.budgets.byLayer[layer2]}`
           );
         }
       }
@@ -2467,9 +3659,9 @@ function validateSnapshot(configInput) {
     ["full-codebase.md", manifest.artifacts?.fullMarkdown]
   ]) {
     if (!artifact) continue;
-    const artifactPath = path9__namespace.join(snapshotDir, key);
+    const artifactPath = path10__namespace.join(snapshotDir, key);
     try {
-      const buffer = fs8__namespace.readFileSync(artifactPath);
+      const buffer = fs9__namespace.readFileSync(artifactPath);
       if (sha256Hex(buffer) !== artifact.sha256 || buffer.length !== artifact.byteSize) {
         drift.partIssues.push({ part: key, issue: "artifact does not match its recorded digest" });
       }
@@ -2525,35 +3717,35 @@ function describeMatcher(matcher) {
   return String(matcher);
 }
 function normalizeTarget(cwd, target) {
-  const absolute = path9__namespace.resolve(cwd, target);
-  const relative3 = path9__namespace.relative(cwd, absolute);
-  if (relative3.startsWith("..") || path9__namespace.isAbsolute(relative3)) return target;
-  return relative3.split(path9__namespace.sep).join("/");
+  const absolute = path10__namespace.resolve(cwd, target);
+  const relative3 = path10__namespace.relative(cwd, absolute);
+  if (relative3.startsWith("..") || path10__namespace.isAbsolute(relative3)) return target;
+  return relative3.split(path10__namespace.sep).join("/");
 }
 function findRuleMatch(rules, relativePath) {
   return rules.find(
     (rule) => matchRule(relativePath, rule.match)
   );
 }
-function readManifest(config) {
-  const manifestPath = path9__namespace.join(config.cwd, config.outDir, "manifest.json");
+function readManifest2(config) {
+  const manifestPath = path10__namespace.resolve(config.cwd, config.outDir, "manifest.json");
   try {
-    return JSON.parse(fs8__namespace.readFileSync(manifestPath, "utf8"));
+    return JSON.parse(fs9__namespace.readFileSync(manifestPath, "utf8"));
   } catch {
     return null;
   }
 }
 function explainPath(config, target) {
   const relative3 = normalizeTarget(config.cwd, target);
-  const absolute = path9__namespace.join(config.cwd, relative3);
+  const absolute = path10__namespace.join(config.cwd, relative3);
   const result = {
     path: relative3,
-    exists: fs8__namespace.existsSync(absolute),
+    exists: fs9__namespace.existsSync(absolute),
     included: false
   };
   const collection = collectFiles(config.cwd, {
     includePatterns: config.include,
-    excludePatterns: config.excludePatterns,
+    excludePatterns: [...config.excludePatterns, ...config.presetExclude],
     includeSensitiveFiles: config.includeSensitiveFiles
   });
   if (!collection.files.includes(relative3)) {
@@ -2578,16 +3770,16 @@ function explainPath(config, target) {
   if (layerRule) result.layerMatch = describeMatcher(layerRule.match);
   const kindRule = findRuleMatch(config.kinds, relative3);
   if (kindRule) result.kindMatch = describeMatcher(kindRule.match);
-  if (fs8__namespace.existsSync(absolute) && fs8__namespace.statSync(absolute).isFile()) {
-    const buffer = fs8__namespace.readFileSync(absolute);
-    const text = buffer.toString("utf8");
+  if (fs9__namespace.existsSync(absolute) && fs9__namespace.statSync(absolute).isFile()) {
+    const buffer = fs9__namespace.readFileSync(absolute);
+    const text2 = buffer.toString("utf8");
     result.bytes = buffer.length;
-    result.lines = countLines(text);
-    const { findings } = scanAndRedactSecrets(text, config.secretRules, relative3);
+    result.lines = countLines(text2);
+    const { findings } = scanAndRedactSecrets(text2, config.secretRules, relative3);
     result.secretCount = findings.length;
     result.secrets = findings.slice(0, 20).map((finding) => ({ rule: finding.rule, line: finding.line }));
   }
-  const manifest = readManifest(config);
+  const manifest = readManifest2(config);
   const entry = manifest?.files.find((file) => file.relativePath === relative3);
   result.part = entry?.part ?? null;
   result.inclusionMode = entry?.inclusionMode;
@@ -2670,10 +3862,16 @@ function compareManifests(before, after) {
   };
 }
 function loadManifest(target) {
-  const manifestPath = fs8__namespace.statSync(target).isDirectory() ? path9__namespace.join(target, "manifest.json") : target;
+  let isDirectory;
+  try {
+    isDirectory = fs9__namespace.statSync(target).isDirectory();
+  } catch {
+    throw new Error(`No snapshot found at ${target}: the path does not exist.`);
+  }
+  const manifestPath = isDirectory ? path10__namespace.join(target, "manifest.json") : target;
   let raw;
   try {
-    raw = fs8__namespace.readFileSync(manifestPath, "utf8");
+    raw = fs9__namespace.readFileSync(manifestPath, "utf8");
   } catch {
     throw new Error(`Could not read a manifest at ${manifestPath}.`);
   }
@@ -2686,6 +3884,9 @@ function loadManifest(target) {
   if (!parsed || !Array.isArray(parsed.files)) {
     throw new Error(`${manifestPath} is not a snapshot manifest (no "files" array).`);
   }
+  if (!parsed.counts || typeof parsed.counts !== "object") {
+    throw new Error(`${manifestPath} is not a snapshot manifest (no "counts" object).`);
+  }
   return parsed;
 }
 function renderDiffText(diff) {
@@ -2709,14 +3910,659 @@ function renderDiffText(diff) {
   return lines.join("\n");
 }
 
+// src/wizard/config-template.ts
+var DEFAULT_ANSWERS = {
+  preset: "generic",
+  maxPartBytes: "300k",
+  largeFileBytes: "200k",
+  include: [],
+  excludePatterns: [],
+  artifacts: {
+    readme: true,
+    manifest: true,
+    parts: true,
+    navigation: true,
+    projectTree: true,
+    audit: true,
+    monolith: false
+  },
+  includeSensitiveFiles: false,
+  outDir: "snapshot"
+};
+function list(values) {
+  if (values.length === 0) return "[]";
+  return `[${values.map((value) => JSON.stringify(value)).join(", ")}]`;
+}
+function size(value) {
+  return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+var PRESET_NAMES = [
+  "nextjs \xB7 react-vite \xB7 vue-vite \xB7 nuxt \xB7 sveltekit \xB7 angular \xB7 astro",
+  "remix \xB7 solid \xB7 nest \xB7 node-express \xB7 node-lib",
+  "python-django \xB7 python-fastapi \xB7 python-lib \xB7 go \xB7 rust",
+  "java-spring \xB7 dotnet \xB7 php-laravel \xB7 ruby-rails",
+  "monorepo \xB7 docs \xB7 infra \xB7 generic"
+];
+function renderConfig(answers) {
+  const { artifacts } = answers;
+  return `import { defineConfig } from "@ankurhalder/codebase-snapshot";
+
+export default defineConfig({
+  // \u2500\u2500 Project \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Which project shape to use. Detected from the repo when omitted.
+  // ${PRESET_NAMES.join("\n  // ")}
+  preset: ${JSON.stringify(answers.preset)},
+
+  // Recorded in the manifest when git cannot report a branch.
+  branch: "main",
+
+  // \u2500\u2500 Output \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Where the snapshot is written.
+  outDir: ${JSON.stringify(answers.outDir)},
+  // Scratch directory; the new snapshot is renamed into place atomically.
+  tmpDir: "snapshot.tmp",
+
+  // \u2500\u2500 Size \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Hard ceiling per part. "300k", 307200 and "1.5mb" are all accepted.
+  maxPartBytes: ${size(answers.maxPartBytes)},
+  // Files above this size get a head/tail preview instead of the full body.
+  largeFileBytes: ${size(answers.largeFileBytes)},
+  previewHeadLines: 80,
+  previewTailLines: 40,
+  // Different ceilings per layer. Unlisted layers use \`default\`.
+  budgets: {
+    default: ${size(answers.maxPartBytes)},
+    byLayer: {},
+  },
+
+  // \u2500\u2500 What goes in \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Allow-list. Empty means "everything that is not ignored".
+  // Example: ["src/**", "packages/*/src/**"]
+  include: ${list(answers.include)},
+  // Globs or path segments to drop. Example: ["**/*.test.ts", "docs"]
+  excludePatterns: ${list(answers.excludePatterns)},
+
+  // \u2500\u2500 Classification \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // "merge" = the preset's rules plus yours (yours win). "replace" = yours only.
+  layersMode: "merge",
+  // [{ name: "billing", match: "src/features/billing/**" }]
+  layers: [],
+  // [{ kind: "route", match: "src/app/api/**" }]
+  kinds: [],
+
+  // \u2500\u2500 Safety \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // .env, *.pem, .npmrc, .ssh/ and friends are skipped unless this is true.
+  includeSensitiveFiles: ${answers.includeSensitiveFiles},
+  secrets: {
+    // [{ rule: "internal-token", pattern: /CORP-[A-Z0-9]{32}/ }]
+    customPatterns: [],
+    // Set true to drop the 21 built-in rules.
+    disableDefaultPatterns: false,
+  },
+
+  // \u2500\u2500 Artifacts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  artifacts: {
+    readme: ${artifacts.readme},        // README.md
+    manifest: ${artifacts.manifest},      // manifest.json \u2014 required by validate and report
+    parts: ${artifacts.parts},         // parts/part-XXX.md
+    navigation: ${artifacts.navigation},    // reports/navigation.md
+    projectTree: ${artifacts.projectTree},   // reports/project-tree.md
+    audit: ${artifacts.audit},         // reports/audit.md
+    monolith: ${artifacts.monolith},     // full-codebase.json + .md (roughly doubles output)
+  },
+  // Skip the monolith above this size. null = no limit.
+  maxMonolithBytes: null,
+
+  // \u2500\u2500 Advanced \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // afterGenerate: (manifest) => { /* write your own artifact */ }
+  hooks: {},
+});
+`;
+}
+function renderMinimalConfig(answers) {
+  const lines = [];
+  if (answers.preset !== DEFAULT_ANSWERS.preset) lines.push(`  preset: ${JSON.stringify(answers.preset)},`);
+  if (answers.maxPartBytes !== DEFAULT_ANSWERS.maxPartBytes) {
+    lines.push(`  maxPartBytes: ${size(answers.maxPartBytes)},`);
+  }
+  if (answers.largeFileBytes !== DEFAULT_ANSWERS.largeFileBytes) {
+    lines.push(`  largeFileBytes: ${size(answers.largeFileBytes)},`);
+  }
+  if (answers.include.length > 0) lines.push(`  include: ${list(answers.include)},`);
+  if (answers.excludePatterns.length > 0) {
+    lines.push(`  excludePatterns: ${list(answers.excludePatterns)},`);
+  }
+  if (answers.includeSensitiveFiles) lines.push("  includeSensitiveFiles: true,");
+  if (answers.outDir !== DEFAULT_ANSWERS.outDir) lines.push(`  outDir: ${JSON.stringify(answers.outDir)},`);
+  const changed = Object.keys(answers.artifacts).filter(
+    (name) => answers.artifacts[name] !== DEFAULT_ANSWERS.artifacts[name]
+  );
+  if (changed.length > 0) {
+    const entries = changed.map((name) => `    ${name}: ${answers.artifacts[name]}`).join(",\n");
+    lines.push(`  artifacts: {
+${entries},
+  },`);
+  }
+  if (lines.length === 0) {
+    return `import { defineConfig } from "@ankurhalder/codebase-snapshot";
+
+export default defineConfig({});
+`;
+  }
+  return `import { defineConfig } from "@ankurhalder/codebase-snapshot";
+
+export default defineConfig({
+${lines.join("\n")}
+});
+`;
+}
+var PromptCancelled = class extends Error {
+  constructor() {
+    super("Prompt cancelled");
+    this.name = "PromptCancelled";
+  }
+};
+function defaultIO() {
+  return { input: process.stdin, output: process.stdout };
+}
+function isInteractive(io) {
+  return Boolean(io.input.isTTY && io.output.isTTY);
+}
+function moveSelection(current, delta, count) {
+  if (count <= 0) return 0;
+  return ((current + delta) % count + count) % count;
+}
+function toggleIndex(selected, index) {
+  const next = new Set(selected);
+  if (next.has(index)) next.delete(index);
+  else next.add(index);
+  return next;
+}
+function marker(active) {
+  return active ? "\u276F" : " ";
+}
+function choiceLine(choice, active) {
+  const hint = choice.hint ? `  ${choice.hint}` : "";
+  return `  ${marker(active)} ${choice.label}${hint}`;
+}
+function renderSelect(message, choices, index) {
+  const lines = [`\u25C6 ${message}`, ""];
+  choices.forEach((choice, position) => lines.push(choiceLine(choice, position === index)));
+  lines.push("", "  \u2191\u2193 move \xB7 enter select");
+  return lines.join("\n");
+}
+function renderMultiSelect(message, choices, index, selected) {
+  const lines = [`\u25C6 ${message}`, ""];
+  choices.forEach((choice, position) => {
+    const box = selected.has(position) ? "\u25FC" : "\u25FB";
+    const hint = choice.hint ? `  ${choice.hint}` : "";
+    lines.push(`  ${marker(position === index)} ${box} ${choice.label}${hint}`);
+  });
+  lines.push("", "  \u2191\u2193 move \xB7 space toggle \xB7 enter confirm");
+  return lines.join("\n");
+}
+function renderConfirm(message, value) {
+  return [
+    `\u25C6 ${message}`,
+    "",
+    `  ${marker(value)} Yes`,
+    `  ${marker(!value)} No`,
+    "",
+    "  \u2190\u2192 or y/n \xB7 enter confirm"
+  ].join("\n");
+}
+function renderText(message, value, error) {
+  const lines = [`\u25C6 ${message}`, "", `  ${value || "\u258F"}`];
+  if (error) lines.push("", `  \u2716 ${error}`);
+  return lines.join("\n");
+}
+function keyReader(input) {
+  const queue = [];
+  const waiters = [];
+  const wasRaw = input.isRaw;
+  const onKey = (_text, key) => {
+    const waiter = waiters.shift();
+    if (waiter) waiter(key);
+    else queue.push(key);
+  };
+  readline__namespace.emitKeypressEvents(input);
+  if (input.isTTY) input.setRawMode(true);
+  input.resume();
+  input.on("keypress", onKey);
+  return {
+    next() {
+      const queued = queue.shift();
+      if (queued) return Promise.resolve(queued);
+      return new Promise((resolve5) => waiters.push(resolve5));
+    },
+    close() {
+      input.off("keypress", onKey);
+      if (input.isTTY) input.setRawMode(wasRaw ?? false);
+      input.pause();
+    }
+  };
+}
+var Frame = class {
+  constructor(output) {
+    this.output = output;
+  }
+  output;
+  drawn = 0;
+  draw(text2) {
+    this.erase();
+    this.output.write(`${text2}
+`);
+    this.drawn = text2.split("\n").length;
+  }
+  erase() {
+    if (this.drawn > 0) this.output.write(`\x1B[${this.drawn}A\x1B[0J`);
+    this.drawn = 0;
+  }
+};
+function isCancel(key) {
+  return key.ctrl === true && key.name === "c" || key.ctrl === true && key.name === "d";
+}
+async function select(io, message, choices, options = {}) {
+  if (choices.length === 0) throw new Error("select() requires at least one choice.");
+  const fallbackIndex = Math.max(
+    0,
+    choices.findIndex((choice) => choice.value === options.defaultValue)
+  );
+  if (!isInteractive(io)) {
+    io.output.write(`${renderSelect(message, choices, fallbackIndex)}
+`);
+    return choices[fallbackIndex].value;
+  }
+  const frame = new Frame(io.output);
+  const reader = keyReader(io.input);
+  let index = fallbackIndex;
+  try {
+    for (; ; ) {
+      frame.draw(renderSelect(message, choices, index));
+      const key = await reader.next();
+      if (isCancel(key)) throw new PromptCancelled();
+      if (key.name === "up") index = moveSelection(index, -1, choices.length);
+      else if (key.name === "down") index = moveSelection(index, 1, choices.length);
+      else if (key.name === "return" || key.name === "enter") {
+        frame.erase();
+        return choices[index].value;
+      } else if (key.name === "j") index = moveSelection(index, 1, choices.length);
+      else if (key.name === "k") index = moveSelection(index, -1, choices.length);
+    }
+  } finally {
+    reader.close();
+  }
+}
+async function multiSelect(io, message, choices, options = {}) {
+  const selected = /* @__PURE__ */ new Set();
+  choices.forEach((choice, position) => {
+    if (options.defaults?.includes(choice.value)) selected.add(position);
+  });
+  const result = () => choices.filter((_, position) => selected.has(position)).map((choice) => choice.value);
+  if (!isInteractive(io)) {
+    io.output.write(`${renderMultiSelect(message, choices, 0, selected)}
+`);
+    return result();
+  }
+  const frame = new Frame(io.output);
+  const reader = keyReader(io.input);
+  let index = 0;
+  try {
+    for (; ; ) {
+      frame.draw(renderMultiSelect(message, choices, index, selected));
+      const key = await reader.next();
+      if (isCancel(key)) throw new PromptCancelled();
+      if (key.name === "up") index = moveSelection(index, -1, choices.length);
+      else if (key.name === "down") index = moveSelection(index, 1, choices.length);
+      else if (key.name === "space") {
+        const next = toggleIndex(selected, index);
+        selected.clear();
+        for (const position of next) selected.add(position);
+      } else if (key.name === "a") {
+        if (selected.size === choices.length) selected.clear();
+        else choices.forEach((_, position) => selected.add(position));
+      } else if (key.name === "return" || key.name === "enter") {
+        frame.erase();
+        return result();
+      }
+    }
+  } finally {
+    reader.close();
+  }
+}
+async function confirm(io, message, options = {}) {
+  let value = options.defaultValue ?? true;
+  if (!isInteractive(io)) {
+    io.output.write(`${renderConfirm(message, value)}
+`);
+    return value;
+  }
+  const frame = new Frame(io.output);
+  const reader = keyReader(io.input);
+  try {
+    for (; ; ) {
+      frame.draw(renderConfirm(message, value));
+      const key = await reader.next();
+      if (isCancel(key)) throw new PromptCancelled();
+      if (key.name === "up" || key.name === "left") value = true;
+      else if (key.name === "down" || key.name === "right") value = false;
+      else if (key.name === "y") value = true;
+      else if (key.name === "n") value = false;
+      else if (key.name === "return" || key.name === "enter") {
+        frame.erase();
+        return value;
+      }
+    }
+  } finally {
+    reader.close();
+  }
+}
+async function text(io, message, options = {}) {
+  const fallback = options.defaultValue ?? "";
+  if (!isInteractive(io)) {
+    io.output.write(`${renderText(message, fallback)}
+`);
+    return fallback;
+  }
+  const frame = new Frame(io.output);
+  const reader = keyReader(io.input);
+  let value = fallback;
+  let error;
+  try {
+    for (; ; ) {
+      frame.draw(renderText(message, value, error));
+      const key = await reader.next();
+      if (isCancel(key)) throw new PromptCancelled();
+      error = void 0;
+      if (key.name === "return" || key.name === "enter") {
+        const problem = options.validate ? options.validate(value) : null;
+        if (problem) {
+          error = problem;
+          continue;
+        }
+        frame.erase();
+        return value;
+      }
+      if (key.name === "backspace") {
+        value = value.slice(0, -1);
+        continue;
+      }
+      if (key.name === "escape") {
+        value = "";
+        continue;
+      }
+      if (_isPrintable(key)) value += _keyText(key);
+    }
+  } finally {
+    reader.close();
+  }
+}
+function _isPrintable(key) {
+  return typeof key.sequence === "string" && key.sequence.length === 1 && key.sequence >= " ";
+}
+function _keyText(key) {
+  return key.sequence ?? "";
+}
+
+// src/wizard/init.ts
+var CONFIG_CANDIDATES = [
+  "snapshot.config.ts",
+  "snapshot.config.js",
+  "snapshot.config.mjs",
+  "snapshot.config.cjs",
+  "snapshot.config.json",
+  ".snapshotrc.json",
+  ".snapshotrc"
+];
+var SIZE_CHOICES = [
+  { value: "60k", label: "Small", hint: "60 KB \xB7 ~15k tokens \xB7 tight context windows" },
+  { value: "120k", label: "Medium", hint: "120 KB \xB7 ~30k tokens \xB7 recommended" },
+  { value: "300k", label: "Large", hint: "300 KB \xB7 ~75k tokens \xB7 the default" },
+  { value: "custom", label: "Custom\u2026", hint: "type a size like 150k or 1.5mb" }
+];
+function existingConfig(cwd) {
+  for (const name of CONFIG_CANDIDATES) {
+    if (fs9__namespace.existsSync(path10__namespace.join(cwd, name))) return name;
+  }
+  return null;
+}
+function artifactAnswers(options) {
+  const artifacts = { ...DEFAULT_ANSWERS.artifacts };
+  for (const name of options.skipArtifacts ?? []) {
+    if (ARTIFACT_NAMES.includes(name)) {
+      artifacts[name] = false;
+    }
+  }
+  if (options.onlyArtifacts && options.onlyArtifacts.length > 0) {
+    const keep = new Set(options.onlyArtifacts);
+    for (const name of ARTIFACT_NAMES) artifacts[name] = keep.has(name);
+  }
+  return artifacts;
+}
+function topLevelDirs(cwd) {
+  try {
+    return fs9__namespace.readdirSync(cwd, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules").map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
+}
+function addScripts(cwd, notes) {
+  const packagePath = path10__namespace.join(cwd, "package.json");
+  if (!fs9__namespace.existsSync(packagePath)) {
+    notes.push("No package.json found, so npm scripts were not added.");
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs9__namespace.readFileSync(packagePath, "utf8"));
+  } catch {
+    notes.push("Could not parse package.json; npm scripts were not added.");
+    return [];
+  }
+  const scripts = parsed.scripts && typeof parsed.scripts === "object" ? parsed.scripts : {};
+  const added = [];
+  if (!scripts.snapshot) {
+    scripts.snapshot = "codebase-snapshot generate";
+    added.push("snapshot");
+  }
+  if (!scripts["snapshot:validate"]) {
+    scripts["snapshot:validate"] = "codebase-snapshot validate";
+    added.push("snapshot:validate");
+  }
+  if (added.length === 0) return [];
+  parsed.scripts = scripts;
+  fs9__namespace.writeFileSync(packagePath, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  return added;
+}
+function addGitignore(cwd) {
+  const ignorePath = path10__namespace.join(cwd, ".gitignore");
+  const existing = fs9__namespace.existsSync(ignorePath) ? fs9__namespace.readFileSync(ignorePath, "utf8") : "";
+  const wanted = ["snapshot/", "snapshot.tmp/"];
+  const added = wanted.filter((entry) => !existing.split(/\r?\n/).includes(entry));
+  if (added.length === 0) return [];
+  const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+  fs9__namespace.writeFileSync(ignorePath, `${existing}${prefix}${added.join("\n")}
+`, "utf8");
+  return added;
+}
+function resolvePresetChoice(answers, presetName) {
+  return {
+    value: presetName,
+    label: presetName,
+    hint: presetName === answers.preset ? "detected" : void 0
+  };
+}
+async function runInit(options) {
+  const io = options.io ?? defaultIO();
+  const detected = detectPreset(options.cwd, options.preset);
+  const notes = [];
+  const answers = {
+    preset: detected.presetName,
+    maxPartBytes: options.maxPartBytes ?? detected.recommendedBudget ?? DEFAULT_ANSWERS.maxPartBytes,
+    largeFileBytes: DEFAULT_ANSWERS.largeFileBytes,
+    include: options.include ?? [],
+    excludePatterns: options.exclude ?? [],
+    artifacts: artifactAnswers(options),
+    includeSensitiveFiles: options.includeSensitiveFiles ?? DEFAULT_ANSWERS.includeSensitiveFiles,
+    outDir: options.outDir ?? DEFAULT_ANSWERS.outDir
+  };
+  const interactive = isInteractive(io) && options.yes !== true;
+  if (interactive) {
+    io.output.write("\n  @ankurhalder/codebase-snapshot\n");
+    io.output.write("  Turn this repository into an LLM-ready, redacted, byte-bounded snapshot.\n\n");
+    io.output.write(`  Detected   ${detected.presetName}
+`);
+    io.output.write(`  Directory  ${options.cwd}
+
+`);
+    const useDetected = await confirm(io, `Set up for ${detected.presetName}?`, {
+      defaultValue: true
+    });
+    if (!useDetected) {
+      answers.preset = await select(
+        io,
+        "What kind of project is this?",
+        listPresetNames().map((name) => resolvePresetChoice(answers, name))
+      );
+      const chosen = detectPreset(options.cwd, answers.preset);
+      answers.preset = chosen.presetName;
+    }
+    const scope = await select(
+      io,
+      "What should go into the snapshot?",
+      [
+        { value: "all", label: "Everything the scanner finds", hint: "recommended \xB7 respects .gitignore" },
+        { value: "folders", label: "Only specific folders\u2026" },
+        { value: "no-tests", label: "Everything, but skip tests" },
+        { value: "custom", label: "Let me write glob patterns" }
+      ],
+      { defaultValue: "all" }
+    );
+    if (scope === "folders") {
+      const dirs = topLevelDirs(options.cwd).slice(0, 40);
+      if (dirs.length === 0) {
+        notes.push("No top-level directories found; the snapshot will include everything.");
+      } else {
+        const chosen = await multiSelect(
+          io,
+          "Select folders",
+          dirs.map((name) => ({ value: name, label: `${name}/` })),
+          { defaults: dirs }
+        );
+        answers.include = chosen.map((name) => `${name}/**`);
+      }
+    } else if (scope === "no-tests") {
+      answers.excludePatterns = [
+        ...answers.excludePatterns,
+        "**/*.test.*",
+        "**/*.spec.*",
+        "tests",
+        "test"
+      ];
+    } else if (scope === "custom") {
+      const raw = await text(io, "Glob patterns to include (comma separated)", {
+        defaultValue: ""
+      });
+      answers.include = raw.split(",").map((value) => value.trim()).filter(Boolean);
+    }
+    const sizeChoice = await select(io, "How large should each part be?", SIZE_CHOICES, {
+      defaultValue: "120k"
+    });
+    if (sizeChoice === "custom") {
+      const raw = await text(io, "Part size (e.g. 150k, 1.5mb, 900000)", {
+        defaultValue: String(answers.maxPartBytes),
+        validate: (value) => parseByteSize(value) === void 0 ? "Not a valid size." : null
+      });
+      answers.maxPartBytes = parseByteSize(raw) ?? answers.maxPartBytes;
+    } else {
+      answers.maxPartBytes = sizeChoice;
+    }
+    const artifactChoices = [
+      { value: "readme", label: "README.md", hint: "orientation page" },
+      { value: "manifest", label: "manifest.json", hint: "required by validate and report" },
+      { value: "parts", label: "parts/", hint: "the code payload" },
+      { value: "navigation", label: "reports/navigation.md", hint: "file \u2192 part index" },
+      { value: "projectTree", label: "reports/project-tree.md", hint: "ASCII tree" },
+      { value: "audit", label: "reports/audit.md", hint: "security and health findings" },
+      { value: "monolith", label: "full-codebase.json + .md", hint: "roughly doubles output" }
+    ];
+    const presetEnabled = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]);
+    const selectedArtifacts = await multiSelect(
+      io,
+      "Which artifacts should be generated?",
+      artifactChoices,
+      { defaults: presetEnabled }
+    );
+    for (const name of ARTIFACT_NAMES) answers.artifacts[name] = selectedArtifacts.includes(name);
+    const enabledCount = ARTIFACT_NAMES.filter((name) => answers.artifacts[name]).length;
+    answers.includeSensitiveFiles = await confirm(
+      io,
+      "Include credential files (.env, *.pem, .npmrc, .ssh/)?",
+      { defaultValue: false }
+    );
+    io.output.write("\n  Review\n\n");
+    io.output.write(`  project          ${answers.preset}
+`);
+    io.output.write(`  include          ${answers.include.length ? answers.include.join(", ") : "everything"}
+`);
+    io.output.write(`  part size        ${String(answers.maxPartBytes)}
+`);
+    io.output.write(`  artifacts        ${enabledCount} of ${ARTIFACT_NAMES.length}
+`);
+    io.output.write(`  credentials      ${answers.includeSensitiveFiles ? "included" : "skipped"}
+
+`);
+    io.output.write("  Will write snapshot.config with your answers, plus every other setting\n");
+    io.output.write("  at its default \u2014 so nothing is hidden behind the docs.\n\n");
+    const proceed = await confirm(io, "Write this and continue?", { defaultValue: true });
+    if (!proceed) throw new PromptCancelled();
+  }
+  const configText = options.minimal ? renderMinimalConfig(answers) : renderConfig(answers);
+  const configName = supportsTypeScriptImports() ? "snapshot.config.ts" : "snapshot.config.mjs";
+  const configPath = path10__namespace.join(options.cwd, configName);
+  if (options.dryRun) {
+    return {
+      configPath,
+      configText,
+      written: false,
+      preset: answers.preset,
+      scripts: [],
+      gitignoreEntries: [],
+      notes
+    };
+  }
+  const present = existingConfig(options.cwd);
+  if (present && present !== configName && !options.force) {
+    throw new Error(
+      `A configuration already exists (${present}). Re-run with --force to replace it.`
+    );
+  }
+  if (fs9__namespace.existsSync(configPath) && !options.force) {
+    throw new Error(`${configName} already exists. Re-run with --force to replace it.`);
+  }
+  fs9__namespace.writeFileSync(configPath, configText, "utf8");
+  const scripts = addScripts(options.cwd, notes);
+  const gitignoreEntries = addGitignore(options.cwd);
+  return {
+    configPath,
+    configText,
+    written: true,
+    preset: answers.preset,
+    scripts,
+    gitignoreEntries,
+    notes
+  };
+}
+
 // src/index.ts
 var GENERATOR_NAME = "@ankurhalder/codebase-snapshot";
-var GENERATOR_VERSION = "2.0.0";
+var GENERATOR_VERSION = "2.1.1";
 var SCHEMA_VERSION = "3.0.0";
 function sha256Hex2(input) {
   return crypto__namespace.createHash("sha256").update(input).digest("hex");
 }
-var SUMMARY_EXTENSIONS = [
+var TS_EXTENSIONS = [
   ".ts",
   ".mts",
   ".cts",
@@ -2724,24 +4570,21 @@ var SUMMARY_EXTENSIONS = [
   ".js",
   ".mjs",
   ".cjs",
-  ".jsx",
-  ".json",
-  ".jsonc",
-  ".md",
-  ".mdx"
+  ".jsx"
 ];
 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);
+    return { summary: summarizeJson(redactedContent), quality: "structural" };
   }
   if (lower.endsWith(".md") || lower.endsWith(".mdx")) {
-    return summarizeMarkdown(redactedContent);
+    return { summary: summarizeMarkdown(redactedContent), quality: "structural" };
+  }
+  if (TS_EXTENSIONS.some((extension) => lower.endsWith(extension))) {
+    return { summary: summarizeTypeScriptSource(relativePath, redactedContent), quality: "ast" };
   }
-  return summarizeTypeScriptSource(relativePath, redactedContent);
+  const profiled = summarizeWithProfile(relativePath, redactedContent);
+  return profiled ? { summary: profiled.summary, quality: profiled.quality } : void 0;
 }
 function isSourceSummary(summary) {
   return Boolean(summary && typeof summary === "object" && "imports" in summary);
@@ -2767,8 +4610,8 @@ var IMPORT_CANDIDATE_SUFFIXES = [
 ];
 function resolveSpecifier(fromFile, specifier, knownFiles) {
   if (!RELATIVE_SPECIFIER.test(specifier)) return null;
-  const baseDir = path9__namespace.posix.dirname(fromFile);
-  const joined = path9__namespace.posix.normalize(path9__namespace.posix.join(baseDir, specifier));
+  const baseDir = path10__namespace.posix.dirname(fromFile);
+  const joined = path10__namespace.posix.normalize(path10__namespace.posix.join(baseDir, specifier));
   const candidate = joined.replace(/\.(?:js|mjs|cjs|jsx)$/, "");
   for (const suffix of IMPORT_CANDIDATE_SUFFIXES) {
     const withSuffix = `${joined}${suffix}`;
@@ -2860,11 +4703,11 @@ function verifyInMemory(files, parts, maxPartBytes) {
   return errors;
 }
 function resolveSafeOutputDirs(config) {
-  const cwd = path9__namespace.resolve(config.cwd);
-  const outDir = path9__namespace.resolve(cwd, config.outDir);
-  const tmpDir = path9__namespace.resolve(cwd, config.tmpDir);
-  const root = path9__namespace.parse(cwd).root;
-  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path9__namespace.sep}`);
+  const cwd = path10__namespace.resolve(config.cwd);
+  const outDir = path10__namespace.resolve(cwd, config.outDir);
+  const tmpDir = path10__namespace.resolve(cwd, config.tmpDir);
+  const root = path10__namespace.parse(cwd).root;
+  const contains = (parent, child) => child === parent || child.startsWith(`${parent}${path10__namespace.sep}`);
   const reject = (reason) => {
     throw new Error(
       `Refusing to generate: ${reason}. outDir=${outDir} tmpDir=${tmpDir} cwd=${cwd}`
@@ -2883,26 +4726,66 @@ function resolveSafeOutputDirs(config) {
   if (contains(tmpDir, outDir)) reject("outDir is inside tmpDir");
   return { outDir, tmpDir };
 }
+var PLACEHOLDER_ENTRIES = /* @__PURE__ */ new Set([".gitkeep", ".gitignore", ".DS_Store"]);
+var OWNERSHIP_MARKER = ".codebase-snapshot";
+function writeOwnershipMarker(dir) {
+  const marker2 = {
+    generator: GENERATOR_NAME,
+    version: GENERATOR_VERSION,
+    schemaVersion: SCHEMA_VERSION
+  };
+  fs9__namespace.writeFileSync(path10__namespace.join(dir, OWNERSHIP_MARKER), `${JSON.stringify(marker2, null, 2)}
+`, "utf8");
+}
+function isOwnOutput(dir) {
+  if (fs9__namespace.existsSync(path10__namespace.join(dir, OWNERSHIP_MARKER))) return true;
+  const manifestPath = path10__namespace.join(dir, "manifest.json");
+  if (!fs9__namespace.existsSync(manifestPath)) return false;
+  try {
+    const parsed = JSON.parse(fs9__namespace.readFileSync(manifestPath, "utf8"));
+    const generator = parsed.generator;
+    return typeof parsed.schemaVersion === "string" && Array.isArray(parsed.files) && typeof generator === "object" && generator !== null && generator.name === GENERATOR_NAME;
+  } catch {
+    return false;
+  }
+}
+function assertReplaceable(target, label) {
+  if (!fs9__namespace.existsSync(target)) return;
+  if (!fs9__namespace.statSync(target).isDirectory()) {
+    throw new Error(
+      `Refusing to write into ${label} ${target}: it exists but is not a directory.`
+    );
+  }
+  const entries = fs9__namespace.readdirSync(target);
+  const meaningful = entries.filter((name) => !PLACEHOLDER_ENTRIES.has(name));
+  if (meaningful.length === 0) return;
+  if (isOwnOutput(target)) return;
+  const preview = meaningful.slice(0, 5).join(", ");
+  const more = meaningful.length > 5 ? `, and ${meaningful.length - 5} more` : "";
+  throw new Error(
+    `Refusing to replace ${label} ${target}: it exists, is not empty, and does not look like a snapshot this generator wrote (found ${preview}${more}). Point ${label} at a new or empty directory, or delete it yourself first.`
+  );
+}
 function swapIntoPlace(tmpDir, outDir) {
   const backupDir = `${outDir}.backup-${process.pid}-${Date.now()}`;
-  const hadPrevious = fs8__namespace.existsSync(outDir);
-  if (hadPrevious) fs8__namespace.renameSync(outDir, backupDir);
+  const hadPrevious = fs9__namespace.existsSync(outDir);
+  if (hadPrevious) fs9__namespace.renameSync(outDir, backupDir);
   try {
     try {
-      fs8__namespace.renameSync(tmpDir, outDir);
+      fs9__namespace.renameSync(tmpDir, outDir);
     } catch (err) {
       if (err.code === "EXDEV") {
-        fs8__namespace.cpSync(tmpDir, outDir, { recursive: true });
-        fs8__namespace.rmSync(tmpDir, { recursive: true, force: true });
+        fs9__namespace.cpSync(tmpDir, outDir, { recursive: true });
+        fs9__namespace.rmSync(tmpDir, { recursive: true, force: true });
       } else {
         throw err;
       }
     }
-    if (hadPrevious) fs8__namespace.rmSync(backupDir, { recursive: true, force: true });
+    if (hadPrevious) fs9__namespace.rmSync(backupDir, { recursive: true, force: true });
   } catch (err) {
-    if (hadPrevious && fs8__namespace.existsSync(backupDir)) {
-      if (fs8__namespace.existsSync(outDir)) fs8__namespace.rmSync(outDir, { recursive: true, force: true });
-      fs8__namespace.renameSync(backupDir, outDir);
+    if (hadPrevious && fs9__namespace.existsSync(backupDir)) {
+      if (fs9__namespace.existsSync(outDir)) fs9__namespace.rmSync(outDir, { recursive: true, force: true });
+      fs9__namespace.renameSync(backupDir, outDir);
     }
     throw err;
   }
@@ -2918,7 +4801,9 @@ function artifactWarnings(artifacts) {
     );
   }
   if (ARTIFACT_NAMES.every((name) => artifacts[name] === false)) {
-    messages.push("every artifact is disabled: the snapshot directory will be empty.");
+    messages.push(
+      "every artifact is disabled: only the .codebase-snapshot ownership marker will be written."
+    );
   }
   return messages;
 }
@@ -2966,7 +4851,7 @@ function generateSnapshot(configInput, options) {
   const gitInfo = getGitInfo(config.cwd, config.branch);
   const collection = collectFiles(config.cwd, {
     includePatterns: config.include,
-    excludePatterns: config.excludePatterns,
+    excludePatterns: [...config.excludePatterns, ...config.presetExclude],
     includeSensitiveFiles: config.includeSensitiveFiles
   });
   const files = [];
@@ -2979,10 +4864,10 @@ function generateSnapshot(configInput, options) {
   let totalSizeBytes = 0;
   let largeFileCount = 0;
   for (const relativePath of collection.files) {
-    const absolutePath = path9__namespace.join(config.cwd, relativePath);
+    const absolutePath = path10__namespace.join(config.cwd, relativePath);
     let stats;
     try {
-      stats = fs8__namespace.statSync(absolutePath);
+      stats = fs9__namespace.statSync(absolutePath);
       if (!stats.isFile()) {
         skipped.push({ path: relativePath, reason: "not-file" });
         continue;
@@ -2997,7 +4882,7 @@ function generateSnapshot(configInput, options) {
     }
     let buffer;
     try {
-      buffer = fs8__namespace.readFileSync(absolutePath);
+      buffer = fs9__namespace.readFileSync(absolutePath);
     } catch {
       skipped.push({ path: relativePath, reason: "read-error" });
       continue;
@@ -3007,10 +4892,10 @@ function generateSnapshot(configInput, options) {
     const lineCount = countLines(rawContent);
     totalLines += lineCount;
     totalSizeBytes += stats.size;
-    const layer = classifyLayer(relativePath, config.layers);
+    const layer2 = classifyLayer(relativePath, config.layers);
     const kind = classifyKind(relativePath, config.kinds);
     const language = detectLanguage(relativePath);
-    bump(layerCounts, layer);
+    bump(layerCounts, layer2);
     bump(kindCounts, kind);
     const { redacted, findings } = scanAndRedactSecrets(
       rawContent,
@@ -3034,8 +4919,11 @@ function generateSnapshot(configInput, options) {
       includedLines = preview.includedLines;
     }
     let summary;
+    let summaryQuality;
     try {
-      summary = summarizeFile(relativePath, redacted);
+      const outcome = summarizeFile(relativePath, redacted);
+      summary = outcome?.summary;
+      summaryQuality = outcome?.quality;
       if (isSourceSummary(summary) && summary.parseErrors) {
         warnings.push(
           `Parse errors in ${relativePath} (${summary.parseErrors}); its summary is incomplete.`
@@ -3052,7 +4940,7 @@ function generateSnapshot(configInput, options) {
       lines: lineCount,
       hashSha256,
       part: "",
-      layer,
+      layer: layer2,
       kind,
       language,
       inclusionMode: isPreviewTruncated ? "preview" : "full",
@@ -3062,6 +4950,7 @@ function generateSnapshot(configInput, options) {
       includedLines,
       includedBytes: Buffer.byteLength(finalContent, "utf8"),
       summary,
+      summaryQuality,
       content: finalContent
     });
   }
@@ -3102,10 +4991,11 @@ function generateSnapshot(configInput, options) {
       includeSensitiveFiles: config.includeSensitiveFiles,
       artifacts: { ...config.artifacts },
       include: [...config.include],
+      preset: config.preset,
       layersMode: config.layersMode,
       budgets: { default: config.budgets.default, byLayer: { ...config.budgets.byLayer } },
       excludePatterns: [...config.excludePatterns],
-      layers: config.layers.map((layer) => layer.name),
+      layers: config.layers.map((layer2) => layer2.name),
       kinds: config.kinds.map((kind) => kind.kind)
     },
     counts: {
@@ -3192,45 +5082,48 @@ function generateSnapshot(configInput, options) {
     return manifest;
   }
   const { outDir, tmpDir } = resolveSafeOutputDirs(config);
+  assertReplaceable(tmpDir, "tmpDir");
+  assertReplaceable(outDir, "outDir");
   const { artifacts } = config;
-  fs8__namespace.rmSync(tmpDir, { recursive: true, force: true });
-  fs8__namespace.mkdirSync(tmpDir, { recursive: true });
-  const partsDir = path9__namespace.join(tmpDir, "parts");
-  const reportsDir = path9__namespace.join(tmpDir, "reports");
-  if (artifacts.parts) fs8__namespace.mkdirSync(partsDir, { recursive: true });
+  fs9__namespace.rmSync(tmpDir, { recursive: true, force: true });
+  fs9__namespace.mkdirSync(tmpDir, { recursive: true });
+  writeOwnershipMarker(tmpDir);
+  const partsDir = path10__namespace.join(tmpDir, "parts");
+  const reportsDir = path10__namespace.join(tmpDir, "reports");
+  if (artifacts.parts) fs9__namespace.mkdirSync(partsDir, { recursive: true });
   if (artifacts.navigation || artifacts.projectTree || artifacts.audit) {
-    fs8__namespace.mkdirSync(reportsDir, { recursive: true });
+    fs9__namespace.mkdirSync(reportsDir, { recursive: true });
   }
   if (artifacts.parts) {
     for (const part of parts) {
-      fs8__namespace.writeFileSync(path9__namespace.join(partsDir, part.filename), part.markdown, "utf8");
+      fs9__namespace.writeFileSync(path10__namespace.join(partsDir, part.filename), part.markdown, "utf8");
     }
   }
   if (artifacts.projectTree) {
     const projectTree = generateProjectTree(files.map((file) => file.relativePath));
-    fs8__namespace.writeFileSync(path9__namespace.join(reportsDir, "project-tree.md"), projectTree, "utf8");
+    fs9__namespace.writeFileSync(path10__namespace.join(reportsDir, "project-tree.md"), projectTree, "utf8");
   }
   if (artifacts.navigation) {
-    fs8__namespace.writeFileSync(path9__namespace.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
+    fs9__namespace.writeFileSync(path10__namespace.join(reportsDir, "navigation.md"), generateNavigation(manifest), "utf8");
   }
   if (artifacts.audit) {
-    fs8__namespace.writeFileSync(
-      path9__namespace.join(reportsDir, "audit.md"),
+    fs9__namespace.writeFileSync(
+      path10__namespace.join(reportsDir, "audit.md"),
       generateAuditReport(manifest, secretFindings),
       "utf8"
     );
   }
   if (artifacts.readme) {
-    fs8__namespace.writeFileSync(path9__namespace.join(tmpDir, "README.md"), generateReadme(manifest), "utf8");
+    fs9__namespace.writeFileSync(path10__namespace.join(tmpDir, "README.md"), generateReadme(manifest), "utf8");
   }
   if (artifacts.manifest) {
-    fs8__namespace.writeFileSync(path9__namespace.join(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+    fs9__namespace.writeFileSync(path10__namespace.join(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
   }
   if (monolithJson !== null) {
-    fs8__namespace.writeFileSync(path9__namespace.join(tmpDir, "full-codebase.json"), monolithJson, "utf8");
+    fs9__namespace.writeFileSync(path10__namespace.join(tmpDir, "full-codebase.json"), monolithJson, "utf8");
   }
   if (monolithMarkdown !== null) {
-    fs8__namespace.writeFileSync(path9__namespace.join(tmpDir, "full-codebase.md"), monolithMarkdown, "utf8");
+    fs9__namespace.writeFileSync(path10__namespace.join(tmpDir, "full-codebase.md"), monolithMarkdown, "utf8");
   }
   swapIntoPlace(tmpDir, outDir);
   runAfterGenerate(config, manifest);
@@ -3241,12 +5134,17 @@ async function generateSnapshotAsync(configInput, options) {
 }
 
 exports.ARTIFACT_NAMES = ARTIFACT_NAMES;
+exports.DEFAULT_ANSWERS = DEFAULT_ANSWERS;
 exports.DEFAULT_SECRET_PATTERNS = DEFAULT_SECRET_PATTERNS;
 exports.GENERATOR_NAME = GENERATOR_NAME;
 exports.GENERATOR_VERSION = GENERATOR_VERSION;
+exports.LANGUAGE_PROFILES = LANGUAGE_PROFILES;
 exports.MIN_MAX_PART_BYTES = MIN_MAX_PART_BYTES;
+exports.PRESETS = PRESETS;
+exports.PromptCancelled = PromptCancelled;
 exports.SCHEMA_VERSION = SCHEMA_VERSION;
 exports.anchorForPath = anchorForPath;
+exports.assertReplaceable = assertReplaceable;
 exports.assertUsableConfigInput = assertUsableConfigInput;
 exports.collectFiles = collectFiles;
 exports.compareManifests = compareManifests;
@@ -3259,12 +5157,15 @@ exports.fenceForContent = fenceForContent;
 exports.generateProjectTree = generateProjectTree;
 exports.generateSnapshot = generateSnapshot;
 exports.generateSnapshotAsync = generateSnapshotAsync;
+exports.getPreset = getPreset;
 exports.globToRegExp = globToRegExp;
 exports.isBinaryBuffer = isBinaryBuffer;
 exports.isBinaryExtension = isBinaryExtension;
 exports.isBinaryFile = isBinaryFile;
+exports.isInteractive = isInteractive;
 exports.isResolvedConfig = isResolvedConfig;
 exports.isSensitivePath = isSensitivePath;
+exports.listPresetNames = listPresetNames;
 exports.loadConfigFile = loadConfigFile;
 exports.loadConfigFileDetailed = loadConfigFileDetailed;
 exports.loadManifest = loadManifest;
@@ -3274,16 +5175,21 @@ exports.matchesExclude = matchesExclude;
 exports.normalizeResolvedConfig = normalizeResolvedConfig;
 exports.parseByteSize = parseByteSize;
 exports.partitionFiles = partitionFiles;
+exports.profileForPath = profileForPath;
+exports.renderConfig = renderConfig;
 exports.renderDiffText = renderDiffText;
 exports.renderExplainText = renderExplainText;
+exports.renderMinimalConfig = renderMinimalConfig;
 exports.renumberParts = renumberParts;
 exports.resolveConfig = resolveConfig;
 exports.resolveSafeOutputDirs = resolveSafeOutputDirs;
+exports.runInit = runInit;
 exports.scanAndRedactSecrets = scanAndRedactSecrets;
 exports.stripJsonComments = stripJsonComments;
 exports.summarizeJson = summarizeJson;
 exports.summarizeMarkdown = summarizeMarkdown;
 exports.summarizeTypeScriptSource = summarizeTypeScriptSource;
+exports.summarizeWithProfile = summarizeWithProfile;
 exports.supportsTypeScriptImports = supportsTypeScriptImports;
 exports.truncatePreview = truncatePreview;
 exports.truncateToBytes = truncateToBytes;