@titan-design/code-graph 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,3 +1,17 @@
+import {
+  aggregateChurnWindows,
+  authorLinesByPath,
+  computeChangeCoupling,
+  computeOwnership,
+  couplingFor,
+  detectGitToplevel,
+  entriesWithin,
+  loadChurnEntries,
+  loadFileFirstSeen,
+  runGit,
+  summarizeOwnership
+} from "./chunk-PFI5XMUG.js";
+
 // src/store.ts
 import { openDatabase, runMigrations } from "@titan-design/store-sqlite";
 
@@ -53,6 +67,7 @@ var MIGRATIONS = [
   { version: 2, name: "code graph columns", up: (db) => db.exec(KIT_EXTENSIONS) },
   { version: 3, name: "code graph tables", up: (db) => db.exec(DOMAIN_DDL) }
 ];
+var SCHEMA_VERSION = Math.max(...MIGRATIONS.map((m) => m.version));
 
 // src/rows.ts
 function rowToSnapshot(row) {
@@ -270,126 +285,18 @@ function prepareStatements(db) {
   };
 }
 function openCodeGraph(dbPath) {
-  const db = openDatabase(dbPath);
+  const db = openDatabase(dbPath, { schemaVersion: SCHEMA_VERSION });
   runMigrations(db, MIGRATIONS);
   return new CodeGraphStore(db);
 }
 
 // src/indexer.ts
 import { realpathSync } from "fs";
