prism0x2a 0.7.2 → 0.11.0

package/.next/standalone/node_modules/prismlens/dist/blueprint/index.mjs

@@ -0,0 +1,2521 @@
+import { SyntaxKind, Project } from 'ts-morph';
+import { dirname, resolve, join, normalize, basename, relative } from 'path';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, statSync } from 'fs';
+import fg from 'fast-glob';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/astEnrich.ts
+var astEnrich_exports = {};
+__export(astEnrich_exports, {
+  enrichWithTypedSignatures: () => enrichWithTypedSignatures,
+  extractJsDocData: () => extractJsDocData,
+  extractTypedSignatures: () => extractTypedSignatures
+});
+function extractJsDocData(sf, nodePos) {
+  try {
+    const node = sf.getDescendantAtPos(nodePos);
+    if (!node) return { description: null, params: [], returns: null };
+    const jsDocs = node.getParent()?.getJsDocs?.() ?? [];
+    const jsDoc = jsDocs[jsDocs.length - 1];
+    if (!jsDoc) return { description: null, params: [], returns: null };
+    const description = jsDoc.getDescription()?.trim() || null;
+    const params = jsDoc.getTags().filter((t) => t.getTagName() === "param").map((t) => {
+      const full = t.getText().replace(/^@param\s*/, "");
+      const typeMatch = /\{([^}]+)\}/.exec(full);
+      const nameMatch = /\}\s+(\w+)/.exec(full);
+      const descMatch = /\}\s+\w+\s+-?\s*(.+)/.exec(full);
+      return {
+        type: typeMatch?.[1] ?? "unknown",
+        name: nameMatch?.[1] ?? "?",
+        description: descMatch?.[1]?.trim() ?? ""
+      };
+    });
+    const returnTag = jsDoc.getTags().find((t) => t.getTagName() === "returns" || t.getTagName() === "return");
+    const returns = returnTag ? returnTag.getText().replace(/^@returns?\s*/, "").trim() || null : null;
+    return { description, params, returns };
+  } catch {
+    return { description: null, params: [], returns: null };
+  }
+}
+function extractTypedSignatures(sf) {
+  const results = [];
+  for (const decl of sf.getFunctions()) {
+    if (!decl.isExported()) continue;
+    const name = decl.getName();
+    if (!name) continue;
+    try {
+      const params = decl.getParameters().map((p) => {
+        const typeText = p.getType().getText(sf);
+        const opt = p.hasQuestionToken() ? "?" : "";
+        const rest = p.isRestParameter() ? "..." : "";
+        return `${rest}${p.getName()}${opt}: ${typeText}`;
+      }).join(", ");
+      const returnType = decl.getReturnType().getText(sf);
+      const signature = `(${params}) => ${returnType}`;
+      const kind = name.startsWith("use") ? "hook" : /^[A-Z]/.test(name) ? "component" : "function";
+      results.push({
+        name,
+        kind,
+        signature: signature.slice(0, 300),
+        jsDoc: extractJsDocData(sf, decl.getPos())
+      });
+    } catch {
+    }
+  }
+  for (const varStmt of sf.getVariableStatements()) {
+    if (!varStmt.isExported()) continue;
+    for (const varDecl of varStmt.getDeclarations()) {
+      const name = varDecl.getName();
+      try {
+        const initializer = varDecl.getInitializer();
+        const isArrowFn = initializer?.getKind() === SyntaxKind.ArrowFunction;
+        const typeText = varDecl.getType().getText(sf);
+        const kind = isArrowFn && name.startsWith("use") ? "hook" : isArrowFn && /^[A-Z]/.test(name) ? "component" : isArrowFn ? "function" : "const";
+        results.push({
+          name,
+          kind,
+          signature: typeText.slice(0, 300),
+          jsDoc: extractJsDocData(sf, varDecl.getPos())
+        });
+      } catch {
+      }
+    }
+  }
+  for (const decl of sf.getInterfaces()) {
+    if (!decl.isExported()) continue;
+    try {
+      const props = decl.getProperties().slice(0, 8).map((p) => {
+        const opt = p.hasQuestionToken() ? "?" : "";
+        const typeText = p.getType().getText(sf);
+        return `${p.getName()}${opt}: ${typeText}`;
+      }).join("; ");
+      results.push({
+        name: decl.getName(),
+        kind: "interface",
+        signature: `{ ${props} }`.slice(0, 400),
+        jsDoc: extractJsDocData(sf, decl.getPos())
+      });
+    } catch {
+    }
+  }
+  for (const decl of sf.getTypeAliases()) {
+    if (!decl.isExported()) continue;
+    try {
+      const typeText = decl.getType().getText(sf);
+      results.push({
+        name: decl.getName(),
+        kind: "type",
+        signature: typeText.slice(0, 300),
+        jsDoc: { description: null, params: [], returns: null }
+      });
+    } catch {
+    }
+  }
+  return results.slice(0, 15);
+}
+function enrichWithTypedSignatures(files, projectRoot) {
+  const result = /* @__PURE__ */ new Map();
+  const targets = files.filter(
+    (f) => f.metrics.heatScore > 20 || f.metrics.incomingRuntimeDeps > 3 || f.exports.length > 3
+  ).slice(0, 150);
+  if (targets.length === 0) return result;
+  const project = new Project({
+    tsConfigFilePath: join(projectRoot, "tsconfig.json"),
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true
+  });
+  for (const file of targets) {
+    try {
+      const sf = project.addSourceFileAtPathIfExists(join(projectRoot, file.path));
+      if (!sf) continue;
+      const signatures = extractTypedSignatures(sf);
+      if (signatures.length > 0) result.set(file.path, signatures);
+    } catch {
+    }
+  }
+  return result;
+}
+var init_astEnrich = __esm({
+  "src/astEnrich.ts"() {
+  }
+});
+
+// src/blueprint.config.ts
+var blueprintConfig = {
+  include: [
+    "app/**/*.{ts,tsx}",
+    "components/**/*.{ts,tsx}",
+    "lib/**/*.{ts,tsx}",
+    "hooks/**/*.{ts,tsx}",
+    // integriertes Tool selbst
+    "blueprint-tool/**/*.{ts,tsx}",
+    // DB-Schema nur als lesbarer Kontext
+    "db.sql",
+    // optional interessante Root-Konfigurationen für App-Struktur
+    "next.config.ts",
+    "tsconfig.json",
+    "tsconfig.test.json",
+    "package.json"
+  ],
+  exclude: [
+    "**/node_modules/**",
+    "**/.next/**",
+    "**/out/**",
+    "**/build/**",
+    "**/dist/**",
+    "**/coverage/**",
+    "**/.git/**",
+    "**/.vercel/**",
+    "**/.turbo/**",
+    // Runtime-/static assets
+    "**/public/**",
+    // Tests und Test-Artefakte
+    "**/__tests__/**",
+    "**/tests/**",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    // Supabase generell raus, außer SQL wenn bewusst included
+    "**/supabase/migrations/**",
+    // Dokumentation / nicht relevanter Text-Content
+    "**/*.md",
+    "**/*.html",
+    // Binäre / statische Assets
+    "**/*.svg",
+    "**/*.png",
+    "**/*.jpg",
+    "**/*.jpeg",
+    "**/*.gif",
+    "**/*.webp",
+    "**/*.ico",
+    // Lock / Build-Meta
+    "**/*.lock",
+    "**/*.tsbuildinfo"
+  ]
+};
+
+// src/lib/coverageUtils.ts
+function covScore(cov) {
+  if (!cov) return null;
+  return (cov.statements + cov.branches + cov.functions + cov.lines) / 4;
+}
+function parseCoverageSummary(raw, projectRoot) {
+  const map = /* @__PURE__ */ new Map();
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/$/, "");
+  for (const [rawPath, data] of Object.entries(raw)) {
+    if (rawPath === "total") continue;
+    const normalized = rawPath.replace(/\\/g, "/");
+    let rel;
+    if (normalized.startsWith(root + "/")) {
+      rel = normalized.slice(root.length + 1);
+    } else {
+      rel = normalized.replace(/^\.\//, "");
+    }
+    map.set(rel, {
+      statements: data.statements.pct,
+      branches: data.branches.pct,
+      functions: data.functions.pct,
+      lines: data.lines.pct
+    });
+  }
+  return map;
+}
+function lookupCoverage(map, relPath) {
+  const direct = map.get(relPath);
+  if (direct) return direct;
+  const norm = relPath.replace(/\\/g, "/").replace(/^\.\//, "");
+  const normMatch = map.get(norm);
+  if (normMatch) return normMatch;
+  const suffix = "/" + norm;
+  const matches = [];
+  for (const [key, val] of map) {
+    if (key === norm || key.endsWith(suffix)) matches.push(val);
+    if (matches.length > 1) return null;
+  }
+  return matches[0] ?? null;
+}
+function computeRisk(heat, loc, coverage) {
+  if (heat >= 85) return "high";
+  if (heat >= 60 && (coverage == null || coverage < 30)) return "high";
+  if (loc > 500 && (coverage == null || coverage < 50)) return "high";
+  if (heat < 25 && coverage != null && coverage >= 70) return "low";
+  if (heat < 15) return "low";
+  return "medium";
+}
+function loadHistory(historyPath) {
+  try {
+    const raw = readFileSync(historyPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version === 1 && parsed.files) return parsed;
+  } catch {
+  }
+  return { version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), files: {} };
+}
+function updateHistory(existing, files, getCoverageAvg) {
+  const now = /* @__PURE__ */ new Date();
+  const scanTs = now.toISOString();
+  const today = scanTs.split("T")[0];
+  const updated = {};
+  for (const file of files) {
+    const cov = (() => {
+      const v = getCoverageAvg(file);
+      return v !== null ? parseFloat(v.toFixed(1)) : null;
+    })();
+    const entry = {
+      date: today,
+      scanTs,
+      heat: parseFloat(file.metrics.heatScore.toFixed(2)),
+      coverage: cov,
+      loc: file.metrics.loc,
+      incomingDeps: file.metrics.incomingRuntimeDeps,
+      risk: computeRisk(file.metrics.heatScore, file.metrics.loc, cov)
+    };
+    const prev = existing.files[file.path] ?? [];
+    updated[file.path] = [...prev, entry].slice(-100);
+  }
+  return {
+    version: 1,
+    updatedAt: scanTs,
+    files: updated
+  };
+}
+function saveHistory(historyPath, history) {
+  writeFileSync(historyPath, JSON.stringify(history, null, 2), "utf-8");
+}
+
+// src/scan.ts
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+function readTsConfigPaths(projectRoot) {
+  const tsconfigPath = join(projectRoot, "tsconfig.json");
+  try {
+    const raw = JSON.parse(readFileSync(tsconfigPath, "utf-8"));
+    const opts = raw.compilerOptions ?? {};
+    const baseUrl = opts.baseUrl ? resolve(projectRoot, opts.baseUrl) : projectRoot;
+    return { baseUrl, paths: opts.paths ?? {} };
+  } catch {
+    return { baseUrl: projectRoot, paths: {} };
+  }
+}
+function tryResolveFile(absBase, projectRoot) {
+  const bare = absBase.replace(/\.(tsx?|jsx?)$/, "");
+  const candidates = [
+    bare + ".ts",
+    bare + ".tsx",
+    join(bare, "index.ts"),
+    join(bare, "index.tsx")
+  ];
+  for (const c of candidates) {
+    if (existsSync(c)) {
+      const rel = normalize(relative(projectRoot, c));
+      if (!rel.startsWith("..")) return rel;
+    }
+  }
+  return null;
+}
+function resolveImport(specifier, sourceFile, projectRoot, scopeSet, aliases) {
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    const sourceDir = dirname(resolve(projectRoot, sourceFile));
+    const resolved = tryResolveFile(resolve(sourceDir, specifier), projectRoot);
+    const kind = resolved !== null && scopeSet.has(resolved) ? "internal" : "external";
+    return { source: specifier, resolvedPath: resolved, kind };
+  }
+  for (const [pattern, targets] of Object.entries(aliases.paths)) {
+    const prefix = pattern.replace(/\*$/, "");
+    if (!specifier.startsWith(prefix)) continue;
+    const rest = specifier.slice(prefix.length);
+    for (const target of targets) {
+      const targetPrefix = target.replace(/\*$/, "");
+      const resolved = tryResolveFile(
+        resolve(aliases.baseUrl, targetPrefix, rest),
+        projectRoot
+      );
+      if (resolved !== null) {
+        const kind = scopeSet.has(resolved) ? "internal" : "external";
+        return { source: specifier, resolvedPath: resolved, kind };
+      }
+    }
+  }
+  return { source: specifier, resolvedPath: null, kind: "external" };
+}
+function classifyImports(content) {
+  const typeOnly = /* @__PURE__ */ new Set();
+  const runtime = /* @__PURE__ */ new Set();
+  let m;
+  const typeStatementRe = /^(?:import|export)\s+type\b[^]*?from\s+['"]([^'"]+)['"]/gm;
+  while ((m = typeStatementRe.exec(content)) !== null) {
+    typeOnly.add(m[1]);
+  }
+  const namedRe = /^import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/gm;
+  while ((m = namedRe.exec(content)) !== null) {
+    const bindings = m[1].split(",").map((b) => b.trim()).filter(Boolean);
+    const allTypeInline = bindings.length > 0 && bindings.every((b) => /^type[\s\t]/.test(b));
+    if (allTypeInline) {
+      if (!runtime.has(m[2])) typeOnly.add(m[2]);
+    } else {
+      runtime.add(m[2]);
+    }
+  }
+  const fromRe = /\bfrom\s+['"]([^'"]+)['"]/gm;
+  while ((m = fromRe.exec(content)) !== null) {
+    const spec = m[1];
+    if (typeOnly.has(spec) || runtime.has(spec)) continue;
+    const lineStart = content.lastIndexOf("\n", m.index) + 1;
+    const linePrefix = content.slice(lineStart, m.index).trimStart();
+    if (/^(?:import|export)\s+type\b/.test(linePrefix)) continue;
+    if (/^import\s+\{/.test(linePrefix)) continue;
+    if (/^(?:import|export)\b/.test(linePrefix)) {
+      runtime.add(spec);
+    }
+  }
+  const sideEffectRe = /^import\s+['"]([^'"]+)['"]/gm;
+  while ((m = sideEffectRe.exec(content)) !== null) {
+    runtime.add(m[1]);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const s of typeOnly) result.set(s, runtime.has(s) ? "runtime" : "type-only");
+  for (const s of runtime) result.set(s, "runtime");
+  return result;
+}
+function extractImports(content) {
+  const results = /* @__PURE__ */ new Set();
+  const fromRe = /\bfrom\s+['"]([^'"]+)['"]/gm;
+  let m;
+  while ((m = fromRe.exec(content)) !== null) {
+    results.add(m[1]);
+  }
+  const sideEffectRe = /^import\s+['"]([^'"]+)['"]/gm;
+  while ((m = sideEffectRe.exec(content)) !== null) {
+    results.add(m[1]);
+  }
+  return [...results];
+}
+function extractExports(content) {
+  const results = /* @__PURE__ */ new Set();
+  const namedRe = /^export\s+(?:default\s+)?(?:const|let|var|function\*?|async\s+function\*?|class|type|interface|enum)\s+(\w+)/gm;
+  let m;
+  while ((m = namedRe.exec(content)) !== null) {
+    results.add(m[1]);
+  }
+  const groupedRe = /^export\s+(?:type\s+)?\{([^}]+)\}/gm;
+  while ((m = groupedRe.exec(content)) !== null) {
+    m[1].split(",").forEach((part) => {
+      const alias = part.trim().split(/\s+as\s+/).pop()?.trim();
+      if (alias && alias !== "") results.add(alias);
+    });
+  }
+  const hasNamedDefault = /^export\s+default\s+(?:function\*?|async\s+function\*?|class)\s+\w+/m.test(
+    content
+  );
+  if (/^export\s+default\b/m.test(content) && !hasNamedDefault) {
+    results.add("default");
+  }
+  return [...results];
+}
+function extractDocInfo(content) {
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < Math.min(lines.length, 5)) {
+    const t = lines[i].trim();
+    if (t === "" || /^['"]use (client|server)['"]/.test(t)) {
+      i++;
+    } else {
+      break;
+    }
+  }
+  if (i >= lines.length) return { docSummary: null, docBlock: null };
+  const firstLine = lines[i].trim();
+  if (firstLine.startsWith("/**")) {
+    const blockLines = [];
+    for (let j = i; j < lines.length; j++) {
+      blockLines.push(lines[j]);
+      if (lines[j].includes("*/")) break;
+    }
+    const cleaned = blockLines.join("\n").replace(/^\/\*+/, "").replace(/\*+\/$/, "").split("\n").map((l) => l.replace(/^\s*\*\s?/, "").trim()).filter((l) => l.length > 0);
+    if (cleaned.length === 0) return { docSummary: null, docBlock: null };
+    const summary = cleaned.find((l) => !l.startsWith("@")) ?? null;
+    return { docSummary: summary, docBlock: cleaned.join("\n") };
+  }
+  if (firstLine.startsWith("//") && !firstLine.startsWith("///")) {
+    const commentLines = [];
+    for (let j = i; j < lines.length; j++) {
+      const t = lines[j].trim();
+      if (!t.startsWith("//")) break;
+      commentLines.push(t.replace(/^\/\/\s?/, ""));
+    }
+    if (commentLines.length === 0 || commentLines[0].length < 3) {
+      return { docSummary: null, docBlock: null };
+    }
+    return {
+      docSummary: commentLines[0],
+      docBlock: commentLines.join("\n")
+    };
+  }
+  return { docSummary: null, docBlock: null };
+}
+function detectJsDoc(content) {
+  return /\/\*\*[\s\S]*?\*\//.test(content);
+}
+function extractTypeImportedNames(content) {
+  const names = /* @__PURE__ */ new Set();
+  let m;
+  const namedRe = /^import\s+type\s+\{([^}]+)\}/gm;
+  while ((m = namedRe.exec(content)) !== null) {
+    m[1].split(",").forEach((part) => {
+      const local = part.trim().split(/\s+as\s+/).pop()?.trim() ?? "";
+      if (/^[A-Z][A-Za-z]/.test(local)) names.add(local);
+    });
+  }
+  const defaultRe = /^import\s+type\s+([A-Z][A-Za-z]\w*)\s+from/gm;
+  while ((m = defaultRe.exec(content)) !== null) {
+    names.add(m[1]);
+  }
+  return names;
+}
+function countHook(content, hookName) {
+  const re = new RegExp(`\\b${hookName}[\\s<(]`, "g");
+  return (content.match(re) ?? []).length;
+}
+var STATE_SIGNAL_PATTERNS = [
+  { re: /\b(?:history|undo|redo)\b/i, signal: "undo/redo history" },
+  { re: /\b(?:isDirty|dirty|hasChanges|unsaved|pendingChange)\b/i, signal: "dirty-checking" },
+  { re: /\b(?:guard|isAllowed|canEdit|permission|isAuthorized)\b/i, signal: "guard logic" },
+  { re: /\b(?:preview|draftPreview|previewMode|previewState)\b/i, signal: "derived preview state" },
+  { re: /\b(?:eventLog|events|log|logEntry|auditLog)\b/i, signal: "event log state" },
+  { re: /\b(?:draft|pendingItem|staged)\b/i, signal: "draft/pending state" },
+  { re: /\b(?:cache|cached)\b/i, signal: "memoization/cache" },
+  { re: /\b(?:selected|selection|activeItem)\b/i, signal: "selection state" },
+  { re: /\b(?:currentPage|pageSize|offset|pagination)\b/i, signal: "pagination state" },
+  { re: /\b(?:modal|dialog|isOpen|overlayVisible)\b/i, signal: "modal/overlay state" }
+];
+function extractStateComplexity(content, filePath) {
+  if (!filePath.endsWith(".tsx")) return null;
+  const useState = countHook(content, "useState");
+  const useReducer = countHook(content, "useReducer");
+  const useEffect = countHook(content, "useEffect");
+  const useMemo = countHook(content, "useMemo");
+  const useCallback = countHook(content, "useCallback");
+  const useRef = countHook(content, "useRef");
+  const total = useState + useReducer + useEffect + useMemo + useCallback + useRef;
+  if (total === 0) return null;
+  const stateVarRe = /const\s+\[\s*(\w+)\s*,\s*\w+\s*\]\s*=\s*use(?:State|Reducer)/g;
+  const stateVarNames = [];
+  let m;
+  while ((m = stateVarRe.exec(content)) !== null) {
+    stateVarNames.push(m[1]);
+  }
+  const stateVarText = stateVarNames.join(" ");
+  const localStateSignals = STATE_SIGNAL_PATTERNS.filter(({ re }) => re.test(stateVarText)).map(({ signal }) => signal);
+  const notes = [];
+  if (total >= 20) notes.push(`${total} hooks \u2014 very high state complexity`);
+  else if (total >= 10) notes.push(`${total} hooks \u2014 high state complexity`);
+  else if (total >= 5) notes.push(`${total} hooks \u2014 moderate state complexity`);
+  if (useEffect >= 4) notes.push(`${useEffect} useEffect calls \u2014 complex side effects`);
+  if (useMemo + useCallback >= 6) notes.push(`${useMemo + useCallback} memoization hooks`);
+  if (useReducer >= 1) notes.push("useReducer \u2014 complex state machine");
+  if (useState >= 12) notes.push(`${useState} useState \u2014 many independent state slices`);
+  return {
+    hookCounts: { useState, useReducer, useEffect, useMemo, useCallback, useRef, total },
+    localStateSignals,
+    complexityNotes: notes.slice(0, 3)
+  };
+}
+var TS_TYPE_BLOCKLIST = /* @__PURE__ */ new Set([
+  "Array",
+  "ReadonlyArray",
+  "IterableIterator",
+  "AsyncIterator",
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  "WeakRef",
+  "Record",
+  "Promise",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "ReturnType",
+  "InstanceType",
+  "Parameters",
+  "ConstructorParameters",
+  "Awaited",
+  "Uppercase",
+  "Lowercase",
+  "Capitalize",
+  "Uncapitalize",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "BigInt",
+  "Function",
+  "Error",
+  "Date",
+  "RegExp"
+]);
+var PRIMITIVE_PATTERNS = [
+  ["Button", /Button/],
+  ["Modal", /Modal/],
+  ["Dialog", /Dialog|AlertDialog/],
+  ["Select", /Select/],
+  ["Input", /Input|TextField|TextInput/],
+  ["Textarea", /Textarea/],
+  ["Checkbox", /Checkbox/],
+  ["Radio", /Radio/],
+  ["Switch", /Switch|Toggle/],
+  ["Tabs", /Tabs?(?!le)/],
+  // Tab/Tabs but not Table
+  ["Table", /Table|DataTable/],
+  ["Card", /Card/],
+  ["Form", /Form/],
+  ["Badge", /Badge/],
+  ["Tooltip", /Tooltip|Popover/],
+  ["Dropdown", /Dropdown|DropdownMenu/],
+  ["Sheet", /Sheet/],
+  ["Drawer", /Drawer/],
+  ["Calendar", /Calendar/],
+  ["Avatar", /Avatar/],
+  ["Command", /Command|Combobox/],
+  ["Search", /Search|SearchBar/]
+];
+function extractJsxInfo(content, filePath) {
+  const empty = {
+    jsxComponents: [],
+    uiPrimitives: [],
+    componentUsageCount: 0,
+    topLevelJsxBlocks: []
+  };
+  if (!filePath.endsWith(".tsx")) return empty;
+  const typeImportedNames = extractTypeImportedNames(content);
+  const jsxTagRe = /(?<![a-zA-Z0-9_])<([A-Z][A-Za-z]+(?:\.[A-Za-z]+)*)(?=[\s\/>])/g;
+  const allMatches = [];
+  let m;
+  while ((m = jsxTagRe.exec(content)) !== null) {
+    const name = m[1];
+    const baseName = name.split(".")[0];
+    if (TS_TYPE_BLOCKLIST.has(baseName)) continue;
+    if (baseName.startsWith("HTML") || baseName.startsWith("SVG")) continue;
+    if (baseName === "NodeJS") continue;
+    if (baseName === "React") continue;
+    if (typeImportedNames.has(baseName)) continue;
+    allMatches.push(name);
+  }
+  const componentUsageCount = allMatches.length;
+  const jsxComponents = [...new Set(allMatches)].sort();
+  const primitiveSet = /* @__PURE__ */ new Set();
+  for (const comp of jsxComponents) {
+    for (const [prim, pattern] of PRIMITIVE_PATTERNS) {
+      if (pattern.test(comp)) {
+        primitiveSet.add(prim);
+        break;
+      }
+    }
+  }
+  const uiPrimitives = [...primitiveSet].sort();
+  const topLevelJsxBlocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of allMatches) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      topLevelJsxBlocks.push(name);
+      if (topLevelJsxBlocks.length >= 10) break;
+    }
+  }
+  return { jsxComponents, uiPrimitives, componentUsageCount, topLevelJsxBlocks };
+}
+function detectDirectives(content) {
+  const head = content.split("\n").slice(0, 5).join("\n");
+  return {
+    hasUseClient: /^(?:'use client'|"use client")/m.test(head),
+    hasUseServer: /^(?:'use server'|"use server")/m.test(head)
+  };
+}
+function getRenderEnvironment(filePath, hasUseClient, hasUseServer) {
+  if (hasUseClient) return "client";
+  if (hasUseServer) return "server";
+  if (filePath.startsWith("app/")) return "server";
+  return "shared";
+}
+function getNextFileKind(filePath) {
+  const name = basename(filePath);
+  if (name === "page.tsx" || name === "page.ts") return "page";
+  if (name === "layout.tsx" || name === "layout.ts") return "layout";
+  if (name === "route.ts" || name === "route.tsx") return "route";
+  if (name === "loading.tsx" || name === "loading.ts") return "loading";
+  if (name === "error.tsx" || name === "error.ts") return "error";
+  if (name === "template.tsx" || name === "template.ts") return "template";
+  return "default";
+}
+function deriveRoutePath(filePath) {
+  if (!filePath.startsWith("app/")) return null;
+  const rel = filePath.slice("app/".length);
+  const dir = dirname(rel);
+  if (dir === ".") return "/";
+  const parts = dir.split("/").filter((p) => !(p.startsWith("(") && p.endsWith(")"))).filter((p) => p !== ".");
+  if (parts.length === 0) return "/";
+  return "/" + parts.join("/");
+}
+function getCategory(path) {
+  if (path.startsWith("app/")) return "app";
+  if (path.startsWith("components/")) return "component";
+  if (path.startsWith("lib/")) return "lib";
+  if (path.startsWith("hooks/")) return "hook";
+  return "unknown";
+}
+function makeId(path) {
+  return path.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+function tarjanSCC(graph) {
+  const indices = /* @__PURE__ */ new Map();
+  const lowlinks = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const sccs = [];
+  let counter = 0;
+  function strongConnect(v) {
+    indices.set(v, counter);
+    lowlinks.set(v, counter);
+    counter++;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of graph.get(v) ?? []) {
+      if (!indices.has(w)) {
+        strongConnect(w);
+        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+      }
+    }
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      sccs.push(scc);
+    }
+  }
+  for (const v of graph.keys()) {
+    if (!indices.has(v)) {
+      strongConnect(v);
+    }
+  }
+  return sccs;
+}
+function extractCycleGroups(allSccs, adjacency) {
+  const cyclicSccs = allSccs.filter(
+    (scc) => scc.length > 1 || (adjacency.get(scc[0]) ?? []).includes(scc[0])
+  );
+  return cyclicSccs.sort((a, b) => b.length - a.length).map((scc, i) => ({
+    id: `cycle_${i + 1}`,
+    paths: [...scc].sort(),
+    size: scc.length
+  }));
+}
+function inferSectionKind(key) {
+  const k = key.toLowerCase();
+  if (k.includes("baseline")) return "baseline";
+  if (k.includes("routing")) return "routing";
+  if (k.includes("strategy") || k.includes("ai_strat") || k.includes("ai_status") || k.startsWith("ai_")) return "ai";
+  if (k.includes("feature") || k.includes("ui_feature")) return "feature-config";
+  if (k.includes("process") || k.includes("workflow")) return "processes";
+  if (k.includes("widget")) return "widgets";
+  if (k.includes("role") || k.includes("permission")) return "roles";
+  if (k.includes("theme")) return "theme";
+  if (k.includes("metric") || k.includes("telemetry")) return "metrics";
+  if (k.includes("object")) return "objects";
+  if (k.includes("registry") || k.includes("catalog")) return "registry";
+  if (k.includes("milestone") || k.includes("domain") || k.includes("content")) return "content";
+  if (k.includes("system")) return "system";
+  return "unknown";
+}
+function parseConfigLayer(projectRoot) {
+  const relPath = "xampleApp.json";
+  const filePath = join(projectRoot, relPath);
+  if (!existsSync(filePath)) {
+    return {
+      sourcePath: relPath,
+      found: false,
+      fileType: null,
+      appId: null,
+      topLevelKeys: [],
+      sectionCount: 0,
+      sections: []
+    };
+  }
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    const topLevelKeys = Object.keys(raw);
+    const appId = raw.source_app_id ?? raw.appId ?? raw.appid ?? raw.app_id ?? null;
+    const dataObj = typeof raw.data === "object" && raw.data !== null ? raw.data : raw;
+    const sections = [];
+    for (const [key, value] of Object.entries(dataObj)) {
+      if (typeof value !== "object" || value === null) continue;
+      const isArray = Array.isArray(value);
+      const items = isArray ? value : [value];
+      const first = items[0];
+      const sampleKeys = typeof first === "object" && first !== null ? Object.keys(first).slice(0, 5) : [];
+      const label = typeof first === "object" && first !== null ? first.label ?? null : null;
+      sections.push({
+        id: key,
+        label,
+        kind: inferSectionKind(key),
+        itemCount: isArray ? value.length : null,
+        sampleKeys
+      });
+    }
+    return {
+      sourcePath: relPath,
+      found: true,
+      fileType: "json",
+      appId,
+      topLevelKeys,
+      sectionCount: sections.length,
+      sections
+    };
+  } catch {
+    return {
+      sourcePath: relPath,
+      found: true,
+      fileType: "json",
+      appId: null,
+      topLevelKeys: [],
+      sectionCount: 0,
+      sections: []
+    };
+  }
+}
+function inferTableCategory(name) {
+  const n = name.toLowerCase();
+  if (/workspace|member|invite|partnership/.test(n)) return "workspace";
+  if (/^agentic|^ai_|prompt_version|routing_cap|telemetry/.test(n)) return "ai";
+  if (/^system_audit|^system_diff|^system_snap|^system_telem/.test(n)) return "system";
+  if (/diary|^notes$|todo|time_series|image_cache|milestone|chat_feedback/.test(n)) return "content";
+  return "app";
+}
+function parseSchemaLayer(projectRoot) {
+  const relPath = "db.sql";
+  const filePath = join(projectRoot, relPath);
+  if (!existsSync(filePath)) {
+    return {
+      sourcePath: relPath,
+      found: false,
+      fileType: null,
+      tableCount: 0,
+      tables: [],
+      foreignKeys: []
+    };
+  }
+  const sql = readFileSync(filePath, "utf-8");
+  const tables = [];
+  const fkSet = /* @__PURE__ */ new Set();
+  const foreignKeys = [];
+  const tableRe = /CREATE TABLE (\w+)\.(\w+)\s*\(([\s\S]*?)\);/g;
+  let m;
+  while ((m = tableRe.exec(sql)) !== null) {
+    const schema = m[1];
+    const name = m[2];
+    const body = m[3];
+    const columnCount = body.split("\n").filter((l) => {
+      const t = l.trim();
+      return t.length > 0 && /^\w/.test(t) && !t.startsWith("CONSTRAINT");
+    }).length;
+    const hasJsonb = body.includes("jsonb");
+    const fkRe = /REFERENCES\s+(?:\w+\.)?(\w+)\s*\(/g;
+    let fkMatch;
+    let fkCount = 0;
+    while ((fkMatch = fkRe.exec(body)) !== null) {
+      fkCount++;
+      const toTable = fkMatch[1];
+      const key = `${name}\u2192${toTable}`;
+      if (!fkSet.has(key)) {
+        fkSet.add(key);
+        foreignKeys.push({ fromTable: name, toTable });
+      }
+    }
+    tables.push({
+      name,
+      schema,
+      columnCount,
+      hasJsonb,
+      foreignKeyCount: fkCount,
+      category: inferTableCategory(name)
+    });
+  }
+  return {
+    sourcePath: relPath,
+    found: true,
+    fileType: "sql",
+    tableCount: tables.length,
+    tables,
+    foreignKeys
+  };
+}
+function extractControlInventory(content, filePath, jsxComponents, uiPrimitives, eventHandlers) {
+  if (!filePath.endsWith(".tsx")) return null;
+  const items = [];
+  const nativeButtonCount = (content.match(/(?<![a-zA-Z0-9_])<button[\s\/>]/g) ?? []).length;
+  const allInputMatches = content.match(/(?<![a-zA-Z0-9_])<input\b[^>]*/gi) ?? [];
+  const textInputCount = allInputMatches.filter(
+    (m) => !/type\s*=\s*["'](?:checkbox|radio|hidden|file|submit|button|reset|image)/.test(m)
+  ).length;
+  const checkboxCount = allInputMatches.filter((m) => /type\s*=\s*["']checkbox/.test(m)).length;
+  const radioCount = allInputMatches.filter((m) => /type\s*=\s*["']radio/.test(m)).length;
+  const searchInputCount = allInputMatches.filter(
+    (m) => /type\s*=\s*["']search/.test(m) || /placeholder\s*=\s*["'][Ss]earch/.test(m)
+  ).length;
+  const nativeTextareaCount = (content.match(/(?<![a-zA-Z0-9_])<textarea[\s\/>]/g) ?? []).length;
+  const nativeSelectCount = (content.match(/(?<![a-zA-Z0-9_])<select[\s\/>]/g) ?? []).length;
+  const nativeFormCount = (content.match(/(?<![a-zA-Z0-9_])<form[\s\/>]/g) ?? []).length;
+  const jsxButtonCount = jsxComponents.filter((c) => /Button/.test(c)).length;
+  const jsxInputCount = jsxComponents.filter((c) => /^Input$|^TextField$|^TextInput$/.test(c)).length;
+  const jsxSelectCount = jsxComponents.filter((c) => /^Select$|SelectTrigger|SelectContent/.test(c)).length;
+  const jsxTabsCount = jsxComponents.filter((c) => /^Tabs$|^Tab$|TabsList|TabsTrigger/.test(c)).length;
+  const jsxDialogCount = jsxComponents.filter((c) => /Dialog|Modal/.test(c)).length;
+  const jsxToggleCount = jsxComponents.filter((c) => /Switch$|Toggle$|^Checkbox$/.test(c)).length;
+  const jsxTableCount = jsxComponents.filter((c) => /^Table$|DataTable/.test(c)).length;
+  const jsxSearchCount = jsxComponents.filter((c) => /Search|Command/.test(c)).length;
+  const jsxDropdownCount = jsxComponents.filter((c) => /Dropdown|DropdownMenu/.test(c)).length;
+  const totalButtonCount = nativeButtonCount + jsxButtonCount;
+  const totalTextInputCount = textInputCount + jsxInputCount;
+  const totalSelectCount = nativeSelectCount + jsxSelectCount;
+  const totalFormFieldCount = totalTextInputCount + nativeTextareaCount + totalSelectCount;
+  const totalSearchCount = searchInputCount + jsxSearchCount;
+  const hasTabs = jsxTabsCount > 0 || uiPrimitives.includes("Tabs");
+  const hasDialog = jsxDialogCount > 0 || uiPrimitives.includes("Dialog") || uiPrimitives.includes("Modal");
+  const hasTable = jsxTableCount > 0 || uiPrimitives.includes("Table");
+  const hasForm = nativeFormCount > 0 || totalFormFieldCount > 2;
+  if (totalButtonCount > 0) {
+    items.push({ kind: "button", semanticRole: "Action Buttons", count: totalButtonCount, confidence: "certain" });
+  }
+  if (totalTextInputCount > 0) {
+    items.push({ kind: "input", semanticRole: "Input Fields", count: totalTextInputCount, confidence: "certain" });
+  }
+  if (nativeTextareaCount > 0) {
+    items.push({ kind: "textarea", semanticRole: "Text Areas", count: nativeTextareaCount, confidence: "certain" });
+  }
+  if (totalSelectCount > 0) {
+    items.push({ kind: "select", semanticRole: "Select / Dropdown", count: totalSelectCount, confidence: "certain" });
+  }
+  if (checkboxCount > 0) {
+    items.push({ kind: "checkbox", semanticRole: "Checkboxes", count: checkboxCount, confidence: "certain" });
+  }
+  if (radioCount > 0) {
+    items.push({ kind: "radio", semanticRole: "Radio Group", count: radioCount, confidence: "certain" });
+  }
+  if (jsxToggleCount > 0) {
+    items.push({ kind: "toggle", semanticRole: "Toggles / Switches", count: jsxToggleCount, confidence: "certain" });
+  }
+  if (hasTabs) {
+    items.push({ kind: "tabs", semanticRole: "Navigation Tabs", count: jsxTabsCount || 1, confidence: "certain" });
+  }
+  if (hasDialog) {
+    items.push({ kind: "dialog", semanticRole: "Dialog / Modal", count: jsxDialogCount || 1, confidence: "certain" });
+  }
+  if (hasTable) {
+    items.push({ kind: "table", semanticRole: "Data Table", count: jsxTableCount || 1, confidence: "certain" });
+  }
+  if (totalSearchCount > 0) {
+    items.push({ kind: "search", semanticRole: "Search / Filter", count: totalSearchCount, confidence: "certain" });
+  }
+  if (jsxDropdownCount > 0) {
+    items.push({ kind: "dropdown", semanticRole: "Dropdown Menus", count: jsxDropdownCount, confidence: "certain" });
+  }
+  const hasSaveHandler = eventHandlers.some((h) => /save|submit|create/i.test(h));
+  const hasDeleteHandler = eventHandlers.some((h) => /delete|remove|destroy/i.test(h));
+  const hasSearchHandler = eventHandlers.some((h) => /search|filter|query/i.test(h));
+  const hasExportHandler = eventHandlers.some((h) => /export|download/i.test(h));
+  const hasCloseHandler = eventHandlers.some((h) => /close|cancel|dismiss/i.test(h));
+  if (hasSaveHandler && !items.some((i) => i.semanticRole === "Save / Submit")) {
+    items.push({ kind: "button", semanticRole: "Save / Submit", count: 1, confidence: "inferred", hint: "from event handler name" });
+  }
+  if (hasDeleteHandler) {
+    items.push({ kind: "button", semanticRole: "Destructive Action", count: 1, confidence: "inferred", hint: "from event handler name" });
+  }
+  if (hasSearchHandler && !items.some((i) => i.kind === "search")) {
+    items.push({ kind: "search", semanticRole: "Search / Filter", count: 1, confidence: "inferred", hint: "from event handler name" });
+  }
+  if (hasExportHandler) {
+    items.push({ kind: "button", semanticRole: "Export / Download", count: 1, confidence: "inferred", hint: "from event handler name" });
+  }
+  if (hasCloseHandler) {
+    items.push({ kind: "button", semanticRole: "Close / Cancel", count: 1, confidence: "inferred", hint: "from event handler name" });
+  }
+  if (items.length === 0 && totalButtonCount === 0 && totalFormFieldCount === 0) {
+    return null;
+  }
+  return {
+    controls: items,
+    formFieldCount: totalFormFieldCount,
+    actionCount: totalButtonCount,
+    hasSearch: totalSearchCount > 0 || hasSearchHandler,
+    hasTabs,
+    hasTable,
+    hasForm,
+    hasDialog,
+    isInferred: totalButtonCount === 0 && totalFormFieldCount === 0
+  };
+}
+var BUILTIN_HOOKS = /* @__PURE__ */ new Set([
+  "useState",
+  "useEffect",
+  "useMemo",
+  "useCallback",
+  "useRef",
+  "useContext",
+  "useReducer",
+  "useLayoutEffect",
+  "useImperativeHandle",
+  "useDebugValue",
+  "useDeferredValue",
+  "useTransition",
+  "useId",
+  "useSyncExternalStore",
+  "useInsertionEffect",
+  "useFormState",
+  "useFormStatus",
+  "useOptimistic",
+  "useRouter",
+  "usePathname",
+  "useSearchParams",
+  "useParams",
+  "useSelectedLayoutSegments",
+  "useServerInsertedHTML",
+  "useMotionValue",
+  "useTransform",
+  "useAnimate",
+  "useScroll"
+]);
+function inferScreenLabel(filePath, exportNames) {
+  const primaryExport = exportNames.find(
+    (e) => /^[A-Z]/.test(e) && !["metadata", "default", "dynamic", "revalidate"].includes(e)
+  );
+  if (primaryExport) {
+    return primaryExport.replace(/([A-Z])/g, " $1").trim().replace(/\s+/g, " ");
+  }
+  const parts = filePath.split("/").filter(
+    (p) => !["app", "page.tsx", "layout.tsx", "route.ts", "loading.tsx", "error.tsx"].includes(p)
+  );
+  const label = parts.filter((p) => !p.startsWith("[") && !p.startsWith("(")).pop();
+  if (label) return label.charAt(0).toUpperCase() + label.slice(1).replace(/-/g, " ");
+  return "Page";
+}
+function inferScreenKind(label, filePath, jsxComponents, uiPrimitives) {
+  const l = label.toLowerCase();
+  const p = filePath.toLowerCase();
+  const j = jsxComponents.map((c) => c.toLowerCase()).join(" ");
+  if (l.includes("recovery") || p.includes("recovery")) return "recovery";
+  if (l.includes("admin") || p.includes("admin/")) return "admin";
+  if (l.includes("dashboard") || j.includes("dashboard") || j.includes("overview")) return "dashboard";
+  if (l.includes("chat") || j.includes("chat")) return "chat";
+  if (l.includes("builder") || j.includes("builder") || j.includes("wizard")) return "builder";
+  if (l.includes("profile") || j.includes("profile")) return "profile";
+  if (l.includes("settings") || l.includes("config")) return "settings";
+  if (l.includes("list") || j.includes("table") || j.includes("list")) return "list";
+  if (l.includes("form") || uiPrimitives.includes("Form") || uiPrimitives.includes("Input")) return "form";
+  if (l.includes("detail") || l.includes("view")) return "detail";
+  if (p.includes("page.tsx")) return "page";
+  if (p.includes("layout.tsx")) return "layout";
+  if (/^[A-Z]/.test(filePath.split("/").pop() ?? "")) return "component";
+  return "unknown";
+}
+function inferUiPatterns(jsxComponents, uiPrimitives) {
+  const patterns = /* @__PURE__ */ new Set();
+  const j = jsxComponents.map((c) => c.toLowerCase()).join(" ");
+  const u = uiPrimitives.map((p) => p.toLowerCase());
+  if (u.includes("form") || j.includes("form")) patterns.add("form");
+  if (u.includes("table") || j.includes("table")) patterns.add("data-table");
+  if (u.includes("tabs") || j.includes("tabs") || j.includes("tab")) patterns.add("tabbed-layout");
+  if (u.includes("card")) patterns.add("card-grid");
+  if (u.includes("modal") || u.includes("dialog")) patterns.add("modal-flow");
+  if (j.includes("chat") || j.includes("message")) patterns.add("chat");
+  if (j.includes("dashboard") || j.includes("panel") || j.includes("widget")) patterns.add("dashboard");
+  if (j.includes("wizard") || j.includes("step")) patterns.add("wizard");
+  if (j.includes("timeline") || j.includes("history")) patterns.add("timeline");
+  if (u.includes("drawer") || u.includes("sheet")) patterns.add("drawer-layout");
+  if (j.includes("editor") || j.includes("monaco") || j.includes("codemirror")) patterns.add("code-editor");
+  if (j.includes("chart") || j.includes("graph") || j.includes("metric")) patterns.add("chart");
+  return [...patterns];
+}
+function extractCustomHooks(content) {
+  const hooks = /* @__PURE__ */ new Set();
+  const re = /\buse([A-Z][A-Za-z]+)\s*(?:<[^>]*>)?\s*\(/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    const full = "use" + m[1];
+    if (!BUILTIN_HOOKS.has(full)) hooks.add(full);
+  }
+  return [...hooks].slice(0, 10);
+}
+function extractEventHandlers(content) {
+  const handlers = /* @__PURE__ */ new Set();
+  const re = /\bhandle[A-Z][A-Za-z]+\b/g;
+  let m;
+  while ((m = re.exec(content)) !== null) handlers.add(m[0]);
+  return [...handlers].slice(0, 8);
+}
+function extractDataSources(content) {
+  const sources = /* @__PURE__ */ new Set();
+  if (/supabase\.from\(/.test(content)) sources.add("supabase");
+  if (/\bfetch\s*\(|axios\.|\.get\s*\(|\.post\s*\(/.test(content)) sources.add("http-fetch");
+  if (/\buseRouter\b|\busePathname\b|\buseSearchParams\b/.test(content)) sources.add("router");
+  if (/\buseContext\s*\(/.test(content)) sources.add("context");
+  if (/localStorage|sessionStorage/.test(content)) sources.add("local-storage");
+  if (/new\s+Anthropic\b|@anthropic-ai/.test(content)) sources.add("anthropic-ai");
+  if (/new\s+OpenAI\b/.test(content)) sources.add("openai");
+  if (/GoogleGenerativeAI/.test(content)) sources.add("google-ai");
+  if (/\.subscribe\(|new WebSocket\(/.test(content)) sources.add("subscription");
+  return [...sources];
+}
+function extractScreenInfo(content, filePath, exportNames, jsxComponents, uiPrimitives, nextFileKind) {
+  if (!filePath.endsWith(".tsx")) return null;
+  const label = inferScreenLabel(filePath, exportNames);
+  const screenKind = inferScreenKind(label, filePath, jsxComponents, uiPrimitives);
+  const uiPatterns = inferUiPatterns(jsxComponents, uiPrimitives);
+  const customHooks = extractCustomHooks(content);
+  const eventHandlers = extractEventHandlers(content);
+  const dataSources = extractDataSources(content);
+  return { label, screenKind, uiPatterns, customHooks, eventHandlers, dataSources };
+}
+var CONFIG_SECTION_KEYWORDS = {
+  system_baseline: ["baseline", "engine", "service"],
+  routing_capabilities: ["routing", "router", "capability"],
+  ai_strategy_master: ["strategy", "knowledge", "master"],
+  ai_status: ["model", "provider", "aistatus"],
+  ui_features: ["feature", "uifeature", "slider"],
+  domain_milestones: ["milestone", "domain"]
+};
+function tableToKeywords(tableName) {
+  const parts = tableName.split("_").filter((p) => p.length >= 3);
+  const kws = new Set(parts);
+  for (const part of parts) {
+    if (part.endsWith("ies") && part.length > 5) {
+      kws.add(part.slice(0, -3) + "y");
+    } else if (part.endsWith("s") && !part.endsWith("ss") && part.length > 4) {
+      kws.add(part.slice(0, -1));
+    }
+  }
+  return [...kws];
+}
+function scoreFileForMatch(file, keywords) {
+  const pathLow = file.path.toLowerCase();
+  const docLow = [file.docSummary, file.docBlock].filter(Boolean).join(" ").toLowerCase();
+  const exportsLow = file.exports.map((e) => e.toLowerCase());
+  const importsLow = file.imports.map((i) => i.toLowerCase());
+  function pathHits(kw) {
+    const k = kw.toLowerCase();
+    if (k.length <= 4) {
+      return pathLow.split(/[\/\-_\.]/g).some((seg) => seg === k);
+    }
+    return pathLow.includes(k);
+  }
+  let score = 0;
+  const reasons = [];
+  const pathKws = keywords.filter(pathHits);
+  if (pathKws.length > 0) {
+    score += 0.4;
+    reasons.push(`path: ${pathKws.slice(0, 2).join(", ")}`);
+  }
+  const expKws = keywords.filter(
+    (kw) => exportsLow.some((e) => e.includes(kw.toLowerCase()))
+  );
+  if (expKws.length > 0) {
+    const matched = file.exports.filter((e) => expKws.some((k) => e.toLowerCase().includes(k))).slice(0, 2);
+    score += 0.3;
+    reasons.push(`exports: ${matched.join(", ")}`);
+  }
+  if (docLow.length > 0) {
+    const docKws = keywords.filter(
+      (kw) => kw.length >= 4 && docLow.includes(kw.toLowerCase())
+    );
+    if (docKws.length > 0) {
+      score += 0.2;
+      reasons.push(`doc: ${docKws.slice(0, 2).join(", ")}`);
+    }
+  }
+  const impKws = keywords.filter(
+    (kw) => kw.length >= 4 && importsLow.some((i) => i.includes(kw.toLowerCase()))
+  );
+  if (impKws.length > 0) {
+    score += 0.1;
+    reasons.push(`imports: ${impKws.slice(0, 1).join(", ")}`);
+  }
+  return { score: Math.min(1, Math.round(score * 100) / 100), reasons };
+}
+function buildConfigToCode(configLayer, entries) {
+  if (!configLayer.found) return [];
+  return configLayer.sections.map((section) => {
+    const idParts = section.id.split("_").filter((p) => p.length >= 3);
+    const curated = CONFIG_SECTION_KEYWORDS[section.id] ?? [];
+    const keywords = [.../* @__PURE__ */ new Set([...idParts, ...curated])];
+    const matchedFiles = entries.map((file) => {
+      const { score, reasons } = scoreFileForMatch(file, keywords);
+      return { path: file.path, score, reasons };
+    }).filter((m) => m.score >= 0.3 && m.reasons.length > 0).sort((a, b) => b.score - a.score).slice(0, 5);
+    return { configId: section.id, configKind: section.kind, matchedFiles };
+  });
+}
+function buildSchemaToCode(schemaLayer, entries) {
+  if (!schemaLayer.found) return [];
+  return schemaLayer.tables.map((table) => {
+    const keywords = tableToKeywords(table.name);
+    const matchedFiles = entries.map((file) => {
+      const { score, reasons } = scoreFileForMatch(file, keywords);
+      return { path: file.path, score, reasons };
+    }).filter((m) => m.score >= 0.3 && m.reasons.length > 0).sort((a, b) => b.score - a.score).slice(0, 5);
+    return { tableName: table.name, category: table.category, matchedFiles };
+  });
+}
+function inferSymbolKind(name, baseKind) {
+  if (/^use[A-Z]/.test(name)) return "hook";
+  if (/^[A-Z]/.test(name)) return "component";
+  return baseKind;
+}
+function extractDocForLine(lines, lineIndex) {
+  let i = lineIndex - 1;
+  while (i >= 0 && lines[i].trim() === "") i--;
+  if (i < 0 || !lines[i].trim().endsWith("*/")) return null;
+  const blockEnd = i;
+  while (i > 0 && !lines[i].trim().startsWith("/**")) i--;
+  if (!lines[i].trim().startsWith("/**")) return null;
+  const cleaned = lines.slice(i, blockEnd + 1).join("\n").replace(/^\/\*+/, "").replace(/\*+\/$/, "").split("\n").map((l) => l.replace(/^\s*\*\s?/, "").trim()).filter((l) => l.length > 0 && !l.startsWith("@")).join(" ").trim();
+  return cleaned.slice(0, 200) || null;
+}
+function extractSymbolSummaries(content) {
+  const results = [];
+  const lines = content.split("\n");
+  const patterns = [
+    [/^export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)/, null, true],
+    [/^export\s+const\s+(\w+)\s*=/, null, true],
+    [/^export\s+(?:type|interface)\s+(\w+)[\s{<]/, "type", true],
+    [/^export\s+(?:default\s+)?class\s+(\w+)/, "component", true],
+    [/^(?:async\s+)?function\s+(use[A-Z]\w+)\s*\(/, "hook", false]
+  ];
+  for (let i = 0; i < lines.length && results.length < 10; i++) {
+    const line = lines[i].trimStart();
+    for (const [re, forcedKind, exported] of patterns) {
+      const m = re.exec(line);
+      if (!m) continue;
+      const name = m[1];
+      const baseKind = line.includes("function") ? "function" : "const";
+      const kind = forcedKind ?? inferSymbolKind(name, baseKind);
+      const doc = extractDocForLine(lines, i);
+      results.push({ name, kind, exported, doc });
+      break;
+    }
+  }
+  return results;
+}
+function extractAdditionalDocBlocks(content, primaryDocBlock) {
+  const blocks = [];
+  const re = /\/\*\*([\s\S]*?)\*\//g;
+  let m;
+  while ((m = re.exec(content)) !== null && blocks.length < 4) {
+    const cleaned = m[1].split("\n").map((l) => l.replace(/^\s*\*\s?/, "").trim()).filter((l) => l.length > 0 && !l.startsWith("@")).join("\n").trim();
+    if (cleaned.length > 15 && cleaned !== primaryDocBlock) {
+      blocks.push(cleaned.slice(0, 200));
+    }
+  }
+  return blocks;
+}
+function extractCodeSnippets(content, configSectionIds, tableNames) {
+  const snippets = [];
+  const lines = content.split("\n");
+  const MAX_CHARS = 300;
+  const take = (start, n) => lines.slice(start, start + n).map((l) => l.trim()).filter((l) => l.length > 0).slice(0, n).join("\n").slice(0, MAX_CHARS);
+  const exportRe = /^export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const)\s+(\w+)/;
+  const exportIdx = lines.findIndex((l) => exportRe.test(l.trimStart()));
+  if (exportIdx >= 0) {
+    const m = exportRe.exec(lines[exportIdx].trimStart());
+    const name = m?.[1] ?? "export";
+    snippets.push({
+      label: name,
+      kind: /^[A-Z]/.test(name) ? "component" : "function",
+      snippet: take(exportIdx, 5)
+    });
+  }
+  const dbIdx = lines.findIndex((l) => /\.from\(['"][\w_]+['"]\)/.test(l));
+  if (dbIdx >= 0) {
+    const tbl = lines[dbIdx].match(/\.from\(['"](\w+)['"]\)/)?.[1];
+    snippets.push({
+      label: tbl ? `query: ${tbl}` : "db query",
+      kind: "query",
+      snippet: take(Math.max(0, dbIdx - 1), 5)
+    });
+  }
+  for (const id of configSectionIds) {
+    const idx = lines.findIndex(
+      (l) => l.includes(`'${id}'`) || l.includes(`"${id}"`)
+    );
+    if (idx >= 0) {
+      snippets.push({
+        label: `config: ${id}`,
+        kind: "config-usage",
+        snippet: take(Math.max(0, idx - 1), 4)
+      });
+      break;
+    }
+  }
+  if (!snippets.some((s) => s.kind === "query")) {
+    for (const name of tableNames) {
+      const idx = lines.findIndex(
+        (l) => l.includes(`'${name}'`) || l.includes(`"${name}"`)
+      );
+      if (idx >= 0) {
+        snippets.push({
+          label: `table: ${name}`,
+          kind: "table-usage",
+          snippet: take(Math.max(0, idx - 1), 4)
+        });
+        break;
+      }
+    }
+  }
+  return snippets.slice(0, 4);
+}
+function extractExplainability(content, primaryDocBlock, configSectionIds, tableNames) {
+  const docBlocks = extractAdditionalDocBlocks(content, primaryDocBlock);
+  const symbolSummaries = extractSymbolSummaries(content);
+  const codeSnippets = extractCodeSnippets(content, configSectionIds, tableNames);
+  const matchedConfigIdsInCode = configSectionIds.filter(
+    (id) => content.includes(`'${id}'`) || content.includes(`"${id}"`)
+  );
+  const matchedTableNamesInCode = tableNames.filter((name) => {
+    if (content.includes(`.from('${name}')`) || content.includes(`.from("${name}")`))
+      return true;
+    return content.includes(`'${name}'`) || content.includes(`"${name}"`);
+  });
+  return {
+    primaryDocBlock,
+    docBlocks,
+    symbolSummaries,
+    codeSnippets,
+    matchedConfigIdsInCode,
+    matchedTableNamesInCode
+  };
+}
+function extractJsdocTags(content) {
+  const result = {};
+  const SKIP_TAGS = /* @__PURE__ */ new Set(["amber-capability", "amber-doc"]);
+  const MAX_TAG_NAMES = 5;
+  const MAX_VALUES_PER_TAG = 3;
+  const blockRe = /\/\*\*[\s\S]*?\*\//g;
+  let blockMatch;
+  while ((blockMatch = blockRe.exec(content)) !== null) {
+    const block = blockMatch[0];
+    const lineRe = /\*[^\S\n]+@(\w+)[^\S\n]*(.*)/g;
+    let lineMatch;
+    while ((lineMatch = lineRe.exec(block)) !== null) {
+      const tagName = lineMatch[1];
+      const tagValue = lineMatch[2].trim();
+      if (SKIP_TAGS.has(tagName)) continue;
+      if (!Object.prototype.hasOwnProperty.call(result, tagName)) {
+        if (Object.keys(result).length >= MAX_TAG_NAMES) continue;
+        result[tagName] = [];
+      }
+      if (result[tagName].length < MAX_VALUES_PER_TAG) {
+        result[tagName].push(tagValue);
+      }
+    }
+  }
+  return result;
+}
+function collectMarkdownDocs(projectRoot) {
+  const IGNORE = ["**/node_modules/**", "**/.next/**", "**/build/**", "**/dist/**", "**/.git/**"];
+  const SIZE_CAP = 5e4;
+  const TOTAL_BUDGET = 5e5;
+  const MAX_HEADINGS = 30;
+  let files;
+  try {
+    files = fg.sync("**/*.md", { cwd: projectRoot, ignore: IGNORE, onlyFiles: true, absolute: false });
+  } catch {
+    return [];
+  }
+  const docs = [];
+  let totalChars = 0;
+  for (const relPath of files.sort()) {
+    if (totalChars >= TOTAL_BUDGET) break;
+    const fullPath = join(projectRoot, relPath);
+    let content;
+    try {
+      content = readFileSync(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.length > SIZE_CAP) continue;
+    totalChars += content.length;
+    const lines = content.split("\n");
+    let title = null;
+    for (const line of lines) {
+      const m = line.match(/^#\s+(.+)/);
+      if (m) {
+        title = m[1].trim();
+        break;
+      }
+    }
+    if (!title) title = basename(relPath, ".md");
+    const headingTree = [];
+    for (const line of lines) {
+      if (/^#{1,6}\s+.+/.test(line)) {
+        headingTree.push(line.trimEnd());
+        if (headingTree.length >= MAX_HEADINGS) break;
+      }
+    }
+    let lastModified;
+    try {
+      lastModified = statSync(fullPath).mtime.toISOString();
+    } catch {
+      lastModified = (/* @__PURE__ */ new Date(0)).toISOString();
+    }
+    docs.push({
+      path: relPath,
+      title,
+      headingTree,
+      loc: lines.length,
+      lastModified
+    });
+  }
+  return docs;
+}
+function collectRecentCommits(projectRoot) {
+  const MAX_COMMITS = 5e3;
+  let logOutput;
+  try {
+    logOutput = execSync('git log --since="180 days ago" --pretty=format:"%h|%aI|%s" -- .', {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return [];
+  }
+  const lines = logOutput.split("\n").map((l) => l.trim()).filter(Boolean);
+  const commits = [];
+  for (const line of lines.slice(0, MAX_COMMITS)) {
+    const pipeIdx1 = line.indexOf("|");
+    if (pipeIdx1 === -1) continue;
+    const pipeIdx2 = line.indexOf("|", pipeIdx1 + 1);
+    if (pipeIdx2 === -1) continue;
+    const sha = line.slice(0, pipeIdx1);
+    const date = line.slice(pipeIdx1 + 1, pipeIdx2);
+    const subject = line.slice(pipeIdx2 + 1);
+    let files = [];
+    let insertions = 0;
+    let deletions = 0;
+    try {
+      const statOutput = execSync(`git show --stat --format="" ${sha}`, {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const statLines = statOutput.split("\n").map((l) => l.trim()).filter(Boolean);
+      for (const statLine of statLines) {
+        const summaryMatch = statLine.match(/(\d+)\s+files?\s+changed(?:,\s*(\d+)\s+insertions?\(\+\))?(?:,\s*(\d+)\s+deletions?\(-\))?/);
+        if (summaryMatch) {
+          insertions = parseInt(summaryMatch[2] ?? "0", 10);
+          deletions = parseInt(summaryMatch[3] ?? "0", 10);
+          continue;
+        }
+        const fileMatch = statLine.match(/^(.+?)\s+\|/);
+        if (fileMatch) {
+          files.push(fileMatch[1].trim());
+        }
+      }
+    } catch {
+    }
+    commits.push({ sha, date, subject, files, insertions, deletions });
+  }
+  return commits;
+}
+function buildFileCommitStats(commits, now) {
+  const map = /* @__PURE__ */ new Map();
+  const MS_90D = 90 * 24 * 60 * 60 * 1e3;
+  const MS_180D = 180 * 24 * 60 * 60 * 1e3;
+  const nowMs = now.getTime();
+  for (const commit of commits) {
+    const commitMs = new Date(commit.date).getTime();
+    const age = nowMs - commitMs;
+    const in90 = age <= MS_90D;
+    const in180 = age <= MS_180D;
+    for (const filePath of commit.files) {
+      if (!map.has(filePath)) {
+        map.set(filePath, { count_90d: 0, count_180d: 0, subjects_180d: [] });
+      }
+      const stats = map.get(filePath);
+      if (in90) stats.count_90d++;
+      if (in180) {
+        stats.count_180d++;
+        if (stats.subjects_180d.length < 5) {
+          stats.subjects_180d.push(commit.subject);
+        }
+      }
+    }
+  }
+  return map;
+}
+function buildRecentTodos(entries) {
+  const result = [];
+  for (const entry of entries) {
+    const tags = entry.jsdocTags ?? {};
+    const todos = tags["todo"] ?? [];
+    for (const text of todos) {
+      result.push({ path: entry.path, text });
+    }
+  }
+  return result;
+}
+function buildDeprecatedSurface(entries) {
+  const result = [];
+  for (const entry of entries) {
+    const tags = entry.jsdocTags ?? {};
+    const deprecatedValues = tags["deprecated"] ?? [];
+    if (deprecatedValues.length > 0) {
+      result.push({ path: entry.path, reason: deprecatedValues[0] ?? "" });
+    }
+  }
+  return result;
+}
+async function main() {
+  const projectRoot = process.cwd();
+  const coverageMap = (() => {
+    const coveragePath = join(projectRoot, "coverage", "coverage-summary.json");
+    if (!existsSync(coveragePath)) return /* @__PURE__ */ new Map();
+    try {
+      const raw = JSON.parse(readFileSync(coveragePath, "utf-8"));
+      const map = parseCoverageSummary(raw, projectRoot);
+      console.log(`  coverage: ${map.size} files with coverage data`);
+      return map;
+    } catch {
+      console.warn("  coverage: could not parse coverage-summary.json \u2014 coverage will be absent");
+      return /* @__PURE__ */ new Map();
+    }
+  })();
+  const churnMap = (() => {
+    try {
+      const out = execSync('git log --since="90 days ago" --pretty=format: --name-only', {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const map = /* @__PURE__ */ new Map();
+      for (const line of out.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed) map.set(trimmed, (map.get(trimmed) ?? 0) + 1);
+      }
+      return map;
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  })();
+  const aliases = readTsConfigPaths(projectRoot);
+  console.log(`
+tsconfig paths loaded:`);
+  console.log(`  baseUrl : ${aliases.baseUrl}`);
+  console.log(`  aliases : ${JSON.stringify(aliases.paths)}`);
+  const configLayer = parseConfigLayer(projectRoot);
+  const schemaLayer = parseSchemaLayer(projectRoot);
+  const configSectionIds = configLayer.sections.map((s2) => s2.id);
+  const tableNames = schemaLayer.tables.map((t) => t.name);
+  const markdownDocs = collectMarkdownDocs(projectRoot);
+  const recentCommits = collectRecentCommits(projectRoot);
+  const fileCommitStatsMap = buildFileCommitStats(recentCommits, /* @__PURE__ */ new Date());
+  const files = await fg.glob([...blueprintConfig.include], {
+    ignore: [...blueprintConfig.exclude],
+    onlyFiles: true
+  });
+  const scopeSet = new Set(files.map(normalize));
+  const entries = [];
+  for (const filePath of files) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const rawImports = extractImports(content);
+      const usageMap = classifyImports(content);
+      const resolvedImportMap = rawImports.map(
+        (specifier) => ({
+          ...resolveImport(specifier, filePath, projectRoot, scopeSet, aliases),
+          importUsage: usageMap.get(specifier) ?? "runtime"
+        })
+      );
+      const internalImports = [
+        ...new Set(
+          resolvedImportMap.filter((r) => r.kind === "internal" && r.resolvedPath !== null).map((r) => r.resolvedPath)
+        )
+      ];
+      const runtimeInternalImports = [
+        ...new Set(
+          resolvedImportMap.filter(
+            (r) => r.kind === "internal" && r.resolvedPath !== null && r.importUsage === "runtime"
+          ).map((r) => r.resolvedPath)
+        )
+      ];
+      const typeOnlyInternalImports = [
+        ...new Set(
+          resolvedImportMap.filter(
+            (r) => r.kind === "internal" && r.resolvedPath !== null && r.importUsage === "type-only"
+          ).map((r) => r.resolvedPath)
+        )
+      ];
+      const externalImports = [
+        ...new Set(
+          resolvedImportMap.filter((r) => r.kind === "external").map((r) => r.source)
+        )
+      ];
+      const { docSummary, docBlock } = extractDocInfo(content);
+      const { hasUseClient, hasUseServer } = detectDirectives(content);
+      const nextFileKind = getNextFileKind(filePath);
+      const { jsxComponents, uiPrimitives, componentUsageCount, topLevelJsxBlocks } = extractJsxInfo(content, filePath);
+      const stateComplexity = extractStateComplexity(content, filePath);
+      const controlInventory = extractControlInventory(
+        content,
+        filePath,
+        jsxComponents,
+        uiPrimitives,
+        extractEventHandlers(content)
+      );
+      const screenInfo = extractScreenInfo(
+        content,
+        filePath,
+        extractExports(content),
+        // re-use extracted exports
+        jsxComponents,
+        uiPrimitives,
+        nextFileKind
+      );
+      const explainability = extractExplainability(
+        content,
+        docBlock,
+        configSectionIds,
+        tableNames
+      );
+      entries.push({
+        id: makeId(filePath),
+        path: filePath,
+        category: getCategory(filePath),
+        loc: content.split("\n").length,
+        imports: rawImports,
+        exports: extractExports(content),
+        hasJsDoc: detectJsDoc(content),
+        docSummary,
+        docBlock,
+        renderEnvironment: getRenderEnvironment(
+          filePath,
+          hasUseClient,
+          hasUseServer
+        ),
+        nextFileKind,
+        routePath: deriveRoutePath(filePath),
+        hasUseClientDirective: hasUseClient,
+        hasUseServerDirective: hasUseServer,
+        isApiRoute: filePath.startsWith("app/") && nextFileKind === "route",
+        isCyclic: false,
+        cycleGroupId: null,
+        jsxComponents,
+        uiPrimitives,
+        componentUsageCount,
+        topLevelJsxBlocks,
+        metrics: {
+          loc: content.split("\n").length,
+          incomingRuntimeDeps: 0,
+          outgoingRuntimeDeps: runtimeInternalImports.length,
+          jsxComponentCount: jsxComponents.length,
+          uiPrimitiveCount: uiPrimitives.length,
+          complexityScore: null,
+          duplicationScore: null,
+          heatScore: 0
+        },
+        stateComplexity,
+        controlInventory,
+        screenInfo,
+        explainability,
+        coverage: lookupCoverage(coverageMap, filePath),
+        churn: churnMap.get(filePath) ?? void 0,
+        jsdocTags: extractJsdocTags(content),
+        commitStats: fileCommitStatsMap.get(filePath) ?? void 0,
+        relatedConfigIds: [],
+        // populated after cross-reference computation
+        relatedTableNames: [],
+        // populated after cross-reference computation
+        internalImports,
+        externalImports,
+        runtimeInternalImports,
+        typeOnlyInternalImports,
+        incomingInternalDependencies: [],
+        outgoingInternalDependencies: internalImports,
+        resolvedImportMap
+      });
+    } catch {
+      console.warn(`Skipping unreadable file: ${filePath}`);
+    }
+  }
+  const incomingMap = new Map(
+    entries.map((e) => [e.path, []])
+  );
+  for (const entry of entries) {
+    for (const internalPath of entry.internalImports) {
+      const arr = incomingMap.get(internalPath);
+      if (arr && !arr.includes(entry.path)) arr.push(entry.path);
+    }
+  }
+  for (const entry of entries) {
+    entry.incomingInternalDependencies = incomingMap.get(entry.path) ?? [];
+  }
+  const runtimeIncomingCounts = new Map(
+    entries.map((e) => [e.path, 0])
+  );
+  for (const entry of entries) {
+    for (const p of entry.runtimeInternalImports) {
+      runtimeIncomingCounts.set(p, (runtimeIncomingCounts.get(p) ?? 0) + 1);
+    }
+  }
+  const maxLoc = Math.max(...entries.map((e) => e.loc), 1);
+  const maxIncoming = Math.max(
+    ...entries.map((e) => runtimeIncomingCounts.get(e.path) ?? 0),
+    1
+  );
+  const maxOutgoing = Math.max(
+    ...entries.map((e) => e.runtimeInternalImports.length),
+    1
+  );
+  const maxJsx = Math.max(...entries.map((e) => e.jsxComponents.length), 1);
+  const maxUi = Math.max(...entries.map((e) => e.uiPrimitives.length), 1);
+  for (const entry of entries) {
+    const inc = runtimeIncomingCounts.get(entry.path) ?? 0;
+    const out = entry.runtimeInternalImports.length;
+    const jsx = entry.jsxComponents.length;
+    const ui = entry.uiPrimitives.length;
+    const raw = 0.25 * (entry.loc / maxLoc) + 0.35 * (inc / maxIncoming) + 0.15 * (out / maxOutgoing) + 0.15 * (jsx / maxJsx) + 0.1 * (ui / maxUi);
+    entry.metrics = {
+      loc: entry.loc,
+      incomingRuntimeDeps: inc,
+      outgoingRuntimeDeps: out,
+      jsxComponentCount: jsx,
+      uiPrimitiveCount: ui,
+      complexityScore: null,
+      duplicationScore: null,
+      heatScore: Math.round(raw * 1e3) / 10
+    };
+  }
+  const allImportsAdj = new Map(
+    entries.map((e) => [e.path, e.internalImports])
+  );
+  const preFilterGroups = extractCycleGroups(
+    tarjanSCC(allImportsAdj),
+    allImportsAdj
+  );
+  const runtimeAdj = new Map(
+    entries.map((e) => [e.path, e.runtimeInternalImports])
+  );
+  const cycleGroups = extractCycleGroups(tarjanSCC(runtimeAdj), runtimeAdj);
+  const cyclesEliminatedByTypeImportFiltering = preFilterGroups.length - cycleGroups.length;
+  const pathToCycleGroupId = /* @__PURE__ */ new Map();
+  for (const group of cycleGroups) {
+    for (const p of group.paths) pathToCycleGroupId.set(p, group.id);
+  }
+  for (const entry of entries) {
+    entry.isCyclic = pathToCycleGroupId.has(entry.path);
+    entry.cycleGroupId = pathToCycleGroupId.get(entry.path) ?? null;
+  }
+  const filesInCycles = [...pathToCycleGroupId.keys()].sort();
+  const largestCycleSize = cycleGroups[0]?.size ?? 0;
+  const analysis = {
+    hasCycles: cycleGroups.length > 0,
+    cycleCount: cycleGroups.length,
+    stronglyConnectedComponents: cycleGroups,
+    filesInCycles,
+    cyclesEliminatedByTypeImportFiltering
+  };
+  const nodes = entries.map((e) => ({
+    id: e.id,
+    path: e.path,
+    category: e.category,
+    loc: e.loc,
+    hasJsDoc: e.hasJsDoc,
+    label: basename(e.path)
+  }));
+  const idByPath = new Map(entries.map((e) => [e.path, e.id]));
+  const edgeSet = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const entry of entries) {
+    for (const internalPath of entry.runtimeInternalImports) {
+      const targetId = idByPath.get(internalPath);
+      if (!targetId) continue;
+      const key = `${entry.id}:${targetId}`;
+      if (!edgeSet.has(key)) {
+        edgeSet.add(key);
+        edges.push({ source: entry.id, target: targetId, type: "import" });
+      }
+    }
+  }
+  const totalInternal = entries.reduce(
+    (sum, f) => sum + f.internalImports.length,
+    0
+  );
+  const totalExternal = entries.reduce(
+    (sum, f) => sum + f.externalImports.length,
+    0
+  );
+  const totalRuntimeInternal = entries.reduce(
+    (sum, f) => sum + f.runtimeInternalImports.length,
+    0
+  );
+  const totalTypeOnlyInternal = entries.reduce(
+    (sum, f) => sum + f.typeOnlyInternalImports.length,
+    0
+  );
+  const importCounts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const internalPath of entry.runtimeInternalImports) {
+      importCounts.set(internalPath, (importCounts.get(internalPath) ?? 0) + 1);
+    }
+  }
+  const mostImportedFiles = [...importCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([path, count]) => ({ path, count }));
+  const primitiveCount = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const prim of entry.uiPrimitives) {
+      primitiveCount.set(prim, (primitiveCount.get(prim) ?? 0) + 1);
+    }
+  }
+  const mostUsedUiPrimitives = [...primitiveCount.entries()].sort((a, b) => b[1] - a[1]).map(([name, count]) => ({ name, count }));
+  const hottestFiles2 = [...entries].sort((a, b) => b.metrics.heatScore - a.metrics.heatScore).slice(0, 15).map((e) => ({ path: e.path, heatScore: e.metrics.heatScore }));
+  const categoryGroups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const scores = categoryGroups.get(entry.category) ?? [];
+    scores.push(entry.metrics.heatScore);
+    categoryGroups.set(entry.category, scores);
+  }
+  const categoryHeat = [...categoryGroups.entries()].map(([category, scores]) => ({
+    category,
+    averageHeat: Math.round(
+      scores.reduce((a, b) => a + b, 0) / scores.length * 10
+    ) / 10,
+    fileCount: scores.length
+  })).sort((a, b) => b.averageHeat - a.averageHeat);
+  const heatmap = { hottestFiles: hottestFiles2, categoryHeat };
+  const configToCode = buildConfigToCode(configLayer, entries);
+  const schemaToCode = buildSchemaToCode(schemaLayer, entries);
+  const fileConfigIds = /* @__PURE__ */ new Map();
+  const fileTableNames = /* @__PURE__ */ new Map();
+  for (const link of configToCode) {
+    for (const m of link.matchedFiles) {
+      const arr = fileConfigIds.get(m.path) ?? [];
+      if (!arr.includes(link.configId)) arr.push(link.configId);
+      fileConfigIds.set(m.path, arr);
+    }
+  }
+  for (const link of schemaToCode) {
+    for (const m of link.matchedFiles) {
+      const arr = fileTableNames.get(m.path) ?? [];
+      if (!arr.includes(link.tableName)) arr.push(link.tableName);
+      fileTableNames.set(m.path, arr);
+    }
+  }
+  for (const entry of entries) {
+    entry.relatedConfigIds = fileConfigIds.get(entry.path) ?? [];
+    entry.relatedTableNames = fileTableNames.get(entry.path) ?? [];
+  }
+  const crossReferences = { configToCode, schemaToCode };
+  const configCodeLinkCount = configToCode.reduce(
+    (s2, c) => s2 + c.matchedFiles.length,
+    0
+  );
+  const schemaCodeLinkCount = schemaToCode.reduce(
+    (s2, c) => s2 + c.matchedFiles.length,
+    0
+  );
+  const routesDiscovered = [
+    ...new Set(
+      entries.filter(
+        (f) => f.routePath !== null && (f.nextFileKind === "page" || f.nextFileKind === "route")
+      ).map((f) => f.routePath)
+    )
+  ].sort();
+  const output = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      fileCount: entries.length,
+      pageCount: entries.filter((f) => f.category === "app").length,
+      componentCount: entries.filter((f) => f.category === "component").length,
+      libCount: entries.filter((f) => f.category === "lib").length,
+      hookCount: entries.filter((f) => f.category === "hook").length,
+      internalDependencyCount: totalInternal,
+      externalDependencyCount: totalExternal,
+      runtimeInternalDependencyCount: totalRuntimeInternal,
+      typeOnlyInternalDependencyCount: totalTypeOnlyInternal,
+      nodeCount: nodes.length,
+      edgeCount: edges.length,
+      mostImportedFiles,
+      clientFileCount: entries.filter((f) => f.renderEnvironment === "client").length,
+      serverFileCount: entries.filter((f) => f.renderEnvironment === "server").length,
+      pageFileCount: entries.filter((f) => f.nextFileKind === "page").length,
+      routeFileCount: entries.filter((f) => f.nextFileKind === "route").length,
+      routesDiscovered,
+      cyclicFileCount: filesInCycles.length,
+      stronglyConnectedComponentCount: cycleGroups.length,
+      largestCycleSize,
+      tsxFileCount: entries.filter((f) => f.path.endsWith(".tsx")).length,
+      filesWithJsxComponents: entries.filter((f) => f.jsxComponents.length > 0).length,
+      filesWithUiPrimitives: entries.filter((f) => f.uiPrimitives.length > 0).length,
+      mostUsedUiPrimitives,
+      configSectionCount: configLayer.sectionCount,
+      sqlTableCount: schemaLayer.tableCount,
+      sqlForeignKeyCount: schemaLayer.foreignKeys.length,
+      configCodeLinkCount,
+      schemaCodeLinkCount,
+      filesWithExplainability: entries.filter(
+        (f) => f.explainability.symbolSummaries.length > 0 || f.explainability.primaryDocBlock !== null
+      ).length,
+      filesWithTableStringMatches: entries.filter(
+        (f) => f.explainability.matchedTableNamesInCode.length > 0
+      ).length,
+      filesWithConfigStringMatches: entries.filter(
+        (f) => f.explainability.matchedConfigIdsInCode.length > 0
+      ).length,
+      filesWithStateComplexity: entries.filter(
+        (f) => f.stateComplexity !== null
+      ).length,
+      topStateHeavyFiles: [...entries].filter((f) => f.stateComplexity !== null).sort(
+        (a, b) => (b.stateComplexity?.hookCounts.total ?? 0) - (a.stateComplexity?.hookCounts.total ?? 0)
+      ).slice(0, 5).map((f) => ({
+        path: f.path,
+        totalHooks: f.stateComplexity.hookCounts.total
+      }))
+    },
+    analysis,
+    heatmap,
+    configLayer,
+    schemaLayer,
+    crossReferences,
+    nodes,
+    edges,
+    files: entries,
+    markdownDocs,
+    recentCommits,
+    recentTodos: buildRecentTodos(entries),
+    deprecatedSurface: buildDeprecatedSurface(entries)
+  };
+  try {
+    const { enrichWithTypedSignatures: enrichWithTypedSignatures2 } = await Promise.resolve().then(() => (init_astEnrich(), astEnrich_exports));
+    console.log("\nRunning ts-morph AST enrichment...");
+    const sigMap = enrichWithTypedSignatures2(entries, projectRoot);
+    let enrichedCount = 0;
+    for (const file of entries) {
+      const sigs = sigMap.get(file.path);
+      if (!sigs) continue;
+      file.explainability.typedSignatures = sigs;
+      for (const sym of file.explainability.symbolSummaries) {
+        const match = sigs.find((s2) => s2.name === sym.name);
+        if (match) sym.signature = match.signature;
+      }
+      enrichedCount++;
+    }
+    console.log(`  \u2192 Enriched ${enrichedCount} / ${entries.length} files with typed signatures`);
+  } catch (e) {
+    console.warn("  ts-morph enrichment skipped:", e.message);
+  }
+  const outputDir = join(__dirname$1, "output");
+  mkdirSync(outputDir, { recursive: true });
+  writeFileSync(
+    join(outputDir, "blueprint.json"),
+    JSON.stringify(output, null, 2),
+    "utf-8"
+  );
+  const historyPath = join(outputDir, "blueprint-history.json");
+  const history = loadHistory(historyPath);
+  const updatedHistory = updateHistory(history, entries, (f) => covScore(f.coverage));
+  saveHistory(historyPath, updatedHistory);
+  console.log(`
+Blueprint generated: ${entries.length} files`);
+  console.log(`
+Import classification:`);
+  console.log(`  total internal     : ${totalInternal}`);
+  console.log(`  runtime internal   : ${totalRuntimeInternal}`);
+  console.log(`  type-only internal : ${totalTypeOnlyInternal}`);
+  console.log(`
+Cycle analysis (runtime-only):`);
+  console.log(`  hasCycles           : ${analysis.hasCycles}`);
+  console.log(`  runtime SCCs        : ${cycleGroups.length}`);
+  console.log(`  pre-filter SCCs     : ${preFilterGroups.length}`);
+  console.log(
+    `  eliminated by type  : ${cyclesEliminatedByTypeImportFiltering}`
+  );
+  if (preFilterGroups.length > 0) {
+    console.log(`
+  Pre-filter groups (for reference):`);
+    preFilterGroups.forEach(
+      (g) => console.log(
+        `    ${g.id} (${g.size} files): ${g.paths.join(", ")}`
+      )
+    );
+  }
+  const s = output.summary;
+  console.log(`
+JSX composition:`);
+  console.log(`  tsx files           : ${s.tsxFileCount}`);
+  console.log(`  with JSX components : ${s.filesWithJsxComponents}`);
+  console.log(`  with UI primitives  : ${s.filesWithUiPrimitives}`);
+  console.log(`  top primitives      : ${mostUsedUiPrimitives.slice(0, 5).map((p) => `${p.name}(${p.count})`).join(", ")}`);
+  const es = output.summary;
+  console.log(`
+Explainability: files=${es.filesWithExplainability}  tableMatches=${es.filesWithTableStringMatches}  configMatches=${es.filesWithConfigStringMatches}`);
+  console.log(`
+Config layer  : found=${configLayer.found}  sections=${configLayer.sectionCount}  appId=${configLayer.appId}`);
+  console.log(`Cross-refs    : config\u2192code=${configCodeLinkCount}  schema\u2192code=${schemaCodeLinkCount}`);
+  console.log(`Schema layer  : found=${schemaLayer.found}  tables=${schemaLayer.tableCount}  fks=${schemaLayer.foreignKeys.length}`);
+  console.log(`
+Heatmap top 5:`);
+  hottestFiles2.slice(0, 5).forEach(
+    (f) => console.log(`  ${f.heatScore.toFixed(1).padStart(5)}  ${f.path}`)
+  );
+  console.log(`
+Category heat:`);
+  categoryHeat.forEach(
+    (c) => console.log(`  ${c.averageHeat.toFixed(1).padStart(5)}  ${c.category} (${c.fileCount} files)`)
+  );
+  console.log(`
+Graph: nodes=${nodes.length}, runtime edges=${edges.length}`);
+  console.log(`Markdown docs : ${markdownDocs.length} files`);
+  console.log(`Commits (180d): ${recentCommits.length}`);
+  console.log(`
+Output \u2192 blueprint-tool/output/blueprint.json`);
+}
+var isEntryPoint = process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+if (isEntryPoint) {
+  main().catch((err) => {
+    console.error("Scanner failed:", err);
+    process.exit(1);
+  });
+}
+function docInfo(content) {
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < Math.min(lines.length, 5)) {
+    const t = lines[i].trim();
+    if (t === "" || /^['"]use (client|server)['"]/.test(t)) {
+      i++;
+    } else break;
+  }
+  if (i >= lines.length) return { docSummary: null, docBlock: null };
+  const first = lines[i].trim();
+  if (first.startsWith("/**")) {
+    const block = [];
+    for (let j = i; j < lines.length; j++) {
+      block.push(lines[j]);
+      if (lines[j].includes("*/")) break;
+    }
+    const cleaned = block.join("\n").replace(/^\/\*+/, "").replace(/\*+\/$/, "").split("\n").map((l) => l.replace(/^\s*\*\s?/, "").trim()).filter(Boolean);
+    if (!cleaned.length) return { docSummary: null, docBlock: null };
+    return { docSummary: cleaned.find((l) => !l.startsWith("@")) ?? null, docBlock: cleaned.join("\n") };
+  }
+  if (first.startsWith("//") && !first.startsWith("///")) {
+    const comment = [];
+    for (let j = i; j < lines.length; j++) {
+      const t = lines[j].trim();
+      if (!t.startsWith("//")) break;
+      comment.push(t.replace(/^\/\/\s?/, ""));
+    }
+    if (!comment.length || comment[0].length < 3) return { docSummary: null, docBlock: null };
+    return { docSummary: comment[0], docBlock: comment.join("\n") };
+  }
+  return { docSummary: null, docBlock: null };
+}
+function renderEnv(path, useClient, useServer) {
+  if (useClient) return "client";
+  if (useServer) return "server";
+  if (path.startsWith("app/")) return "server";
+  return "shared";
+}
+async function readSourceFiles(target, include = blueprintConfig.include, exclude = blueprintConfig.exclude) {
+  const aliases = readTsConfigPaths(target);
+  const paths = await fg.glob([...include], {
+    ignore: [...exclude],
+    onlyFiles: true,
+    cwd: target
+  });
+  const scopeSet = new Set(paths.map(normalize));
+  const entries = [];
+  for (const rel of paths) {
+    const absPath = `${target}/${rel}`;
+    try {
+      const content = readFileSync(absPath, "utf-8");
+      const rawImports = extractImports(content);
+      const usageMap = classifyImports(content);
+      const resolvedImportMap = rawImports.map((spec) => ({
+        ...resolveImport(spec, rel, target, scopeSet, aliases),
+        importUsage: usageMap.get(spec) ?? "runtime"
+      }));
+      const internalImports = [
+        ...new Set(
+          resolvedImportMap.filter((r) => r.kind === "internal" && r.resolvedPath !== null).map((r) => r.resolvedPath)
+        )
+      ];
+      const runtimeInternalImports = [
+        ...new Set(
+          resolvedImportMap.filter((r) => r.kind === "internal" && r.resolvedPath !== null && r.importUsage === "runtime").map((r) => r.resolvedPath)
+        )
+      ];
+      const typeOnlyInternalImports = [
+        ...new Set(
+          resolvedImportMap.filter((r) => r.kind === "internal" && r.resolvedPath !== null && r.importUsage === "type-only").map((r) => r.resolvedPath)
+        )
+      ];
+      const externalImports = [
+        ...new Set(resolvedImportMap.filter((r) => r.kind === "external").map((r) => r.source))
+      ];
+      const { docSummary, docBlock } = docInfo(content);
+      const { hasUseClient, hasUseServer } = detectDirectives(content);
+      const nextFileKind = getNextFileKind(rel);
+      const { jsxComponents, uiPrimitives, componentUsageCount, topLevelJsxBlocks } = extractJsxInfo(content, rel);
+      const stateComplexity = extractStateComplexity(content, rel);
+      entries.push({
+        id: makeId(rel),
+        path: rel,
+        category: getCategory(rel),
+        loc: content.split("\n").length,
+        imports: rawImports,
+        exports: extractExports(content),
+        hasJsDoc: detectJsDoc(content),
+        docSummary,
+        docBlock,
+        renderEnvironment: renderEnv(rel, hasUseClient, hasUseServer),
+        nextFileKind,
+        routePath: deriveRoutePath(rel),
+        hasUseClientDirective: hasUseClient,
+        hasUseServerDirective: hasUseServer,
+        isApiRoute: rel.startsWith("app/") && nextFileKind === "route",
+        isCyclic: false,
+        cycleGroupId: null,
+        jsxComponents,
+        uiPrimitives,
+        componentUsageCount,
+        topLevelJsxBlocks,
+        metrics: {
+          loc: content.split("\n").length,
+          incomingRuntimeDeps: 0,
+          outgoingRuntimeDeps: runtimeInternalImports.length,
+          jsxComponentCount: jsxComponents.length,
+          uiPrimitiveCount: uiPrimitives.length,
+          complexityScore: null,
+          duplicationScore: null,
+          heatScore: 0
+        },
+        stateComplexity,
+        controlInventory: null,
+        screenInfo: null,
+        explainability: {
+          primaryDocBlock: docBlock,
+          docBlocks: [],
+          symbolSummaries: [],
+          codeSnippets: [],
+          matchedConfigIdsInCode: [],
+          matchedTableNamesInCode: []
+        },
+        coverage: null,
+        jsdocTags: extractJsdocTags(content),
+        relatedConfigIds: [],
+        relatedTableNames: [],
+        internalImports,
+        externalImports,
+        runtimeInternalImports,
+        typeOnlyInternalImports,
+        incomingInternalDependencies: [],
+        outgoingInternalDependencies: internalImports,
+        resolvedImportMap
+      });
+    } catch {
+    }
+  }
+  const incomingMap = new Map(entries.map((e) => [e.path, []]));
+  for (const e of entries) {
+    for (const p of e.internalImports) {
+      const arr = incomingMap.get(p);
+      if (arr && !arr.includes(e.path)) arr.push(e.path);
+    }
+  }
+  for (const e of entries) {
+    e.incomingInternalDependencies = incomingMap.get(e.path) ?? [];
+    e.metrics.incomingRuntimeDeps = e.incomingInternalDependencies.length;
+  }
+  const runtimeIncoming = new Map(entries.map((e) => [e.path, 0]));
+  for (const e of entries) {
+    for (const p of e.runtimeInternalImports) {
+      runtimeIncoming.set(p, (runtimeIncoming.get(p) ?? 0) + 1);
+    }
+  }
+  const maxLoc = Math.max(...entries.map((e) => e.loc), 1);
+  const maxInc = Math.max(...entries.map((e) => runtimeIncoming.get(e.path) ?? 0), 1);
+  const maxOut = Math.max(...entries.map((e) => e.runtimeInternalImports.length), 1);
+  const maxJsx = Math.max(...entries.map((e) => e.jsxComponents.length), 1);
+  const maxUi = Math.max(...entries.map((e) => e.uiPrimitives.length), 1);
+  for (const e of entries) {
+    const inc = runtimeIncoming.get(e.path) ?? 0;
+    const raw = 0.25 * (e.loc / maxLoc) + 0.35 * (inc / maxInc) + 0.15 * (e.runtimeInternalImports.length / maxOut) + 0.15 * (e.jsxComponents.length / maxJsx) + 0.1 * (e.uiPrimitives.length / maxUi);
+    e.metrics = { ...e.metrics, incomingRuntimeDeps: inc, heatScore: Math.round(raw * 1e3) / 10 };
+  }
+  return entries;
+}
+function extractEdges(files) {
+  const idByPath = new Map(files.map((f) => [f.path, f.id]));
+  const edgeSet = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const f of files) {
+    for (const dep of f.runtimeInternalImports) {
+      const targetId = idByPath.get(dep);
+      if (!targetId) continue;
+      const key = `${f.id}:${targetId}`;
+      if (!edgeSet.has(key)) {
+        edgeSet.add(key);
+        edges.push({ source: f.id, target: targetId, type: "import" });
+      }
+    }
+  }
+  return edges;
+}
+function buildGraph(files, edges) {
+  const nodes = files.map((f) => ({
+    id: f.id,
+    path: f.path,
+    category: f.category,
+    loc: f.loc,
+    hasJsDoc: f.hasJsDoc,
+    label: basename(f.path)
+  }));
+  const allAdj = new Map(files.map((f) => [f.path, f.internalImports]));
+  const preGroups = extractCycleGroups(tarjanSCC(allAdj), allAdj);
+  const rtAdj = new Map(files.map((f) => [f.path, f.runtimeInternalImports]));
+  const cycleGroups = extractCycleGroups(tarjanSCC(rtAdj), rtAdj);
+  const eliminated = preGroups.length - cycleGroups.length;
+  const pathToCycleId = /* @__PURE__ */ new Map();
+  for (const g of cycleGroups) {
+    for (const p of g.paths) pathToCycleId.set(p, g.id);
+  }
+  for (const f of files) {
+    f.isCyclic = pathToCycleId.has(f.path);
+    f.cycleGroupId = pathToCycleId.get(f.path) ?? null;
+  }
+  const filesInCycles = [...pathToCycleId.keys()].sort();
+  const analysis = {
+    hasCycles: cycleGroups.length > 0,
+    cycleCount: cycleGroups.length,
+    stronglyConnectedComponents: cycleGroups,
+    filesInCycles,
+    cyclesEliminatedByTypeImportFiltering: eliminated
+  };
+  return { files, nodes, edges, analysis };
+}
+var COVERAGE_FILE = "coverage/coverage-summary.json";
+function readCoverageData(target) {
+  const coveragePath = join(target, COVERAGE_FILE);
+  if (!existsSync(coveragePath)) return /* @__PURE__ */ new Map();
+  try {
+    const raw = JSON.parse(readFileSync(coveragePath, "utf-8"));
+    return parseCoverageSummary(raw, target);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function mergeWithGraph(graph, coverage) {
+  const annotated = graph.files.map((f) => ({
+    ...f,
+    coverage: lookupCoverage(coverage, f.path)
+  }));
+  return { ...graph, files: annotated };
+}
+
+// src/blueprint/generate.ts
+var DEFAULT_OUTPUT = "output/blueprint.json";
+async function generateBlueprint(target, opts = {}) {
+  const include = opts.include ?? [...blueprintConfig.include];
+  const exclude = opts.exclude ?? [...blueprintConfig.exclude];
+  const prevCwd = process.cwd();
+  process.chdir(target);
+  let files;
+  try {
+    files = await readSourceFiles(target, include, exclude);
+  } finally {
+    process.chdir(prevCwd);
+  }
+  const coverage = readCoverageData(target);
+  const edges = extractEdges(files);
+  let graph = buildGraph(files, edges);
+  graph = mergeWithGraph(graph, coverage);
+  const { files: enrichedFiles, nodes, edges: graphEdges, analysis } = graph;
+  process.chdir(target);
+  let configLayer, schemaLayer, markdownDocs, recentCommits;
+  try {
+    configLayer = parseConfigLayer(target);
+    schemaLayer = parseSchemaLayer(target);
+    markdownDocs = collectMarkdownDocs(target);
+    recentCommits = collectRecentCommits(target);
+  } finally {
+    process.chdir(prevCwd);
+  }
+  const fileCommitStatsMap = buildFileCommitStats(recentCommits, /* @__PURE__ */ new Date());
+  for (const f of enrichedFiles) {
+    f.commitStats = fileCommitStatsMap.get(f.path) ?? void 0;
+  }
+  configLayer.sections.map((s) => s.id);
+  schemaLayer.tables.map((t) => t.name);
+  const configToCode = buildConfigToCode(configLayer, enrichedFiles);
+  const schemaToCode = buildSchemaToCode(schemaLayer, enrichedFiles);
+  for (const link of configToCode) {
+    for (const m of link.matchedFiles) {
+      const f = enrichedFiles.find((e) => e.path === m.path);
+      if (f && !f.relatedConfigIds.includes(link.configId)) f.relatedConfigIds.push(link.configId);
+    }
+  }
+  for (const link of schemaToCode) {
+    for (const m of link.matchedFiles) {
+      const f = enrichedFiles.find((e) => e.path === m.path);
+      if (f && !f.relatedTableNames.includes(link.tableName)) f.relatedTableNames.push(link.tableName);
+    }
+  }
+  const hottestFiles2 = [...enrichedFiles].sort((a, b) => b.metrics.heatScore - a.metrics.heatScore).slice(0, 15).map((e) => ({ path: e.path, heatScore: e.metrics.heatScore }));
+  const catGroups = /* @__PURE__ */ new Map();
+  for (const f of enrichedFiles) {
+    const arr = catGroups.get(f.category) ?? [];
+    arr.push(f.metrics.heatScore);
+    catGroups.set(f.category, arr);
+  }
+  const categoryHeat = [...catGroups.entries()].map(([category, scores]) => ({
+    category,
+    averageHeat: Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10,
+    fileCount: scores.length
+  })).sort((a, b) => b.averageHeat - a.averageHeat);
+  const totalInternal = enrichedFiles.reduce((s, f) => s + f.internalImports.length, 0);
+  const totalExternal = enrichedFiles.reduce((s, f) => s + f.externalImports.length, 0);
+  const totalRuntime = enrichedFiles.reduce((s, f) => s + f.runtimeInternalImports.length, 0);
+  const totalTypeOnly = enrichedFiles.reduce((s, f) => s + f.typeOnlyInternalImports.length, 0);
+  const importCounts = /* @__PURE__ */ new Map();
+  for (const f of enrichedFiles) {
+    for (const p of f.runtimeInternalImports) importCounts.set(p, (importCounts.get(p) ?? 0) + 1);
+  }
+  const mostImportedFiles = [...importCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([path, count]) => ({ path, count }));
+  const primCount = /* @__PURE__ */ new Map();
+  for (const f of enrichedFiles) {
+    for (const p of f.uiPrimitives) primCount.set(p, (primCount.get(p) ?? 0) + 1);
+  }
+  const mostUsedUiPrimitives = [...primCount.entries()].sort((a, b) => b[1] - a[1]).map(([name, count]) => ({ name, count }));
+  const routesDiscovered = [
+    ...new Set(
+      enrichedFiles.filter((f) => f.routePath !== null && (f.nextFileKind === "page" || f.nextFileKind === "route")).map((f) => f.routePath)
+    )
+  ].sort();
+  const filesInCycles = analysis.filesInCycles;
+  const largestCycleSize = analysis.stronglyConnectedComponents[0]?.size ?? 0;
+  const configCodeLinkCount = configToCode.reduce((s, c) => s + c.matchedFiles.length, 0);
+  const schemaCodeLinkCount = schemaToCode.reduce((s, c) => s + c.matchedFiles.length, 0);
+  const output = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      fileCount: enrichedFiles.length,
+      pageCount: enrichedFiles.filter((f) => f.category === "app").length,
+      componentCount: enrichedFiles.filter((f) => f.category === "component").length,
+      libCount: enrichedFiles.filter((f) => f.category === "lib").length,
+      hookCount: enrichedFiles.filter((f) => f.category === "hook").length,
+      internalDependencyCount: totalInternal,
+      externalDependencyCount: totalExternal,
+      runtimeInternalDependencyCount: totalRuntime,
+      typeOnlyInternalDependencyCount: totalTypeOnly,
+      nodeCount: nodes.length,
+      edgeCount: graphEdges.length,
+      mostImportedFiles,
+      clientFileCount: enrichedFiles.filter((f) => f.renderEnvironment === "client").length,
+      serverFileCount: enrichedFiles.filter((f) => f.renderEnvironment === "server").length,
+      pageFileCount: enrichedFiles.filter((f) => f.nextFileKind === "page").length,
+      routeFileCount: enrichedFiles.filter((f) => f.nextFileKind === "route").length,
+      routesDiscovered,
+      cyclicFileCount: filesInCycles.length,
+      stronglyConnectedComponentCount: analysis.cycleCount,
+      largestCycleSize,
+      tsxFileCount: enrichedFiles.filter((f) => f.path.endsWith(".tsx")).length,
+      filesWithJsxComponents: enrichedFiles.filter((f) => f.jsxComponents.length > 0).length,
+      filesWithUiPrimitives: enrichedFiles.filter((f) => f.uiPrimitives.length > 0).length,
+      mostUsedUiPrimitives,
+      configSectionCount: configLayer.sectionCount,
+      sqlTableCount: schemaLayer.tableCount,
+      sqlForeignKeyCount: schemaLayer.foreignKeys.length,
+      configCodeLinkCount,
+      schemaCodeLinkCount,
+      filesWithExplainability: enrichedFiles.length,
+      filesWithTableStringMatches: enrichedFiles.filter((f) => f.relatedTableNames.length > 0).length,
+      filesWithConfigStringMatches: enrichedFiles.filter((f) => f.relatedConfigIds.length > 0).length,
+      filesWithStateComplexity: enrichedFiles.filter((f) => f.stateComplexity !== null).length,
+      topStateHeavyFiles: enrichedFiles.filter((f) => f.stateComplexity !== null).sort((a, b) => b.stateComplexity.hookCounts.total - a.stateComplexity.hookCounts.total).slice(0, 5).map((f) => ({ path: f.path, totalHooks: f.stateComplexity.hookCounts.total }))
+    },
+    analysis,
+    heatmap: { hottestFiles: hottestFiles2, categoryHeat },
+    configLayer,
+    schemaLayer,
+    crossReferences: { configToCode, schemaToCode },
+    nodes,
+    edges: graphEdges,
+    files: enrichedFiles,
+    markdownDocs,
+    recentCommits
+  };
+  if (opts.write) {
+    const outPath = join(target, opts.outputPath ?? DEFAULT_OUTPUT);
+    const dir = dirname(outPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(outPath, JSON.stringify(output, null, 2), "utf-8");
+  }
+  return output;
+}
+function readBlueprint(target, outputPath = DEFAULT_OUTPUT) {
+  const fullPath = join(target, outputPath);
+  if (!existsSync(fullPath)) return null;
+  try {
+    return JSON.parse(readFileSync(fullPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/blueprint/stats.ts
+function aggregateStats(blueprint) {
+  const { summary, files, heatmap } = blueprint;
+  const tableMatches = blueprint.crossReferences.schemaToCode.reduce(
+    (n, link) => n + link.matchedFiles.length,
+    0
+  );
+  const configMatches = blueprint.crossReferences.configToCode.reduce(
+    (n, link) => n + link.matchedFiles.length,
+    0
+  );
+  const coverageFileCount = files.filter((f) => f.coverage !== null).length;
+  const hottestFile = heatmap.hottestFiles[0] ?? null;
+  return {
+    totalFiles: summary.fileCount,
+    runtimeEdges: summary.runtimeInternalDependencyCount,
+    tsxFiles: summary.tsxFileCount,
+    appRoutes: summary.routeFileCount,
+    configSections: summary.configSectionCount,
+    sqlTables: summary.sqlTableCount,
+    tableMatches,
+    configMatches,
+    cyclicFiles: summary.cyclicFileCount,
+    coverageFileCount,
+    hottestFile
+  };
+}
+
+// src/blueprint/heat.ts
+function calculateHeatScore(file) {
+  return file.metrics.heatScore;
+}
+function heatPerCategory(files) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const arr = groups.get(f.category) ?? [];
+    arr.push(f.metrics.heatScore);
+    groups.set(f.category, arr);
+  }
+  return [...groups.entries()].map(([category, scores]) => ({
+    category,
+    averageHeat: Math.round(scores.reduce((a, b) => a + b, 0) / scores.length * 10) / 10,
+    fileCount: scores.length
+  })).sort((a, b) => b.averageHeat - a.averageHeat);
+}
+function heatColor(score) {
+  if (score >= 50) return "#ef4444";
+  if (score >= 30) return "#f97316";
+  if (score >= 15) return "#eab308";
+  if (score >= 5) return "#3b82f6";
+  return "#475569";
+}
+var heatGradient = [
+  { threshold: 0, color: "#475569", label: "Cold" },
+  { threshold: 5, color: "#3b82f6", label: "Low" },
+  { threshold: 15, color: "#eab308", label: "Warm" },
+  { threshold: 30, color: "#f97316", label: "Hot" },
+  { threshold: 50, color: "#ef4444", label: "Critical" }
+];
+function hottestFiles(files, limit = 15) {
+  return [...files].sort((a, b) => b.metrics.heatScore - a.metrics.heatScore).slice(0, limit).map((f) => ({ path: f.path, heatScore: f.metrics.heatScore }));
+}
+
+// src/blueprint/classify.ts
+function classifyFile(filePath, _content) {
+  return getCategory(filePath);
+}
+function filterByCategory(files, categories) {
+  if (categories.length === 0) return files;
+  const set = new Set(categories);
+  return files.filter((f) => set.has(f.category));
+}
+var DEFAULT_INCLUDE = [
+  "app/**/*.{ts,tsx}",
+  "components/**/*.{ts,tsx}",
+  "lib/**/*.{ts,tsx}",
+  "hooks/**/*.{ts,tsx}"
+];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/coverage/**",
+  "**/__tests__/**",
+  "**/*.test.ts",
+  "**/*.test.tsx"
+];
+function hasSourceChanged(target, lastScanTime, include = DEFAULT_INCLUDE, exclude = DEFAULT_EXCLUDE) {
+  const limitMs = lastScanTime.getTime();
+  const files = fg.sync(include, { ignore: exclude, cwd: target, onlyFiles: true });
+  for (const rel of files) {
+    const abs = `${target}/${rel}`;
+    try {
+      if (statSync(abs).mtimeMs > limitMs) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function getSourceChangeSummary(target, lastScanTime, knownPaths = /* @__PURE__ */ new Set(), include = DEFAULT_INCLUDE, exclude = DEFAULT_EXCLUDE) {
+  const limitMs = lastScanTime.getTime();
+  const files = fg.sync(include, { ignore: exclude, cwd: target, onlyFiles: true });
+  const changedFiles = [];
+  const addedFiles = [];
+  for (const rel of files) {
+    const norm = normalize(rel);
+    const abs = `${target}/${rel}`;
+    const isKnown = knownPaths.has(norm);
+    try {
+      const mtime = statSync(abs).mtimeMs;
+      if (!isKnown) {
+        addedFiles.push(norm);
+      } else if (mtime > limitMs) {
+        changedFiles.push(norm);
+      }
+    } catch {
+    }
+  }
+  return {
+    changedFiles,
+    addedFiles,
+    total: changedFiles.length + addedFiles.length,
+    lastScanAt: lastScanTime.toISOString()
+  };
+}
+
+export { aggregateStats, buildGraph, calculateHeatScore, classifyFile, extractEdges, filterByCategory, generateBlueprint, getSourceChangeSummary, hasSourceChanged, heatColor, heatGradient, heatPerCategory, hottestFiles, mergeWithGraph, readBlueprint, readCoverageData, readSourceFiles };