-import * as path10 from "path";
-
-// src/parser/parser.ts
-import { Parser, Language } from "web-tree-sitter";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var initialized = false;
-var parsers = /* @__PURE__ */ new Map();
-var languages = /* @__PURE__ */ new Map();
-function resolveWasmPath(language) {
-  switch (language) {
-    case "typescript":
-      return require2.resolve("tree-sitter-typescript/tree-sitter-typescript.wasm");
-    case "tsx":
-      return require2.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
-    case "python":
-      return require2.resolve("tree-sitter-python/tree-sitter-python.wasm");
-    default:
-      throw new Error(`Unsupported language: ${language}`);
-  }
-}
-async function ensureInitialized() {
-  if (initialized) return;
-  await Parser.init();
-  initialized = true;
-}
-async function getLanguage(language) {
-  const cached = languages.get(language);
-  if (cached) return cached;
-  const wasmPath = resolveWasmPath(language);
-  const lang = await Language.load(wasmPath);
-  languages.set(language, lang);
-  return lang;
-}
-async function getParser(language) {
-  const cached = parsers.get(language);
-  if (cached) return cached;
-  resolveWasmPath(language);
-  await ensureInitialized();
-  const lang = await getLanguage(language);
-  const parser = new Parser();
-  parser.setLanguage(lang);
-  parsers.set(language, parser);
-  return parser;
-}
-async function parseFile(content, filePath, language) {
-  const parser = await getParser(language);
-  const tree = parser.parse(content);
-  if (!tree) {
-    throw new Error(`Failed to parse ${filePath}`);
-  }
-  return { tree, content, filePath, language };
-}
-function getSupportedLanguages() {
-  return ["typescript", "tsx", "python"];
-}
-
-// src/parser/file-filter.ts
-import * as path from "path";
-var EXCLUDED_DIRS = [
-  "node_modules",
-  "vendor",
-  "dist",
-  "build",
-  ".next",
-  "__generated__",
-  ".git",
-  ".claude",
-  "coverage"
-];
-var EXCLUDED_PATTERNS = [
-  /\.min\.[jt]sx?$/,
-  /\.d\.ts$/,
-  /\.map$/,
-  /lock\.(json|yaml)$/,
-  /pnpm-lock\.yaml$/,
-  /package-lock\.json$/,
-  /yarn\.lock$/
-];
-var LANGUAGE_EXTENSIONS = {
-  typescript: [".ts", ".tsx"],
-  javascript: [".js", ".jsx"],
-  python: [".py"]
-};
-function isExcludedDir(dirName) {
-  return EXCLUDED_DIRS.includes(dirName);
-}
-function shouldIncludeFile(filePath, languages2) {
-  const segments = filePath.split("/");
-  if (segments.some((s) => EXCLUDED_DIRS.includes(s))) {
-    return false;
-  }
-  if (EXCLUDED_PATTERNS.some((p) => p.test(filePath))) {
-    return false;
-  }
-  const ext = path.extname(filePath);
-  const allowedExtensions = languages2.flatMap(
-    (lang) => LANGUAGE_EXTENSIONS[lang] ?? []
-  );
-  return allowedExtensions.includes(ext);
-}
-function getLanguageFromPath(filePath) {
-  const ext = path.extname(filePath);
-  for (const [language, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
-    if (extensions.includes(ext)) {
-      return language;
-    }
-  }
-  return null;
-}
+import * as path9 from "path";
+import { parseFile } from "@titan-design/code-parser";
 
 // src/extractors/ts-morph-extractor.ts
-import * as path5 from "path";
+import * as path4 from "path";
 import { existsSync } from "fs";
 import {
   Project,
@@ -399,16 +306,17 @@ import {
 } from "ts-morph";
 
 // src/extractors/file-nodes.ts
-import * as path3 from "path";
+import * as path2 from "path";
+import { getLanguageFromPath } from "@titan-design/code-parser";
 
 // src/extractors/ids.ts
-import * as path2 from "path";
+import * as path from "path";
 var MODULE_EXT_RE = /\.(?:tsx|ts|jsx|js|mts|cts|mjs|cjs|py)$/;
 function toPosix(p) {
-  return p.split(path2.sep).join("/");
+  return p.split(path.sep).join("/");
 }
 function repoRelative(repoRoot, absPath) {
-  const rel = path2.relative(repoRoot, absPath);
+  const rel = path.relative(repoRoot, absPath);
   return toPosix(rel);
 }
 function fileId(repoRoot, absPath) {
@@ -427,8 +335,8 @@ function packageId(name) {
   return name;
 }
 var SYMBOL_ID_SEP = "#";
-function symbolId(fileId2, exportName) {
-  return `${fileId2}${SYMBOL_ID_SEP}${exportName}`;
+function symbolId(fileId2, qualifiedName) {
+  return `${fileId2}${SYMBOL_ID_SEP}${qualifiedName}`;
 }
 function parseSymbolId(id) {
   const idx = id.indexOf(SYMBOL_ID_SEP);
@@ -457,8 +365,8 @@ function buildFileModuleNodes(repoRoot, absPath) {
   const parentId = parentModuleId(mId) ?? void 0;
   const language = getLanguageFromPath(absPath) ?? "typescript";
   return [
-    { id: fId, kind: "file", name: path3.basename(fId), parentId: mId, language },
-    { id: mId, kind: "module", name: path3.basename(mId), parentId, language }
+    { id: fId, kind: "file", name: path2.basename(fId), parentId: mId, language },
+    { id: mId, kind: "module", name: path2.basename(mId), parentId, language }
   ];
 }
 
@@ -534,6 +442,65 @@ function isPropertyNamePosition(id) {
   return false;
 }
 
+// src/scope-path.ts
+var TS_NAMED_SCOPES = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "abstract_class_declaration",
+  "class",
+  "function_declaration",
+  "generator_function_declaration",
+  "method_definition",
+  "internal_module"
+]);
+var TS_BOUND_SCOPES = /* @__PURE__ */ new Set([
+  "class",
+  "arrow_function",
+  "function_expression",
+  "generator_function",
+  "object"
+]);
+var PY_NAMED_SCOPES = /* @__PURE__ */ new Set(["function_definition", "class_definition"]);
+var ANONYMOUS_SCOPE = "<anonymous>";
+function qualify(scope, name) {
+  return scope ? `${scope}.${name}` : name;
+}
+function bindingName(node) {
+  const parent = node.parent;
+  if (!parent) return null;
+  if (parent.type === "variable_declarator" || parent.type === "public_field_definition") {
+    return parent.childForFieldName("name")?.text ?? null;
+  }
+  if (parent.type === "pair") return parent.childForFieldName("key")?.text ?? null;
+  if (parent.type === "export_statement") return "default";
+  return null;
+}
+function scopeSegment(node, python) {
+  if (python) {
+    return PY_NAMED_SCOPES.has(node.type) ? node.childForFieldName("name")?.text ?? null : null;
+  }
+  const own = TS_NAMED_SCOPES.has(node.type) ? node.childForFieldName("name")?.text : void 0;
+  if (own) return own;
+  if (!TS_BOUND_SCOPES.has(node.type)) return null;
+  return bindingName(node) ?? ANONYMOUS_SCOPE;
+}
+function enter(scope, segment) {
+  if (!segment) return scope;
+  if (segment === ANONYMOUS_SCOPE && (scope === ANONYMOUS_SCOPE || scope.endsWith(`.${ANONYMOUS_SCOPE}`))) {
+    return scope;
+  }
+  return qualify(scope, segment);
+}
+function walkScopes(root, python, visit) {
+  const step = (node, scope) => {
+    visit(node, scope);
+    const inner = enter(scope, scopeSegment(node, python));
+    for (const child of node.children) {
+      if (child) step(child, inner);
+    }
+  };
+  step(root, "");
+}
+
 // src/declared-names.ts
 var TS_DECL_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -541,22 +508,24 @@ var TS_DECL_TYPES = /* @__PURE__ */ new Set([
   "class_declaration"
 ]);
 var PY_DECL_TYPES = /* @__PURE__ */ new Set(["function_definition", "class_definition"]);
+function collectDeclarations(file) {
+  const python = file.language === "python";
+  const declTypes = python ? PY_DECL_TYPES : TS_DECL_TYPES;
+  const out = [];
+  walkScopes(file.tree.rootNode, python, (node, scope) => {
+    const named = declaredNodeAt(node, declTypes);
+    if (!named) return;
+    out.push({
+      name: named.name,
+      qualifiedName: qualify(scope, named.name),
+      span: { startLine: named.node.startPosition.row + 1, endLine: named.node.endPosition.row + 1 }
+    });
+  });
+  return out;
+}
 function collectDeclaredSpans(file) {
-  const declTypes = file.language === "python" ? PY_DECL_TYPES : TS_DECL_TYPES;
   const spans = /* @__PURE__ */ new Map();
-  const visit = (node) => {
-    const named = declaredNodeAt(node, declTypes);
-    if (named) {
-      spans.set(named.name, {
-        startLine: named.node.startPosition.row + 1,
-        endLine: named.node.endPosition.row + 1
-      });
-    }
-    for (const child of node.children) {
-      if (child) visit(child);
-    }
-  };
-  visit(file.tree.rootNode);
+  for (const d of collectDeclarations(file)) spans.set(d.qualifiedName, d.span);
   return spans;
 }
 function collectDeclaredNames(file) {
@@ -754,7 +723,7 @@ function recordDynamicSymbolRefEdges(sourceFile, srcFileId, agg, resolveSpecifie
 }
 
 // src/extractors/module-resolution.ts
-import * as path4 from "path";
+import * as path3 from "path";
 var RESOLVABLE_EXTS = [
   ".ts",
   ".tsx",
@@ -776,20 +745,20 @@ function* relativeResolutionCandidates(base) {
     const stem = base.slice(0, base.length - jsExt[0].length);
     for (const ext of RESOLVABLE_EXTS) yield stem + ext;
   }
-  for (const ext of RESOLVABLE_EXTS) yield path4.join(base, "index" + ext);
+  for (const ext of RESOLVABLE_EXTS) yield path3.join(base, "index" + ext);
 }
 function resolveRelativeAbs(fs3, fromAbs, specifier) {
   if (!isRelativeSpecifier(specifier)) return null;
-  const base = path4.resolve(path4.dirname(fromAbs), specifier);
+  const base = path3.resolve(path3.dirname(fromAbs), specifier);
   for (const candidate of relativeResolutionCandidates(base)) {
     if (fs3.fileExistsSync(candidate)) return candidate;
   }
   return null;
 }
 function inRepoFileId(repoRoot, abs) {
-  const relative4 = path4.relative(repoRoot, abs);
-  if (relative4.startsWith("..") || path4.isAbsolute(relative4)) return null;
-  if (relative4.split(path4.sep).includes("node_modules")) return null;
+  const relative4 = path3.relative(repoRoot, abs);
+  if (relative4.startsWith("..") || path3.isAbsolute(relative4)) return null;
+  if (relative4.split(path3.sep).includes("node_modules")) return null;
   return fileId(repoRoot, abs);
 }
 
@@ -1028,7 +997,7 @@ function remapDistToSrc(abs) {
   const base = m[1];
   const sub = m[2];
   for (const ext of [".ts", ".tsx"]) {
-    const candidate = path5.join(base, "src", sub + ext);
+    const candidate = path4.join(base, "src", sub + ext);
     if (existsSync(candidate)) return candidate;
   }
   return abs;
@@ -1038,11 +1007,11 @@ function isTypeScriptFile(file) {
 }
 
 // src/extractors/python-extractor.ts
-import * as path6 from "path";
+import * as path5 from "path";
 import { existsSync as existsSync2 } from "fs";
 function* candidates(base) {
   yield `${base}.py`;
-  yield path6.join(base, "__init__.py");
+  yield path5.join(base, "__init__.py");
 }
 var PythonGraphExtractor = class {
   constructor(repoRoot) {
@@ -1079,10 +1048,10 @@ var PythonGraphExtractor = class {
   resolveDotted(fromAbs, specifier) {
     const leadingDots = /^\.*/.exec(specifier)?.[0].length ?? 0;
     const parts = specifier.slice(leadingDots).split(".").filter(Boolean);
-    const relativeBase = path6.resolve(path6.dirname(fromAbs), "../".repeat(Math.max(leadingDots - 1, 0)));
-    const roots = leadingDots > 0 ? [relativeBase] : [path6.dirname(fromAbs), this.repoRoot];
+    const relativeBase = path5.resolve(path5.dirname(fromAbs), "../".repeat(Math.max(leadingDots - 1, 0)));
+    const roots = leadingDots > 0 ? [relativeBase] : [path5.dirname(fromAbs), this.repoRoot];
     for (const root of roots) {
-      for (const candidate of candidates(path6.join(root, ...parts))) {
+      for (const candidate of candidates(path5.join(root, ...parts))) {
         const id = inRepoFileId(this.repoRoot, candidate);
         if (id !== null && existsSync2(candidate)) return id;
       }
@@ -1090,6 +1059,9 @@ var PythonGraphExtractor = class {
     return null;
   }
 };
+function isPublicName(qualifiedName) {
+  return !qualifiedName.slice(qualifiedName.lastIndexOf(".") + 1).startsWith("_");
+}
 function symbolNodes(fId, file) {
   return [...collectDeclaredSpans(file)].map(([name, span]) => ({
     id: symbolId(fId, name),
@@ -1097,7 +1069,7 @@ function symbolNodes(fId, file) {
     name,
     parentId: fId,
     language: "python",
-    attrs: { exported: !name.startsWith("_"), startLine: span.startLine, endLine: span.endLine }
+    attrs: { exported: isPublicName(name), startLine: span.startLine, endLine: span.endLine }
   }));
 }
 function importSpecifiers(root) {
@@ -1130,17 +1102,13 @@ var LanguageExtractor = class {
 };
 
 // src/git-renames.ts
-import { execFileSync } from "child_process";
-import * as path7 from "path";
+import * as path6 from "path";
 function detectGitHead(repoRoot) {
   return runGit(repoRoot, ["rev-parse", "HEAD"]);
 }
 function isInsideGitRepo(repoRoot) {
   return runGit(repoRoot, ["rev-parse", "--is-inside-work-tree"]) === "true";
 }
-function detectGitToplevel(cwd) {
-  return runGit(cwd, ["rev-parse", "--show-toplevel"]);
-}
 function detectRenames(options) {
   const threshold = options.similarityThreshold ?? 80;
   const args = [
@@ -1172,12 +1140,12 @@ function parseRenameOutput(text) {
   return out;
 }
 function classifyRename(oldPath, newPath) {
-  return path7.posix.dirname(oldPath) === path7.posix.dirname(newPath) ? "rename" : "move";
+  return path6.posix.dirname(oldPath) === path6.posix.dirname(newPath) ? "rename" : "move";
 }
 function renameToAliases(repoRoot, pair) {
   const reason = classifyRename(pair.oldPath, pair.newPath);
-  const oldAbs = path7.join(repoRoot, pair.oldPath);
-  const newAbs = path7.join(repoRoot, pair.newPath);
+  const oldAbs = path6.join(repoRoot, pair.oldPath);
+  const newAbs = path6.join(repoRoot, pair.newPath);
   return [
     { oldId: fileId(repoRoot, oldAbs), newId: fileId(repoRoot, newAbs), reason },
     { oldId: moduleId(repoRoot, oldAbs), newId: moduleId(repoRoot, newAbs), reason }
@@ -1195,29 +1163,10 @@ function buildAliases(repoRoot, pairs) {
   }
   return out;
 }
-function discoveryEnv() {
-  const env = { ...process.env };
-  delete env.GIT_DIR;
-  delete env.GIT_INDEX_FILE;
-  delete env.GIT_WORK_TREE;
-  return env;
-}
-function runGit(cwd, args) {
-  try {
-    return execFileSync("git", [...args], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      env: discoveryEnv()
-    }).trim();
-  } catch {
-    return null;
-  }
-}
 
 // src/generated.ts
 import { readFileSync } from "fs";
-import * as path8 from "path";
+import * as path7 from "path";
 var HEURISTIC_FILE_RE = /(?:^|\/)[^/]*\.(?:gen|generated)\.[^/]*$/;
 var HEURISTIC_DIR_RE = /(?:^|\/)generated\//;
 function isGeneratedByHeuristic(id) {
@@ -1229,7 +1178,7 @@ function isGeneratedFile(id, patterns) {
 }
 function loadGeneratedPatterns(rootDir) {
   try {
-    const content = readFileSync(path8.join(rootDir, ".gitattributes"), "utf-8");
+    const content = readFileSync(path7.join(rootDir, ".gitattributes"), "utf-8");
     return parseGeneratedPatterns(content);
   } catch {
     return [];
@@ -1332,25 +1281,26 @@ function annotateRoles(nodes, options) {
 
 // src/file-walk.ts
 import * as fs from "fs/promises";
-import * as path9 from "path";
-async function walkSourceFiles(rootDirs, languages2) {
+import * as path8 from "path";
+import { isExcludedDir, shouldIncludeFile } from "@titan-design/code-parser";
+async function walkSourceFiles(rootDirs, languages) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const rootDir of rootDirs) {
-    await collectFiles(rootDir, rootDir, languages2, seen, out);
+    await collectFiles(rootDir, rootDir, languages, seen, out);
   }
   return out;
 }
-async function collectFiles(dir, rootDir, languages2, seen, out) {
+async function collectFiles(dir, rootDir, languages, seen, out) {
   const entries = await fs.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path9.join(dir, entry.name);
+    const full = path8.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (isExcludedDir(entry.name)) continue;
-      await collectFiles(full, rootDir, languages2, seen, out);
+      await collectFiles(full, rootDir, languages, seen, out);
     } else if (entry.isFile() && !seen.has(full)) {
-      const relative4 = path9.relative(rootDir, full);
-      if (shouldIncludeFile(relative4, [...languages2])) {
+      const relative4 = path8.relative(rootDir, full);
+      if (shouldIncludeFile(relative4, [...languages])) {
         seen.add(full);
         out.push(full);
       }
@@ -1421,6 +1371,7 @@ function resolveBarrelEdges(nodes, edges) {
 // src/incremental.ts
 import { createHash } from "crypto";
 import * as fs2 from "fs/promises";
+import { getLanguageFromPath as getLanguageFromPath2 } from "@titan-design/code-parser";
 
 // src/cognitive-complexity.ts
 function cognitiveComplexityOf(body, language) {
@@ -1812,21 +1763,16 @@ function countLoc(content) {
 function analyzeFunctions(file) {
   const stats = [];
   const fnTypes = file.language === "python" ? PY_FUNCTION_TYPES : TS_FUNCTION_TYPES;
-  const visit = (node) => {
+  walkScopes(file.tree.rootNode, file.language === "python", (node, scope) => {
     const fn = functionAt(node, fnTypes);
-    if (fn) {
-      stats.push({
-        name: fn.name,
-        cyclomatic: cyclomaticOf(fn.body, file.language),
-        cognitive: cognitiveComplexityOf(fn.body, file.language),
-        nestingDepth: nestingDepthOf(fn.body, file.language, 0)
-      });
-    }
-    for (const child of node.children) {
-      if (child) visit(child);
-    }
-  };
-  visit(file.tree.rootNode);
+    if (!fn) return;
+    stats.push({
+      name: fn.name === null ? null : qualify(scope, fn.name),
+      cyclomatic: cyclomaticOf(fn.body, file.language),
+      cognitive: cognitiveComplexityOf(fn.body, file.language),
+      nestingDepth: nestingDepthOf(fn.body, file.language, 0)
+    });
+  });
   return stats;
 }
 function functionAt(node, fnTypes) {
@@ -1872,6 +1818,259 @@ function cyclomaticOf(body, language) {
   return complexity;
 }
 
+// src/analysis/dead-code.ts
+var DEAD_CODE_METRIC_NAMES = /* @__PURE__ */ new Set([
+  "unreachable_statements",
+  "unused_locals",
+  "unused_params"
+]);
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function_expression",
+  "arrow_function",
+  "method_definition",
+  "generator_function_declaration",
+  "generator_function"
+]);
+var PARAM_TYPES = /* @__PURE__ */ new Set(["required_parameter", "optional_parameter"]);
+var TERMINALS = /* @__PURE__ */ new Set([
+  "return_statement",
+  "throw_statement",
+  "break_statement",
+  "continue_statement"
+]);
+function computeDeadCodeMetrics(files, fileIdOf) {
+  const out = [];
+  for (const file of files) {
+    if (file.language !== "typescript" && file.language !== "tsx") continue;
+    const id = fileIdOf(file.filePath);
+    const unreachable = countUnreachable(file.tree.rootNode);
+    if (unreachable > 0) {
+      out.push({ nodeId: id, name: "unreachable_statements", value: unreachable, unit: "count" });
+    }
+    const { locals, params } = countUnusedBindings(file.tree.rootNode);
+    if (locals > 0) {
+      out.push({ nodeId: id, name: "unused_locals", value: locals, unit: "count" });
+    }
+    if (params > 0) {
+      out.push({ nodeId: id, name: "unused_params", value: params, unit: "count" });
+    }
+  }
+  return out;
+}
+function countUnreachable(root) {
+  let count = 0;
+  const visit = (node) => {
+    if (node.type === "statement_block") count += unreachableInBlock(node);
+    for (const child of node.namedChildren) {
+      if (child) visit(child);
+    }
+  };
+  visit(root);
+  return count;
+}
+function unreachableInBlock(block) {
+  let seenTerminal = false;
+  let count = 0;
+  for (const child of block.namedChildren) {
+    if (!child) continue;
+    if (seenTerminal && child.type !== "comment" && child.type !== "function_declaration") {
+      count++;
+    }
+    if (TERMINALS.has(child.type)) seenTerminal = true;
+  }
+  return count;
+}
+function countUnusedBindings(root) {
+  let locals = 0;
+  let params = 0;
+  const visit = (node) => {
+    if (FUNCTION_TYPES.has(node.type)) {
+      const r = analyzeFunction(node);
+      locals += r.locals;
+      params += r.params;
+    }
+    for (const child of node.namedChildren) {
+      if (child) visit(child);
+    }
+  };
+  visit(root);
+  return { locals, params };
+}
+function analyzeFunction(fn) {
+  const declIds = /* @__PURE__ */ new Set();
+  const nameCount = /* @__PURE__ */ new Map();
+  collectBindingDecls(fn, declIds, nameCount);
+  const refs = /* @__PURE__ */ new Map();
+  countReferences(fn, declIds, refs);
+  const isUnused = (name) => !name.startsWith("_") && (nameCount.get(name) ?? 0) <= 1 && (refs.get(name) ?? 0) === 0;
+  const paramNames = ownParamNames(fn);
+  let params = 0;
+  for (let i = paramNames.length - 1; i >= 0; i--) {
+    const name = paramNames[i] ?? null;
+    if (name !== null && isUnused(name)) params++;
+    else break;
+  }
+  let locals = 0;
+  for (const name of ownLocalNames(fn)) {
+    if (isUnused(name)) locals++;
+  }
+  return { locals, params };
+}
+function ownParamNames(fn) {
+  const params = fn.childForFieldName("parameters");
+  if (!params) return [];
+  const out = [];
+  for (const p of params.namedChildren) {
+    if (!p || !PARAM_TYPES.has(p.type)) continue;
+    const first = p.namedChild(0);
+    out.push(first?.type === "identifier" ? first.text : null);
+  }
+  return out;
+}
+function ownLocalNames(fn) {
+  const body = fn.childForFieldName("body");
+  if (!body) return [];
+  const out = [];
+  const walk = (node) => {
+    if (FUNCTION_TYPES.has(node.type)) return;
+    if (node.type === "variable_declarator") {
+      const name = node.childForFieldName("name");
+      if (name?.type === "identifier") out.push(name.text);
+    }
+    for (const child of node.namedChildren) {
+      if (child) walk(child);
+    }
+  };
+  walk(body);
+  return out;
+}
+function collectBindingDecls(fn, ids, nameCount) {
+  const mark = (n) => {
+    if (n?.type !== "identifier") return;
+    ids.add(n.id);
+    nameCount.set(n.text, (nameCount.get(n.text) ?? 0) + 1);
+  };
+  const walk = (node) => {
+    if (PARAM_TYPES.has(node.type)) mark(node.namedChild(0));
+    else if (node.type === "variable_declarator") mark(node.childForFieldName("name"));
+    for (const child of node.namedChildren) {
+      if (child) walk(child);
+    }
+  };
+  walk(fn);
+}
+function countReferences(fn, declIds, out) {
+  const walk = (node) => {
+    if ((node.type === "identifier" || node.type === "shorthand_property_identifier") && !declIds.has(node.id)) {
+      out.set(node.text, (out.get(node.text) ?? 0) + 1);
+    }
+    for (const child of node.namedChildren) {
+      if (child) walk(child);
+    }
+  };
+  walk(fn);
+}
+
+// src/analysis/growth-risk.ts
+var GROWTH_RISK_METRIC_NAMES = /* @__PURE__ */ new Set([
+  "loop_depth",
+  "recursive_functions",
+  "search_in_loop"
+]);
+var TS_LOOP_TYPES = /* @__PURE__ */ new Set([
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "do_statement"
+]);
+var PY_LOOP_TYPES = /* @__PURE__ */ new Set(["for_statement", "while_statement"]);
+var NAMED_FN_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "generator_function_declaration",
+  "method_definition",
+  "function_definition"
+]);
+var SEARCH_METHODS = /* @__PURE__ */ new Set([
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "find",
+  "findIndex",
+  "some",
+  "every",
+  "filter"
+]);
+function computeGrowthRiskMetrics(files, fileIdOf) {
+  const out = [];
+  for (const file of files) {
+    const loopTypes = file.language === "python" ? PY_LOOP_TYPES : TS_LOOP_TYPES;
+    const root = file.tree.rootNode;
+    const id = fileIdOf(file.filePath);
+    const depth = maxLoopDepth(root, loopTypes, 0);
+    if (depth >= 2) {
+      out.push({ nodeId: id, name: "loop_depth", value: depth, unit: "count" });
+    }
+    const recursion = countDirectRecursion(root);
+    if (recursion > 0) {
+      out.push({ nodeId: id, name: "recursive_functions", value: recursion, unit: "count" });
+    }
+    const searches = countSearchInLoop(root, loopTypes, false);
+    if (searches > 0) {
+      out.push({ nodeId: id, name: "search_in_loop", value: searches, unit: "count" });
+    }
+  }
+  return out;
+}
+function countDirectRecursion(root) {
+  let count = 0;
+  const visit = (node) => {
+    if (NAMED_FN_TYPES.has(node.type)) {
+      const name = node.childForFieldName("name")?.text;
+      const body = node.childForFieldName("body");
+      if (name && body && callsName(body, name)) count++;
+    }
+    for (const child of node.namedChildren) {
+      if (child) visit(child);
+    }
+  };
+  visit(root);
+  return count;
+}
+function callsName(node, name) {
+  if (node.type === "call_expression") {
+    const fn = node.childForFieldName("function");
+    if (fn?.type === "identifier" && fn.text === name) return true;
+  }
+  for (const child of node.namedChildren) {
+    if (child && callsName(child, name)) return true;
+  }
+  return false;
+}
+function countSearchInLoop(node, loopTypes, inLoop) {
+  let count = 0;
+  if (inLoop && node.type === "call_expression") {
+    const fn = node.childForFieldName("function");
+    const prop = fn?.type === "member_expression" ? fn.childForFieldName("property") : null;
+    if (prop && SEARCH_METHODS.has(prop.text)) count++;
+  }
+  const childInLoop = inLoop || loopTypes.has(node.type);
+  for (const child of node.namedChildren) {
+    if (child) count += countSearchInLoop(child, loopTypes, childInLoop);
+  }
+  return count;
+}
+function maxLoopDepth(node, loopTypes, depth) {
+  let max = depth;
+  for (const child of node.namedChildren) {
+    if (!child) continue;
+    const next = loopTypes.has(child.type) ? depth + 1 : depth;
+    const childMax = maxLoopDepth(child, loopTypes, next);
+    if (childMax > max) max = childMax;
+  }
+  return max;
+}
+
 // src/reconstruct.ts
 function reconstructFragment(repoRoot, absPath, fileId2, basis) {
   const nodes = buildFileModuleNodes(repoRoot, absPath);
@@ -1922,7 +2121,7 @@ function structuralSignature(file) {
   return hashContent(parts.join(""));
 }
 function sourceLanguage(filePath) {
-  const language = getLanguageFromPath(filePath);
+  const language = getLanguageFromPath2(filePath);
   return language === "typescript" || language === "python" ? language : null;
 }
 async function readSourceFiles(filePaths) {
@@ -2019,7 +2218,8 @@ function loadReuseBasis(db, indexVersion) {
     }
     const sourceMetricsByFile = /* @__PURE__ */ new Map();
     for (const m of db.listMetrics(snap.id)) {
-      if (!SOURCE_METRIC_NAMES.has(m.name)) continue;
+      if (!SOURCE_METRIC_NAMES.has(m.name) && !DEAD_CODE_METRIC_NAMES.has(m.name) && !GROWTH_RISK_METRIC_NAMES.has(m.name))
+        continue;
       const node = nodesById.get(m.nodeId);
       const fileKey = node?.kind === "symbol" && node.parentId ? node.parentId : m.nodeId;
       const bucket = sourceMetricsByFile.get(fileKey);
@@ -2163,6 +2363,199 @@ function computeMetrics(nodes, edges) {
   return out;
 }
 
+// src/analysis/test-linker.ts
+var DEFAULT_MIN_CO_EDIT_COUNT = 2;
+var TEST_INFIX_RE = /\.(?:test|spec)(\.[^./]+)$/;
+var TESTS_DIR_RE = /(^|\/)(?:__tests__|tests?)\//;
+function pathCandidates(testId) {
+  const out = /* @__PURE__ */ new Set();
+  const deInfixed = testId.replace(TEST_INFIX_RE, "$1");
+  if (deInfixed !== testId) out.add(deInfixed);
+  const deDir = deInfixed.replace(TESTS_DIR_RE, "$1");
+  if (deDir !== testId) out.add(deDir);
+  return [...out];
+}
+function splitFileIds(nodes) {
+  const testIds = [];
+  const nonTestIds = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    if (n.kind !== "file") continue;
+    if (n.role === "test") testIds.push(n.id);
+    else nonTestIds.add(n.id);
+  }
+  return { testIds, nonTestIds };
+}
+function linkTestsToSources(nodes, coEditPairs, options = {}) {
+  const minCount = options.minCoEditCount ?? DEFAULT_MIN_CO_EDIT_COUNT;
+  const { testIds, nonTestIds } = splitFileIds(nodes);
+  const links = [];
+  for (const testId of testIds) {
+    const matched = pathCandidates(testId).filter((c) => nonTestIds.has(c));
+    if (matched.length > 0) {
+      for (const sourceId of matched) {
+        links.push({ testId, sourceId, method: "path" });
+      }
+      continue;
+    }
+    const partner = couplingFor(coEditPairs, testId).find((p) => p.count >= minCount && nonTestIds.has(p.partner));
+    if (partner) {
+      links.push({ testId, sourceId: partner.partner, method: "coedit" });
+    }
+  }
+  return links;
+}
+function testCoverageCountMetrics(links) {
+  const testsBySource = groupTestsBySource(links);
+  const out = [];
+  for (const [sourceId, tests] of testsBySource) {
+    out.push({
+      nodeId: sourceId,
+      name: "linked_test_count",
+      value: tests.size,
+      unit: "count"
+    });
+  }
+  return out;
+}
+function groupTestsBySource(links) {
+  const out = /* @__PURE__ */ new Map();
+  for (const l of links) {
+    let set = out.get(l.sourceId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      out.set(l.sourceId, set);
+    }
+    set.add(l.testId);
+  }
+  return out;
+}
+
+// src/history-recency.ts
+var DAY_SECONDS = 86400;
+function windowSuffix(window) {
+  return window === "lifetime" ? "lifetime" : `${window}d`;
+}
+function computeRecencyWindows(firstSeen, churnedIdsByWindow, nowEpoch) {
+  const out = [];
+  const ageEmitted = /* @__PURE__ */ new Set();
+  for (const [windowDays, ids] of churnedIdsByWindow) {
+    const suffix = windowSuffix(windowDays);
+    for (const id of ids) {
+      const seen = firstSeen.get(id);
+      let recency = 1;
+      if (seen !== void 0) {
+        const ageDays = Math.max(0, (nowEpoch - seen) / DAY_SECONDS);
+        if (windowDays !== "lifetime") recency = Math.min(1, ageDays / windowDays);
+        if (!ageEmitted.has(id)) {
+          out.push({ nodeId: id, name: "file_age_days", value: Math.round(ageDays), unit: "days" });
+          ageEmitted.add(id);
+        }
+      }
+      out.push({ nodeId: id, name: `recency_${suffix}`, value: round3(recency), unit: "ratio" });
+    }
+  }
+  return out;
+}
+function round3(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/history-metrics.ts
+var DEFAULT_CHURN_WINDOWS = [30, 90, 180];
+function resolveChurnWindows(requested, primaryWindow, includeLifetime) {
+  const base = requested && requested.length > 0 ? requested : DEFAULT_CHURN_WINDOWS;
+  const finite = [.../* @__PURE__ */ new Set([primaryWindow, ...base])].filter((w) => w > 0).sort((a, b) => a - b);
+  return includeLifetime ? [...finite, "lifetime"] : finite;
+}
+function loadHistoryMetrics(nodes, idRoot, options = {}) {
+  const knownPaths = collectFileIds(nodes);
+  const primaryWindow = options.churnWindowDays ?? 30;
+  const windows = resolveChurnWindows(options.churnWindows, primaryWindow, options.includeLifetime === true);
+  const wide = loadChurnEntries({ repoRoot: idRoot, windowDays: windows[windows.length - 1] });
+  if (wide === null) return null;
+  const nowEpoch = options.nowEpoch ?? Math.floor(Date.now() / 1e3);
+  const churnByWindow = aggregateChurnWindows(wide, windows, nowEpoch, knownPaths);
+  const primaryEntries = windows.at(-1) === primaryWindow ? wide : entriesWithin(wide, primaryWindow, nowEpoch);
+  const metrics = [
+    ...churnMetrics(churnByWindow),
+    ...ownershipMetrics(primaryEntries, primaryWindow, knownPaths),
+    ...recencyMetrics(idRoot, churnByWindow, knownPaths, nowEpoch)
+  ];
+  if (options.includeLifetime === true) metrics.push(...ownershipMetrics(wide, "lifetime", knownPaths));
+  return { metrics, primaryEntries };
+}
+function collectFileIds(nodes) {
+  const out = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    if (n.kind === "file") out.add(n.id);
+  }
+  return out;
+}
+function churnMetrics(churnByWindow) {
+  const out = [];
+  for (const [window, byPath] of churnByWindow) {
+    const suffix = windowSuffix(window);
+    for (const [nodeId, churn] of byPath) {
+      out.push(
+        { nodeId, name: `churn_${suffix}`, value: churn.lines, unit: "lines" },
+        { nodeId, name: `churn_${suffix}_commits`, value: churn.commits, unit: "count" },
+        { nodeId, name: `churn_${suffix}_authors`, value: churn.authors, unit: "count" }
+      );
+    }
+  }
+  return out;
+}
+function ownershipMetrics(entries, window, knownPaths) {
+  const suffix = windowSuffix(window);
+  const out = [];
+  for (const [nodeId, owner] of computeOwnership(entries, { knownPaths })) {
+    out.push(
+      { nodeId, name: `bus_factor_${suffix}`, value: owner.busFactor, unit: "count" },
+      { nodeId, name: `top_author_share_${suffix}`, value: round3(owner.topAuthorShare), unit: "ratio" }
+    );
+  }
+  return out;
+}
+function computeTestCoverageOwnership(entries, links, options = {}) {
+  const suffix = windowSuffix(options.windowDays ?? 30);
+  const testsBySource = groupTestsBySource(links);
+  const testIds = /* @__PURE__ */ new Set();
+  for (const tests of testsBySource.values()) {
+    for (const t of tests) testIds.add(t);
+  }
+  const linesByTest = authorLinesByPath(entries, testIds);
+  const out = [];
+  for (const [nodeId, tests] of testsBySource) {
+    const summary = summarizeOwnership(mergeAuthorChurn(tests, linesByTest), options.busFactorThreshold);
+    if (summary === null) continue;
+    out.push(
+      { nodeId, name: `test_bus_factor_${suffix}`, value: summary.busFactor, unit: "count" },
+      { nodeId, name: `test_top_author_share_${suffix}`, value: round3(summary.topAuthorShare), unit: "ratio" }
+    );
+  }
+  return out;
+}
+function mergeAuthorChurn(tests, linesByTest) {
+  const byAuthor = /* @__PURE__ */ new Map();
+  for (const testId of tests) {
+    const fileAuthors = linesByTest.get(testId);
+    if (!fileAuthors) continue;
+    for (const [author, lines] of fileAuthors) {
+      byAuthor.set(author, (byAuthor.get(author) ?? 0) + lines);
+    }
+  }
+  return byAuthor;
+}
+function recencyMetrics(idRoot, churnByWindow, knownPaths, nowEpoch) {
+  const churnedByWindow = /* @__PURE__ */ new Map();
+  for (const [window, byPath] of churnByWindow) {
+    if (byPath.size > 0) churnedByWindow.set(window, new Set(byPath.keys()));
+  }
+  if (churnedByWindow.size === 0) return [];
+  const firstSeen = loadFileFirstSeen({ repoRoot: idRoot, knownPaths }) ?? /* @__PURE__ */ new Map();
+  return computeRecencyWindows(firstSeen, churnedByWindow, nowEpoch);
+}
+
 // src/index-metrics.ts
 function symbolNamesByFile(nodes) {
   const out = /* @__PURE__ */ new Map();
@@ -2176,6 +2569,7 @@ function symbolNamesByFile(nodes) {
 }
 function buildIndexerMetrics(input) {
   const nodeList = [...input.nodes.values()];
+  const history = input.history ? loadHistoryMetrics(nodeList, input.idRoot, input.history) : null;
   return [
     ...computeMetrics(nodeList, [...input.edges.values()]),
     ...computeSourceMetrics(
@@ -2183,9 +2577,23 @@ function buildIndexerMetrics(input) {
       (p) => fileId(input.idRoot, p),
       symbolNamesByFile(nodeList)
     ),
-    ...input.reusedSourceMetrics
+    ...computeDeadCodeMetrics(input.parsedFiles, (p) => fileId(input.idRoot, p)),
+    ...computeGrowthRiskMetrics(input.parsedFiles, (p) => fileId(input.idRoot, p)),
+    ...input.reusedSourceMetrics,
+    ...history?.metrics ?? [],
+    ...computeTestCoverage(nodeList, history?.primaryEntries ?? null, input.history?.churnWindowDays)
   ];
 }
+function computeTestCoverage(nodes, entries, windowDays) {
+  const coEditPairs = entries ? computeChangeCoupling(entries, { knownPaths: collectFileIds(nodes) }).pairs : [];
+  const links = linkTestsToSources(nodes, coEditPairs);
+  if (links.length === 0) return [];
+  const out = testCoverageCountMetrics(links);
+  if (entries) {
+    out.push(...computeTestCoverageOwnership(entries, links, { windowDays }));
+  }
+  return out;
+}
 
 // src/merge.ts
 function edgeKey(edge) {
@@ -2204,19 +2612,56 @@ function mergeFragments(fragments) {
   return { nodes, edges };
 }
 
-// src/indexer.ts
-var INDEX_VERSION = "0.11.0";
-var LANGUAGES = ["typescript", "python"];
-function canonicalizePath(p) {
-  try {
-    return realpathSync(p);
-  } catch {
-    return p;
+// src/symbol-aliases.ts
+var QUALIFIED_SYMBOLS_SINCE = "0.14.0";
+function versionParts(version) {
+  const m = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+function predatesQualifiedSymbols(indexVersion) {
+  const have = versionParts(indexVersion);
+  if (!have) return true;
+  const since = versionParts(QUALIFIED_SYMBOLS_SINCE);
+  for (let i = 0; i < 3; i++) {
+    if (have[i] !== since[i]) return have[i] < since[i];
   }
+  return false;
 }
-function normalizePaths(paths) {
+function qualifiedSymbolAliases(files, nodeIds) {
+  const out = [];
+  for (const { fileId: fileId2, file } of files) {
+    for (const [name, qualified] of qualifiedByName(file)) {
+      const oldId = symbolId(fileId2, name);
+      if (qualified.size !== 1 || nodeIds.has(oldId)) continue;
+      const newId = symbolId(fileId2, [...qualified][0]);
+      if (nodeIds.has(newId)) out.push({ oldId, newId, reason: "requalify" });
+    }
+  }
+  return out;
+}
+function qualifiedByName(file) {
+  const out = /* @__PURE__ */ new Map();
+  for (const d of collectDeclarations(file)) {
+    const bucket = out.get(d.name);
+    if (bucket) bucket.add(d.qualifiedName);
+    else out.set(d.name, /* @__PURE__ */ new Set([d.qualifiedName]));
+  }
+  return out;
+}
+
+// src/indexer.ts
+var INDEX_VERSION = "0.14.0";
+var LANGUAGES = ["typescript", "python"];
+function canonicalizePath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function normalizePaths(paths) {
   if (paths.length === 0) throw new Error("indexPaths requires at least one path");
-  return [...new Set(paths.map((p) => path10.resolve(p)))];
+  return [...new Set(paths.map((p) => path9.resolve(p)))];
 }
 function countByKind(items) {
   const out = {};
@@ -2243,6 +2688,12 @@ function resolveAliases(rootDir, idRoot, options, store) {
   if (target === priorCommit) return [];
   return buildAliases(idRoot, detectRenames({ repoRoot: rootDir, fromCommit: priorCommit, toCommit: target }));
 }
+function resolveSymbolAliases(store, idRoot, parsedByPath, nodeIds) {
+  const prior = store.listSnapshots({ limit: 1 })[0];
+  if (!prior || !predatesQualifiedSymbols(prior.indexVersion)) return [];
+  const files = [...parsedByPath.values()].map((file) => ({ fileId: fileId(idRoot, file.filePath), file }));
+  return qualifiedSymbolAliases(files, nodeIds);
+}
 function resolveRoots(paths) {
   const raw = normalizePaths(paths);
   const gitToplevel = detectGitToplevel(raw[0]);
@@ -2256,6 +2707,13 @@ async function parseAll(toParse) {
   }
   return parsed;
 }
+function historyOptions(options) {
+  return {
+    churnWindowDays: options.churnWindowDays,
+    churnWindows: options.churnWindows,
+    includeLifetime: options.lifetime === true
+  };
+}
 async function indexPaths(store, options) {
   const { rootDirs, idRoot } = resolveRoots(options.paths);
   const readFiles = await readSourceFiles(await walkSourceFiles(rootDirs, LANGUAGES));
@@ -2283,10 +2741,14 @@ async function indexPaths(store, options) {
     edges: accumulator.edges,
     parsedFiles: [...parsedByPath.values()],
     reusedSourceMetrics: reuse ? reusedFileIds.flatMap((id) => reuse.sourceMetricsByFile.get(id) ?? []) : [],
-    idRoot
+    idRoot,
+    history: options.computeChurn === false ? void 0 : historyOptions(options)
   });
   const rootDir = rootDirs[0];
-  const aliases = resolveAliases(rootDir, idRoot, options, store);
+  const aliases = [
+    ...resolveAliases(rootDir, idRoot, options, store),
+    ...resolveSymbolAliases(store, idRoot, parsedByPath, new Set(accumulator.nodes.keys()))
+  ];
   const commitHash = options.commitHash ?? detectGitHead(rootDir) ?? void 0;
   const snapshotId = persist(store, options.ref ?? "wd", commitHash, accumulator, aliases, metrics);
   store.insertFingerprints(snapshotId, buildFingerprints(readFiles, idRoot, classified.structuralByFileId));
@@ -2305,6 +2767,9 @@ async function indexPaths(store, options) {
   };
 }
 
+// src/index.ts
+import { getLanguageFromPath as getLanguageFromPath3, getSupportedLanguages, parseFile as parseFile2, shouldIncludeFile as shouldIncludeFile2 } from "@titan-design/code-parser";
+
 // src/aliases.ts
 var METRIC_ALIASES = /* @__PURE__ */ new Map([
   ["lines", "loc"],
@@ -2334,6 +2799,9 @@ var EDGE_KIND_ALIASES = /* @__PURE__ */ new Map([
   ["depends_on", "depends-on"],
   ["dependson", "depends-on"]
 ]);
+function deprecatedTarget(map, name) {
+  return map.get(name);
+}
 function canonicalMetricName(name) {
   return METRIC_ALIASES.get(name) ?? name;
 }
@@ -2343,6 +2811,332 @@ function canonicalRole(name) {
 function canonicalEdgeKind(name) {
   return EDGE_KIND_ALIASES.get(name) ?? name;
 }
+function metricAliasTarget(name) {
+  return deprecatedTarget(METRIC_ALIASES, name);
+}
+function roleAliasTarget(name) {
+  return deprecatedTarget(ROLE_ALIASES, name);
+}
+
+// src/analysis/coverage.ts
+var COVERAGE_METRIC_NAME = "coverage_pct";
+function isFileCoverage(v) {
+  return typeof v === "object" && v !== null && typeof v.fnMap === "object" && typeof v.f === "object";
+}
+function innermostContaining(symbols, line) {
+  let best = null;
+  for (const s of symbols) {
+    if (s.startLine <= line && line <= s.endLine) {
+      if (!best || s.endLine - s.startLine < best.endLine - best.startLine) best = s;
+    }
+  }
+  return best;
+}
+function attributeCoverage(coverage, fileIdOf, symbolsByFile) {
+  const out = [];
+  for (const [absPath, fc] of Object.entries(coverage)) {
+    if (!isFileCoverage(fc)) continue;
+    const fileId2 = fileIdOf(absPath);
+    if (!fileId2) continue;
+    const fnIds = Object.keys(fc.fnMap);
+    if (fnIds.length === 0) continue;
+    const covered = fnIds.filter((k) => (fc.f[k] ?? 0) > 0).length;
+    out.push(pctMetric(fileId2, covered, fnIds.length));
+    out.push(...symbolCoverage(fc, fnIds, symbolsByFile.get(fileId2) ?? []));
+  }
+  return out;
+}
+function symbolCoverage(fc, fnIds, symbols) {
+  const perSymbol = /* @__PURE__ */ new Map();
+  for (const k of fnIds) {
+    const sym = innermostContaining(symbols, fc.fnMap[k].loc.start.line);
+    if (!sym) continue;
+    const acc = perSymbol.get(sym.id) ?? { hit: 0, total: 0 };
+    acc.total++;
+    if ((fc.f[k] ?? 0) > 0) acc.hit++;
+    perSymbol.set(sym.id, acc);
+  }
+  return [...perSymbol].map(([id, { hit, total }]) => pctMetric(id, hit, total));
+}
+function pctMetric(nodeId, covered, total) {
+  return {
+    nodeId,
+    name: COVERAGE_METRIC_NAME,
+    value: Math.round(100 * covered / total),
+    unit: "percent"
+  };
+}
+
+// src/analysis/pagerank.ts
+var DEFAULT_DAMPING = 0.85;
+var DEFAULT_TOLERANCE = 1e-6;
+var DEFAULT_MAX_ITERS = 100;
+var DEFAULT_EDGE_WEIGHTS = {
+  imports: 1,
+  "re-exports": 0.5,
+  calls: 1.5,
+  extends: 1,
+  implements: 1,
+  references: 1,
+  "depends-on": 1
+};
+function getEdgeWeight(kind, overrides) {
+  return overrides?.[kind] ?? DEFAULT_EDGE_WEIGHTS[kind] ?? 1;
+}
+function computePageRank(nodes, edges, options = {}) {
+  const n = nodes.length;
+  if (n === 0) return { rows: [], iterations: 0, converged: true };
+  const damping = options.damping ?? DEFAULT_DAMPING;
+  const tolerance = options.tolerance ?? DEFAULT_TOLERANCE;
+  const maxIters = options.maxIterations ?? DEFAULT_MAX_ITERS;
+  const weights = { ...DEFAULT_EDGE_WEIGHTS, ...options.edgeWeights ?? {} };
+  const idx = buildIdIndex(nodes);
+  const adj = buildAdjacency(idx, edges, weights, n);
+  const pers = buildPersonalization(idx, n, options.personalization);
+  const { rank, iterations, converged } = powerIterate(
+    pers,
+    adj,
+    damping,
+    tolerance,
+    maxIters
+  );
+  return { rows: rankToRows(nodes, rank), iterations, converged };
+}
+function buildIdIndex(nodes) {
+  const idx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < nodes.length; i++) idx.set(nodes[i].id, i);
+  return idx;
+}
+function buildAdjacency(idx, edges, weights, n) {
+  const outNeighbors = Array.from(
+    { length: n },
+    () => []
+  );
+  const outWeightSum = new Array(n).fill(0);
+  for (const e of edges) {
+    const si = idx.get(e.srcId);
+    const di = idx.get(e.dstId);
+    if (si === void 0 || di === void 0) continue;
+    const w = weights[e.kind] ?? 1;
+    if (w <= 0) continue;
+    outNeighbors[si].push({ to: di, w });
+    outWeightSum[si] += w;
+  }
+  return { outNeighbors, outWeightSum };
+}
+function powerIterate(pers, adj, damping, tolerance, maxIters) {
+  const n = pers.length;
+  let rank = pers.slice();
+  let next = new Array(n).fill(0);
+  let iterations = 0;
+  let converged = false;
+  for (let iter = 0; iter < maxIters; iter++) {
+    iterations = iter + 1;
+    const dangling = sumDangling(rank, adj.outWeightSum);
+    const teleport = 1 - damping + damping * dangling;
+    seedTeleport(next, pers, teleport);
+    distributeRank(next, rank, adj, damping);
+    const diff = l1Diff(rank, next);
+    [rank, next] = [next, rank];
+    next.fill(0);
+    if (diff < tolerance) {
+      converged = true;
+      break;
+    }
+  }
+  return { rank, iterations, converged };
+}
+function sumDangling(rank, outWeightSum) {
+  let total = 0;
+  for (let i = 0; i < rank.length; i++) {
+    if (outWeightSum[i] === 0) total += rank[i];
+  }
+  return total;
+}
+function seedTeleport(next, pers, teleport) {
+  for (let i = 0; i < next.length; i++) next[i] = teleport * pers[i];
+}
+function distributeRank(next, rank, adj, damping) {
+  for (let i = 0; i < rank.length; i++) {
+    const s = adj.outWeightSum[i];
+    if (s === 0 || rank[i] === 0) continue;
+    const factor = damping * rank[i] / s;
+    const list = adj.outNeighbors[i];
+    for (let k = 0; k < list.length; k++) {
+      next[list[k].to] += factor * list[k].w;
+    }
+  }
+}
+function l1Diff(a, b) {
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff += Math.abs(b[i] - a[i]);
+  return diff;
+}
+function rankToRows(nodes, rank) {
+  return nodes.map((node, i) => ({ nodeId: node.id, score: rank[i] })).sort(compareRows);
+}
+function compareRows(a, b) {
+  if (b.score !== a.score) return b.score - a.score;
+  return a.nodeId < b.nodeId ? -1 : a.nodeId > b.nodeId ? 1 : 0;
+}
+function buildPersonalization(idx, n, pers) {
+  if (!pers || pers.size === 0) return uniformVector(n);
+  const out = new Array(n).fill(0);
+  const total = applySeedWeights(out, idx, pers);
+  if (total === 0) return uniformVector(n);
+  for (let i = 0; i < n; i++) out[i] /= total;
+  return out;
+}
+function uniformVector(n) {
+  return new Array(n).fill(1 / n);
+}
+function applySeedWeights(out, idx, pers) {
+  let total = 0;
+  for (const [id, w] of pers) {
+    if (!isValidWeight(w)) continue;
+    const i = idx.get(id);
+    if (i === void 0) continue;
+    out[i] = w;
+    total += w;
+  }
+  return total;
+}
+function isValidWeight(w) {
+  return Number.isFinite(w) && w > 0;
+}
+
+// src/analysis/relevance.ts
+function computeRelevance(nodes, edges, seedIds, options = {}) {
+  const seeds = seedIds.filter((id) => id.length > 0);
+  if (seeds.length === 0) return /* @__PURE__ */ new Map();
+  const personalization = new Map(seeds.map((id) => [id, 1]));
+  const result = computePageRank(nodes, symmetrize(edges), {
+    personalization,
+    damping: options.damping,
+    edgeWeights: options.edgeWeights
+  });
+  const out = /* @__PURE__ */ new Map();
+  for (const row of result.rows) out.set(row.nodeId, row.score);
+  return out;
+}
+function symmetrize(edges) {
+  const out = [];
+  for (const e of edges) {
+    out.push(e);
+    out.push({ ...e, srcId: e.dstId, dstId: e.srcId });
+  }
+  return out;
+}
+
+// src/analysis/symbol-coupling.ts
+var DEFAULT_MIN_CO_IMPORTS = 2;
+var DEFAULT_LARGE_IMPORTER_THRESHOLD = 40;
+function computeSymbolConsumers(edges) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    let set = bySymbol.get(e.dstId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      bySymbol.set(e.dstId, set);
+    }
+    set.add(e.srcId);
+  }
+  const out = [];
+  for (const [id, consumers] of bySymbol) {
+    const parsed = parseSymbolId(id);
+    if (!parsed) continue;
+    out.push({
+      symbolId: id,
+      fileId: parsed.fileId,
+      name: parsed.name,
+      consumers: [...consumers].sort()
+    });
+  }
+  return out.sort(compareConsumers);
+}
+function compareConsumers(a, b) {
+  if (b.consumers.length !== a.consumers.length) {
+    return b.consumers.length - a.consumers.length;
+  }
+  return a.symbolId < b.symbolId ? -1 : a.symbolId > b.symbolId ? 1 : 0;
+}
+function computeSymbolCoupling(edges, options = {}) {
+  const minCoImports = options.minCoImports ?? DEFAULT_MIN_CO_IMPORTS;
+  const largeThreshold = options.largeImporterThreshold ?? DEFAULT_LARGE_IMPORTER_THRESHOLD;
+  const bySource = groupSymbolsBySource(edges);
+  const counts = /* @__PURE__ */ new Map();
+  for (const symbols of bySource.values()) {
+    if (symbols.length < 2 || symbols.length > largeThreshold) continue;
+    accumulateSymbolPairs(symbols, counts);
+  }
+  return finalizePairs(counts, minCoImports);
+}
+function groupSymbolsBySource(edges) {
+  const perSource = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!parseSymbolId(e.dstId)) continue;
+    let set = perSource.get(e.srcId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      perSource.set(e.srcId, set);
+    }
+    set.add(e.dstId);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [src, set] of perSource) out.set(src, [...set].sort());
+  return out;
+}
+function accumulateSymbolPairs(symbols, counts) {
+  for (let i = 0; i < symbols.length; i++) {
+    for (let j = i + 1; j < symbols.length; j++) {
+      const key = `${symbols[i]}	${symbols[j]}`;
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+  }
+}
+function finalizePairs(counts, minCoImports) {
+  const out = [];
+  for (const [key, coImports] of counts) {
+    if (coImports < minCoImports) continue;
+    const [aId, bId] = key.split("	");
+    const a = parseSymbolId(aId);
+    const b = parseSymbolId(bId);
+    out.push({
+      aId,
+      aFile: a.fileId,
+      aName: a.name,
+      bId,
+      bFile: b.fileId,
+      bName: b.name,
+      coImports,
+      crossFile: a.fileId !== b.fileId
+    });
+  }
+  return out.sort(comparePairs);
+}
+function comparePairs(a, b) {
+  if (b.coImports !== a.coImports) return b.coImports - a.coImports;
+  if (a.crossFile !== b.crossFile) return a.crossFile ? -1 : 1;
+  if (a.aId !== b.aId) return a.aId < b.aId ? -1 : 1;
+  return a.bId < b.bId ? -1 : a.bId > b.bId ? 1 : 0;
+}
+
+// src/analysis/snapshot.ts
+function snapshotPageRank(store, snapshotId, options = {}) {
+  return computePageRank(store.listNodes(snapshotId), store.listEdges(snapshotId), options);
+}
+function snapshotRelevance(store, snapshotId, seedIds, options = {}) {
+  return computeRelevance(store.listNodes(snapshotId), store.listEdges(snapshotId), seedIds, options);
+}
+function snapshotReferenceEdges(store, snapshotId) {
+  return store.listEdges(snapshotId, { includeReferences: true }).filter((e) => e.kind === "references").map((e) => ({ srcId: e.srcId, dstId: e.dstId }));
+}
+function snapshotSymbolConsumers(store, snapshotId) {
+  return computeSymbolConsumers(snapshotReferenceEdges(store, snapshotId));
+}
+function snapshotSymbolCoupling(store, snapshotId, options = {}) {
+  return computeSymbolCoupling(snapshotReferenceEdges(store, snapshotId), options);
+}
 
 // src/read.ts
 function listNodes(store, snapshotId, opts) {
@@ -2354,60 +3148,954 @@ function listEdges(store, snapshotId, opts) {
 function listMetrics(store, snapshotId) {
   return store.listMetrics(snapshotId);
 }
+
+// src/check/context.ts
+function buildRuleContext(store, snapshotId) {
+  const nodes = store.listNodes(snapshotId);
+  const edges = store.listEdges(snapshotId);
+  const nodesById = /* @__PURE__ */ new Map();
+  for (const n of nodes) nodesById.set(n.id, n);
+  return { nodes, nodesById, metricsByNode: indexMetrics(store.listMetrics(snapshotId)), edges };
+}
+function indexMetrics(metrics) {
+  const metricsByNode = /* @__PURE__ */ new Map();
+  for (const m of metrics) {
+    if (m.value === null) continue;
+    let inner = metricsByNode.get(m.nodeId);
+    if (!inner) {
+      inner = /* @__PURE__ */ new Map();
+      metricsByNode.set(m.nodeId, inner);
+    }
+    inner.set(m.name, m.value);
+  }
+  return metricsByNode;
+}
+
+// src/check/patterns.ts
+function patternToRegex(pattern) {
+  if (!pattern.includes("*")) {
+    return new RegExp(escapeRegex(pattern));
+  }
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*" && pattern[i + 1] === "*") {
+      out += ".*";
+      i++;
+    } else if (c === "*") {
+      out += "[^/]*";
+    } else {
+      out += escapeRegex(c);
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+function compilePatterns(patterns) {
+  if (!patterns) return [];
+  return patterns.map(patternToRegex);
+}
+function matchesAny(value, patterns) {
+  for (const rx of patterns) {
+    if (rx.test(value)) return true;
+  }
+  return false;
+}
+function escapeRegex(s) {
+  return s.replace(/[.+?(){}|^$\\[\]]/g, "\\$&");
+}
+
+// src/check/rule-helpers.ts
+function severityOf(rule) {
+  return rule.severity ?? "error";
+}
+function formatNumber(n) {
+  if (Number.isInteger(n)) return String(n);
+  return n.toFixed(3).replace(/\.?0+$/, "");
+}
+function isImportEdge(edge) {
+  return edge.kind === "imports" || edge.kind === "re-exports";
+}
+function longestPrefixMatcher(prefixes) {
+  const byLength = [...prefixes].sort((a, b) => b.length - a.length);
+  return (id) => {
+    for (const p of byLength) {
+      if (id === p || id.startsWith(`${p}/`)) return p;
+    }
+    return null;
+  };
+}
+
+// src/check/import-rules.ts
+function layerIndex(layers) {
+  const packageLayer = /* @__PURE__ */ new Map();
+  for (let i = 0; i < layers.length; i++) {
+    for (const pkg of layers[i]) packageLayer.set(pkg, i);
+  }
+  return packageLayer;
+}
+function runLayeredDepsRule(rule, ctx) {
+  const packageLayer = layerIndex(rule.layers);
+  const packageOf = longestPrefixMatcher([...packageLayer.keys()]);
+  const out = [];
+  for (const edge of ctx.edges) {
+    if (!isImportEdge(edge)) continue;
+    const srcPkg = packageOf(edge.srcId);
+    const dstPkg = packageOf(edge.dstId);
+    if (srcPkg === null || dstPkg === null) continue;
+    const srcLayer = packageLayer.get(srcPkg);
+    const dstLayer = packageLayer.get(dstPkg);
+    if (srcLayer >= dstLayer) continue;
+    out.push({
+      ruleId: rule.id,
+      severity: severityOf(rule),
+      nodeId: edge.srcId,
+      destinationId: edge.dstId,
+      message: `${srcPkg} (layer ${srcLayer}) imports ${dstPkg} (layer ${dstLayer})`
+    });
+  }
+  return out;
+}
+function runForbidImportRule(rule, ctx) {
+  const fromRx = compilePatterns([rule.from]);
+  const toRx = compilePatterns([rule.to]);
+  const out = [];
+  for (const edge of ctx.edges) {
+    if (!isImportEdge(edge)) continue;
+    if (!matchesAny(edge.srcId, fromRx)) continue;
+    if (!matchesAny(edge.dstId, toRx)) continue;
+    out.push({
+      ruleId: rule.id,
+      severity: severityOf(rule),
+      nodeId: edge.srcId,
+      destinationId: edge.dstId,
+      message: `${edge.srcId} imports ${edge.dstId} (forbidden: ${rule.from} \u2192 ${rule.to})`
+    });
+  }
+  return out;
+}
+function importersByDestination(edges) {
+  const importersByDst = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    if (!isImportEdge(edge)) continue;
+    let list = importersByDst.get(edge.dstId);
+    if (!list) {
+      list = [];
+      importersByDst.set(edge.dstId, list);
+    }
+    list.push(edge.srcId);
+  }
+  return importersByDst;
+}
+function runNoInternalOnlyBarrelsRule(rule, ctx) {
+  const packageOf = longestPrefixMatcher(rule.packageRoots);
+  const excluders = compilePatterns(rule.exclude);
+  const importersByDst = importersByDestination(ctx.edges);
+  const out = [];
+  for (const node of ctx.nodes) {
+    if (node.kind !== "file") continue;
+    if (node.role !== "barrel") continue;
+    if (matchesAny(node.id, excluders)) continue;
+    const barrelPkg = packageOf(node.id);
+    if (barrelPkg === null) continue;
+    const importers = importersByDst.get(node.id) ?? [];
+    const externalCount = importers.reduce((n, src) => packageOf(src) !== barrelPkg ? n + 1 : n, 0);
+    if (externalCount > 0) continue;
+    out.push({
+      ruleId: rule.id,
+      severity: severityOf(rule),
+      nodeId: node.id,
+      message: barrelMessage(barrelPkg, importers.length)
+    });
+  }
+  return out;
+}
+function barrelMessage(barrelPkg, importerCount) {
+  return importerCount === 0 ? `barrel in package "${barrelPkg}" has no importers` : `barrel in package "${barrelPkg}" has ${importerCount} internal importer(s) but zero external`;
+}
+
+// src/check/metric-rules.ts
+function nodeFilter(rule) {
+  return {
+    kind: rule.kind,
+    excluders: compilePatterns(rule.exclude),
+    excludedRoles: new Set(rule.excludeRoles ?? [])
+  };
+}
+function passesFilter(node, filter) {
+  if (filter.kind && node.kind !== filter.kind) return false;
+  if (matchesAny(node.id, filter.excluders)) return false;
+  if (node.role && filter.excludedRoles.has(node.role)) return false;
+  return true;
+}
+function runMetricMaxRule(rule, ctx) {
+  const filter = nodeFilter(rule);
+  const out = [];
+  for (const node of ctx.nodes) {
+    if (!passesFilter(node, filter)) continue;
+    const value = ctx.metricsByNode.get(node.id)?.get(rule.metric);
+    if (value === void 0) continue;
+    if (value <= rule.max) continue;
+    out.push({
+      ruleId: rule.id,
+      severity: severityOf(rule),
+      nodeId: node.id,
+      metric: rule.metric,
+      value,
+      threshold: rule.max,
+      message: `${rule.metric}=${formatNumber(value)} > ${formatNumber(rule.max)}`
+    });
+  }
+  return out;
+}
+function runMetricMinRule(rule, ctx) {
+  const filter = nodeFilter(rule);
+  const out = [];
+  for (const node of ctx.nodes) {
+    if (!passesFilter(node, filter)) continue;
+    const value = ctx.metricsByNode.get(node.id)?.get(rule.metric);
+    if (value === void 0) continue;
+    if (value >= rule.min) continue;
+    out.push({
+      ruleId: rule.id,
+      severity: severityOf(rule),
+      nodeId: node.id,
+      metric: rule.metric,
+      value,
+      threshold: rule.min,
+      message: `${rule.metric}=${formatNumber(value)} < ${formatNumber(rule.min)}`
+    });
+  }
+  return out;
+}
+function runMetricProductMaxRule(rule, ctx) {
+  const filter = nodeFilter(rule);
+  const out = [];
+  for (const node of ctx.nodes) {
+    if (!passesFilter(node, filter)) continue;
+    const inner = ctx.metricsByNode.get(node.id);
+    if (!inner) continue;
+    const components = collectComponents(rule.metrics, inner);
+    if (!components) continue;
+    const product = components.reduce((a, b) => a * b, 1);
+    if (product <= rule.max) continue;
+    out.push(productViolation(rule, node.id, components, product));
+  }
+  return out;
+}
+function productViolation(rule, nodeId, components, product) {
+  const detail = rule.metrics.map((m, i) => `${m}=${formatNumber(components[i])}`).join(" * ");
+  return {
+    ruleId: rule.id,
+    severity: severityOf(rule),
+    nodeId,
+    metric: rule.metrics.join(" * "),
+    value: product,
+    threshold: rule.max,
+    message: `${detail} = ${formatNumber(product)} > ${formatNumber(rule.max)}`
+  };
+}
+function collectComponents(metrics, values) {
+  const out = [];
+  for (const m of metrics) {
+    const v = values.get(m);
+    if (v === void 0) return null;
+    out.push(v);
+  }
+  return out;
+}
+
+// src/check/rules.ts
+function runRule(rule, ctx) {
+  switch (rule.type) {
+    case "metric-max":
+      return runMetricMaxRule(rule, ctx);
+    case "metric-min":
+      return runMetricMinRule(rule, ctx);
+    case "metric-product-max":
+      return runMetricProductMaxRule(rule, ctx);
+    case "forbid-import":
+      return runForbidImportRule(rule, ctx);
+    case "layered-deps":
+      return runLayeredDepsRule(rule, ctx);
+    case "no-internal-only-barrels":
+      return runNoInternalOnlyBarrelsRule(rule, ctx);
+  }
+}
+
+// src/check/check.ts
+function runChecks(store, options) {
+  const ctx = buildRuleContext(store, options.snapshotId);
+  const violations = [];
+  for (const rule of options.rules) {
+    violations.push(...runRule(rule, ctx));
+  }
+  if (options.baselineSnapshotId) {
+    const baselineKeys = collectBaselineKeys(store, options.baselineSnapshotId, options.rules);
+    for (const v of violations) {
+      if (baselineKeys.has(violationKey(v))) v.isCarryover = true;
+    }
+  }
+  const counts = countByOriginAndSeverity(violations);
+  return {
+    snapshotId: options.snapshotId,
+    baselineSnapshotId: options.baselineSnapshotId,
+    rulesEvaluated: options.rules.length,
+    nodesEvaluated: ctx.nodes.length,
+    violations,
+    ...counts,
+    passed: counts.newErrors === 0
+  };
+}
+function collectBaselineKeys(store, baselineSnapshotId, rules) {
+  const ctx = buildRuleContext(store, baselineSnapshotId);
+  const keys = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    for (const v of runRule(rule, ctx)) keys.add(violationKey(v));
+  }
+  return keys;
+}
+function violationKey(v) {
+  return v.destinationId ? `${v.ruleId}|${v.nodeId}|${v.destinationId}` : `${v.ruleId}|${v.nodeId}`;
+}
+function countByOriginAndSeverity(violations) {
+  const counts = { newErrors: 0, newWarnings: 0, carryoverErrors: 0, carryoverWarnings: 0 };
+  for (const v of violations) {
+    const isError = v.severity === "error";
+    if (v.isCarryover) {
+      if (isError) counts.carryoverErrors++;
+      else counts.carryoverWarnings++;
+    } else {
+      if (isError) counts.newErrors++;
+      else counts.newWarnings++;
+    }
+  }
+  return counts;
+}
+
+// src/check/validate.ts
+function validateRules(input, options = {}) {
+  if (!input || typeof input !== "object") {
+    throw new Error("rules file must be an object with a `rules` array");
+  }
+  const obj = input;
+  if (!Array.isArray(obj.rules)) {
+    throw new Error("rules file must have a `rules` array");
+  }
+  const warn = options.onWarn ?? (() => {
+  });
+  return obj.rules.map((r, i) => validateRule(r, i, warn));
+}
+function healMetricName(name, ruleId, warn) {
+  const target = metricAliasTarget(name);
+  if (target) {
+    warn(`${ruleId}: metric "${name}" is deprecated \u2014 using "${target}"`);
+    return target;
+  }
+  return name;
+}
+function validateRule(raw, index, warn) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`rule[${index}] must be an object`);
+  }
+  const r = raw;
+  if (typeof r.id !== "string" || !r.id) {
+    throw new Error(`rule[${index}] missing string id`);
+  }
+  if (typeof r.type !== "string") {
+    throw new Error(`rule[${index}] (${r.id}) missing string type`);
+  }
+  switch (r.type) {
+    case "metric-max":
+      return assertMetricMax(r, warn);
+    case "metric-min":
+      return assertMetricMin(r, warn);
+    case "metric-product-max":
+      return assertMetricProductMax(r, warn);
+    case "forbid-import":
+      return assertForbidImport(r);
+    case "layered-deps":
+      return assertLayeredDeps(r);
+    case "no-internal-only-barrels":
+      return assertNoInternalOnlyBarrels(r);
+    default:
+      throw new Error(`rule[${index}] (${r.id}) unknown type "${r.type}"`);
+  }
+}
+function assertNoInternalOnlyBarrels(r) {
+  if (!Array.isArray(r.packageRoots) || r.packageRoots.length === 0) {
+    throw new Error(
+      `${r.id}: packageRoots must be a non-empty array of path-prefix strings`
+    );
+  }
+  for (const p of r.packageRoots) {
+    if (typeof p !== "string" || !p) {
+      throw new Error(`${r.id}: each packageRoots entry must be a non-empty string`);
+    }
+  }
+  return {
+    type: "no-internal-only-barrels",
+    id: r.id,
+    packageRoots: r.packageRoots,
+    severity: r.severity,
+    exclude: parseStringArray(r.exclude)
+  };
+}
+function assertLayeredDeps(r) {
+  if (!Array.isArray(r.layers) || r.layers.length < 2) {
+    throw new Error(`${r.id}: layers must be an array of 2+ string arrays`);
+  }
+  for (const layer of r.layers) {
+    if (!Array.isArray(layer) || !layer.every((p) => typeof p === "string")) {
+      throw new Error(`${r.id}: each layer must be a string[]`);
+    }
+    if (layer.length === 0) {
+      throw new Error(`${r.id}: empty layers not allowed`);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const layer of r.layers) {
+    for (const pkg of layer) {
+      if (seen.has(pkg)) {
+        throw new Error(`${r.id}: package "${pkg}" appears in more than one layer`);
+      }
+      seen.add(pkg);
+    }
+  }
+  return {
+    type: "layered-deps",
+    id: r.id,
+    layers: r.layers,
+    severity: r.severity
+  };
+}
+function assertMetricProductMax(r, warn) {
+  if (!Array.isArray(r.metrics) || r.metrics.length < 2) {
+    throw new Error(`${r.id}: metrics must be an array of 2+ metric names`);
+  }
+  if (!r.metrics.every((m) => typeof m === "string")) {
+    throw new Error(`${r.id}: metrics must be strings`);
+  }
+  if (typeof r.max !== "number") {
+    throw new Error(`${r.id}: max must be a number`);
+  }
+  const ruleId = r.id;
+  return {
+    type: "metric-product-max",
+    id: ruleId,
+    metrics: r.metrics.map((m) => healMetricName(m, ruleId, warn)),
+    max: r.max,
+    kind: r.kind,
+    severity: r.severity,
+    exclude: parseStringArray(r.exclude),
+    excludeRoles: parseRoleArray(ruleId, r.excludeRoles, warn)
+  };
+}
+function assertMetricMax(r, warn) {
+  if (typeof r.metric !== "string") throw new Error(`${r.id}: metric must be a string`);
+  if (typeof r.max !== "number") throw new Error(`${r.id}: max must be a number`);
+  const ruleId = r.id;
+  return {
+    type: "metric-max",
+    id: ruleId,
+    metric: healMetricName(r.metric, ruleId, warn),
+    max: r.max,
+    kind: r.kind,
+    severity: r.severity,
+    exclude: parseStringArray(r.exclude),
+    excludeRoles: parseRoleArray(ruleId, r.excludeRoles, warn)
+  };
+}
+function assertMetricMin(r, warn) {
+  if (typeof r.metric !== "string") throw new Error(`${r.id}: metric must be a string`);
+  if (typeof r.min !== "number") throw new Error(`${r.id}: min must be a number`);
+  const ruleId = r.id;
+  return {
+    type: "metric-min",
+    id: ruleId,
+    metric: healMetricName(r.metric, ruleId, warn),
+    min: r.min,
+    kind: r.kind,
+    severity: r.severity,
+    exclude: parseStringArray(r.exclude),
+    excludeRoles: parseRoleArray(ruleId, r.excludeRoles, warn)
+  };
+}
+function assertForbidImport(r) {
+  if (typeof r.from !== "string") throw new Error(`${r.id}: from must be a string`);
+  if (typeof r.to !== "string") throw new Error(`${r.id}: to must be a string`);
+  return {
+    type: "forbid-import",
+    id: r.id,
+    from: r.from,
+    to: r.to,
+    severity: r.severity
+  };
+}
+function parseStringArray(value) {
+  return Array.isArray(value) ? value : void 0;
+}
+var ROLE_VALUES = /* @__PURE__ */ new Set([
+  "test",
+  "fixture",
+  "barrel",
+  "types",
+  "config",
+  "entry",
+  "source"
+]);
+function parseRoleArray(ruleId, value, warn) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) {
+    throw new Error(`${ruleId}: excludeRoles must be an array`);
+  }
+  return value.map((entry) => healRole(entry, ruleId, warn));
+}
+function healRole(entry, ruleId, warn) {
+  if (typeof entry === "string" && ROLE_VALUES.has(entry)) {
+    return entry;
+  }
+  if (typeof entry === "string") {
+    const target = roleAliasTarget(entry);
+    if (target) {
+      warn(`${ruleId}: role "${entry}" is deprecated \u2014 using "${target}"`);
+      return target;
+    }
+  }
+  throw new Error(
+    `${ruleId}: unknown role "${entry}" \u2014 valid: ${[...ROLE_VALUES].join(", ")}`
+  );
+}
+
+// src/check/run.ts
+import { readFile as readFile2 } from "fs/promises";
+function resolveSnapshot(store, spec) {
+  if (typeof spec === "number" || /^\d+$/.test(spec)) {
+    const snap2 = store.getSnapshot(Number(spec));
+    if (!snap2) throw new Error(`no snapshot with id ${spec}`);
+    return snap2;
+  }
+  const snap = store.getLatestSnapshotByRef(spec);
+  if (!snap) throw new Error(`no snapshot found for ref "${spec}"`);
+  return snap;
+}
+function checkSnapshot(store, options) {
+  const snapshot = resolveSnapshot(store, options.snapshot);
+  const baselineSnapshot = options.baseline !== void 0 ? resolveSnapshot(store, options.baseline) : void 0;
+  const result = runChecks(store, {
+    snapshotId: snapshot.id,
+    rules: options.rules,
+    baselineSnapshotId: baselineSnapshot?.id
+  });
+  return { snapshot, baselineSnapshot, result };
+}
+async function loadCheckRules(path10, options = {}) {
+  let raw;
+  try {
+    raw = await readFile2(path10, "utf8");
+  } catch (err) {
+    throw new Error(`Cannot read rules file at ${path10}: ${errorMessage(err)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${path10}: ${errorMessage(err)}`);
+  }
+  return validateRules(parsed, options);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/diff/diff.ts
+function aliasMap(aliases) {
+  const m = /* @__PURE__ */ new Map();
+  for (const a of aliases) m.set(a.oldId, a);
+  return m;
+}
+function resolveId(id, aliases) {
+  return aliases.get(id)?.newId ?? id;
+}
+function edgeKey2(srcId, dstId, kind) {
+  return JSON.stringify([srcId, dstId, canonicalEdgeKind(kind)]);
+}
+function metricKey(nodeId, name) {
+  return JSON.stringify([nodeId, canonicalMetricName(name)]);
+}
+function indexEdges(edges) {
+  const m = /* @__PURE__ */ new Map();
+  for (const e of edges) m.set(edgeKey2(e.srcId, e.dstId, e.kind), e);
+  return m;
+}
+function diffNodes(fromNodes, toNodes, aliases) {
+  const toIndex = new Map(toNodes.map((n) => [n.id, n]));
+  const matchedToIds = /* @__PURE__ */ new Set();
+  const removed = [];
+  const renamed = [];
+  for (const fromNode of fromNodes) {
+    const newId = resolveId(fromNode.id, aliases);
+    const toNode = toIndex.get(newId);
+    if (!toNode) {
+      removed.push(fromNode);
+      continue;
+    }
+    matchedToIds.add(newId);
+    if (newId !== fromNode.id) {
+      renamed.push({ oldId: fromNode.id, newId, reason: aliases.get(fromNode.id).reason, node: toNode });
+    }
+  }
+  const added = toNodes.filter((toNode) => !matchedToIds.has(toNode.id));
+  return { added, removed, renamed, commonNewIds: matchedToIds };
+}
+function diffEdges(fromEdges, toEdges, aliases) {
+  const remappedKey = (e) => edgeKey2(resolveId(e.srcId, aliases), resolveId(e.dstId, aliases), e.kind);
+  const fromKeys = new Set(fromEdges.map(remappedKey));
+  const toIndex = indexEdges(toEdges);
+  const added = [];
+  for (const [k, e] of toIndex) {
+    if (!fromKeys.has(k)) added.push(e);
+  }
+  const removed = fromEdges.filter((e) => !toIndex.has(remappedKey(e)));
+  return { added, removed };
+}
+function indexFromMetrics(metrics, aliases) {
+  const fromIndex = /* @__PURE__ */ new Map();
+  for (const m of metrics) {
+    const newId = resolveId(m.nodeId, aliases);
+    fromIndex.set(metricKey(newId, m.name), { metric: m, nodeId: newId });
+  }
+  return fromIndex;
+}
+function deltaOf(before, after) {
+  if (before === null || after === null) return null;
+  return after - before;
+}
+function metricDelta(nodeId, name, before, after) {
+  return { nodeId, name: canonicalMetricName(name), before, after, delta: deltaOf(before, after) };
+}
+function diffMetrics(fromMetrics, toMetrics, aliases, commonNewIds) {
+  const fromIndex = indexFromMetrics(fromMetrics, aliases);
+  const toIndex = new Map(toMetrics.map((m) => [metricKey(m.nodeId, m.name), m]));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, { metric: before, nodeId }] of fromIndex) {
+    if (!commonNewIds.has(nodeId)) continue;
+    seen.add(key);
+    const afterVal = toIndex.get(key)?.value ?? null;
+    if (before.value !== afterVal) out.push(metricDelta(nodeId, before.name, before.value, afterVal));
+  }
+  for (const [key, after] of toIndex) {
+    if (seen.has(key) || !commonNewIds.has(after.nodeId)) continue;
+    out.push(metricDelta(after.nodeId, after.name, null, after.value));
+  }
+  return out;
+}
+function diffSnapshots(store, options) {
+  const { fromSnapshotId, toSnapshotId } = options;
+  const aliases = aliasMap(store.listAliases(toSnapshotId));
+  const nodeDiff = diffNodes(store.listNodes(fromSnapshotId), store.listNodes(toSnapshotId), aliases);
+  const edgeDiff = diffEdges(store.listEdges(fromSnapshotId), store.listEdges(toSnapshotId), aliases);
+  const metricDeltas = diffMetrics(
+    store.listMetrics(fromSnapshotId),
+    store.listMetrics(toSnapshotId),
+    aliases,
+    nodeDiff.commonNewIds
+  );
+  return {
+    summary: summarize(options, nodeDiff, edgeDiff, metricDeltas),
+    addedNodes: nodeDiff.added,
+    removedNodes: nodeDiff.removed,
+    renamedNodes: nodeDiff.renamed,
+    addedEdges: edgeDiff.added,
+    removedEdges: edgeDiff.removed,
+    metricDeltas
+  };
+}
+function summarize({ fromSnapshotId, toSnapshotId }, nodeDiff, edgeDiff, metricDeltas) {
+  return {
+    fromSnapshotId,
+    toSnapshotId,
+    addedNodes: nodeDiff.added.length,
+    removedNodes: nodeDiff.removed.length,
+    renamedNodes: nodeDiff.renamed.length,
+    unchangedNodes: nodeDiff.commonNewIds.size - nodeDiff.renamed.length,
+    addedEdges: edgeDiff.added.length,
+    removedEdges: edgeDiff.removed.length,
+    metricChanges: metricDeltas.length
+  };
+}
+
+// src/diff/check-diff.ts
+function diffCheckResults(store, options) {
+  const from = runChecks(store, { snapshotId: options.fromSnapshotId, rules: options.rules });
+  const to = runChecks(store, { snapshotId: options.toSnapshotId, rules: options.rules });
+  return {
+    fromSnapshotId: options.fromSnapshotId,
+    toSnapshotId: options.toSnapshotId,
+    rulesEvaluated: options.rules.length,
+    ...bucketViolations(indexByKey(from.violations), indexByKey(to.violations))
+  };
+}
+function bucketViolations(fromByKey, toByKey) {
+  const buckets = { newViolations: [], resolvedViolations: [], unchanged: [], worsened: [], improved: [] };
+  for (const [key, toV] of toByKey) {
+    const fromV = fromByKey.get(key);
+    if (!fromV) {
+      buckets.newViolations.push(toV);
+      continue;
+    }
+    const delta = computeDelta(fromV, toV);
+    const entry = { from: fromV, to: toV, delta };
+    buckets.unchanged.push(entry);
+    if (delta !== null && delta > 0) buckets.worsened.push(entry);
+    else if (delta !== null && delta < 0) buckets.improved.push(entry);
+  }
+  for (const [key, fromV] of fromByKey) {
+    if (!toByKey.has(key)) buckets.resolvedViolations.push(fromV);
+  }
+  return buckets;
+}
+function indexByKey(violations) {
+  const out = /* @__PURE__ */ new Map();
+  for (const v of violations) out.set(violationKey(v), v);
+  return out;
+}
+function computeDelta(from, to) {
+  if (from.value === void 0 || to.value === void 0) return null;
+  return to.value - from.value;
+}
+
+// src/embeddings/corpus.ts
+import { contentHashOf } from "@titan-design/store-sqlite";
+function buildEmbedText(signature, purpose) {
+  return purpose ? `${signature} -- ${purpose}` : signature;
+}
+function hashEmbedText(text) {
+  return contentHashOf(text);
+}
+var TEST_OR_FIXTURE_PATH = /\.test\.|\.spec\.|__tests__|\/fixtures\//;
+var EXCLUDED_FILE_ROLES = /* @__PURE__ */ new Set(["test", "generated"]);
+function listEmbeddableSymbols(store, snapshotId) {
+  const nodes = store.listNodes(snapshotId, { includeSymbols: true });
+  const fileRoles = /* @__PURE__ */ new Map();
+  for (const n of nodes) if (n.kind === "file") fileRoles.set(n.id, n.role ?? null);
+  const out = [];
+  for (const n of nodes) {
+    const symbol = toEmbeddable(n, fileRoles);
+    if (symbol) out.push(symbol);
+  }
+  return out;
+}
+function toEmbeddable(node, fileRoles) {
+  if (node.kind !== "symbol") return null;
+  const attrs = node.attrs ?? {};
+  if (attrs.exported !== true || !attrs.signature) return null;
+  const file = node.parentId ?? node.id.split("#")[0] ?? node.id;
+  if (TEST_OR_FIXTURE_PATH.test(file)) return null;
+  const role = fileRoles.get(file);
+  if (role && EXCLUDED_FILE_ROLES.has(role)) return null;
+  const text = buildEmbedText(attrs.signature, attrs.purpose);
+  return {
+    id: node.id,
+    name: node.name,
+    file,
+    signature: attrs.signature,
+    purpose: attrs.purpose,
+    text,
+    textHash: hashEmbedText(text)
+  };
+}
+
+// src/embeddings/cache.ts
+import { fromFloat32Buffer, normalize, toFloat32Buffer } from "@titan-design/embed";
+import { CacheBlobTable } from "@titan-design/store-sqlite";
+var SYMBOL_EMBEDDING_NAMESPACE = "code-graph/symbol-embedding";
+var EMBED_BATCH_SIZE = 64;
+function symbolVectorCache(store) {
+  return new CacheBlobTable(store.db, { name: KIT.cacheBlob });
+}
+function loadVectorsByHash(store, model, hashes) {
+  const cache = symbolVectorCache(store);
+  const found = /* @__PURE__ */ new Map();
+  for (const contentHash of new Set(hashes)) {
+    const hit = cache.get({ namespace: SYMBOL_EMBEDDING_NAMESPACE, model, contentHash });
+    if (hit) found.set(contentHash, fromFloat32Buffer(hit.value));
+  }
+  return found;
+}
+function storeVectors(store, model, rows) {
+  const cache = symbolVectorCache(store);
+  store.db.transaction(() => {
+    for (const r of rows) {
+      const key = { namespace: SYMBOL_EMBEDDING_NAMESPACE, model, contentHash: r.textHash };
+      cache.put(key, toFloat32Buffer(r.vector), { dims: r.vector.length });
+    }
+  })();
+}
+async function embedTextsCached(store, embedder, texts) {
+  const hashes = texts.map((t) => hashEmbedText(t));
+  const byHash = loadVectorsByHash(store, embedder.model, hashes);
+  const missing = /* @__PURE__ */ new Map();
+  texts.forEach((text, i) => {
+    if (!byHash.has(hashes[i])) missing.set(hashes[i], text);
+  });
+  const pending = [...missing.entries()];
+  for (let i = 0; i < pending.length; i += EMBED_BATCH_SIZE) {
+    const rows = await embedBatch(embedder, pending.slice(i, i + EMBED_BATCH_SIZE));
+    storeVectors(store, embedder.model, rows);
+    for (const r of rows) byHash.set(r.textHash, r.vector);
+  }
+  return { byHash, newHashes: new Set(missing.keys()) };
+}
+async function embedBatch(embedder, batch) {
+  const vectors = await embedder.embed(batch.map(([, text]) => text), { role: "document" });
+  if (vectors.length !== batch.length) {
+    throw new Error(`Embedder returned ${vectors.length} vectors for ${batch.length} texts`);
+  }
+  return batch.map(([textHash], j) => ({ textHash, vector: normalize(vectors[j]) }));
+}
+
+// src/embeddings/embeddings.ts
+import { BruteForceVectorIndex, vectorRetriever } from "@titan-design/retrieval";
+async function embedSnapshot(store, snapshotId, embedder) {
+  const symbols = listEmbeddableSymbols(store, snapshotId);
+  const { newHashes } = await embedTextsCached(store, embedder, symbols.map((s) => s.text));
+  return {
+    model: embedder.model,
+    symbols: symbols.length,
+    withPurpose: symbols.filter((s) => s.purpose).length,
+    embedded: symbols.length,
+    newlyEmbedded: newHashes.size,
+    reused: symbols.filter((s) => !newHashes.has(s.textHash)).length
+  };
+}
+async function tryEmbedSnapshot(store, snapshotId, embedder) {
+  try {
+    return { ok: true, result: await embedSnapshot(store, snapshotId, embedder) };
+  } catch (err) {
+    return { ok: false, model: embedder.model, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function findSimilarCapability(store, snapshotId, query, embedder, opts = {}) {
+  const symbols = listEmbeddableSymbols(store, snapshotId);
+  const index = buildSymbolIndex(store, embedder.model, symbols);
+  if (index.size === 0) {
+    throw new Error(
+      `No capability embeddings stored for snapshot ${snapshotId} (model ${embedder.model}); run embedSnapshot first.`
+    );
+  }
+  const retriever = vectorRetriever(embedder, index);
+  const hits = await retriever.retrieve(query, { limit: opts.limit ?? 10 });
+  const byId = new Map(symbols.map((s) => [s.id, s]));
+  return {
+    query,
+    model: embedder.model,
+    coverage: { symbols: symbols.length, embedded: index.size, withPurpose: symbols.filter((s) => s.purpose).length },
+    candidates: hits.map((h) => toCandidate(byId.get(h.id), h.score ?? 0))
+  };
+}
+function buildSymbolIndex(store, model, symbols) {
+  const vectors = loadVectorsByHash(store, model, symbols.map((s) => s.textHash));
+  const index = new BruteForceVectorIndex();
+  for (const s of symbols) {
+    const vector = vectors.get(s.textHash);
+    if (vector) index.add(s.id, vector);
+  }
+  return index;
+}
+function toCandidate(s, score) {
+  return { id: s.id, name: s.name, file: s.file, signature: s.signature, purpose: s.purpose, score };
+}
 export {
   ALL_ROLES,
+  COVERAGE_METRIC_NAME,
   CodeGraphStore,
+  DEAD_CODE_METRIC_NAMES,
   DOMAIN_DDL,
+  GROWTH_RISK_METRIC_NAMES,
   INDEX_VERSION,
   KIT,
   LanguageExtractor,
   MIGRATIONS,
   PythonGraphExtractor,
+  SCHEMA_VERSION,
   SOURCE_METRIC_NAMES,
+  SYMBOL_EMBEDDING_NAMESPACE,
   SYMBOL_ID_SEP,
   TsMorphGraphExtractor,
   annotateRoles,
+  attributeCoverage,
   buildAliases,
+  buildEmbedText,
   buildFileModuleNodes,
   buildIndexerMetrics,
   canonicalEdgeKind,
   canonicalMetricName,
   canonicalRole,
+  checkSnapshot,
   classifyRole,
   collectDeclaredNames,
   collectDeclaredSpans,
+  computeDeadCodeMetrics,
+  computeGrowthRiskMetrics,
   computeMetrics,
+  computePageRank,
+  computeRelevance,
   computeRoleHints,
   computeSourceMetrics,
+  computeSymbolConsumers,
+  computeSymbolCoupling,
+  computeTestCoverageOwnership,
   detectGitHead,
   detectGitToplevel,
   detectRenames,
+  diffCheckResults,
+  diffSnapshots,
   edgeWeight,
+  embedSnapshot,
+  embedTextsCached,
   externalId,
   fileId,
-  getLanguageFromPath,
+  findSimilarCapability,
+  getEdgeWeight,
+  getLanguageFromPath3 as getLanguageFromPath,
   getSupportedLanguages,
+  groupTestsBySource,
   hashContent,
+  hashEmbedText,
   indexPaths,
   isGeneratedByHeuristic,
   isGeneratedFile,
   isInsideGitRepo,
+  linkTestsToSources,
   listEdges,
+  listEmbeddableSymbols,
   listMetrics,
   listNodes,
+  loadCheckRules,
   loadGeneratedPatterns,
   moduleId,
   openCodeGraph,
   packageId,
   parentModuleId,
-  parseFile,
+  parseFile2 as parseFile,
   parseSymbolId,
   pruneDanglingReferences,
   readSourceFiles,
   resolveBarrelEdges,
-  shouldIncludeFile,
+  resolveSnapshot,
+  runChecks,
+  shouldIncludeFile2 as shouldIncludeFile,
+  snapshotPageRank,
+  snapshotReferenceEdges,
+  snapshotRelevance,
+  snapshotSymbolConsumers,
+  snapshotSymbolCoupling,
   structuralSignature,
   symbolId,
+  testCoverageCountMetrics,
+  tryEmbedSnapshot,
+  validateRules,
   walkSourceFiles
 };
 //# sourceMappingURL=index.js.map