@titan-design/code-graph 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,5 +1,19 @@
+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";
+import { openDatabase, quoteIdent, runMigrations } from "@titan-design/store-sqlite";
 
 // src/schema.ts
 import { kitMigration } from "@titan-design/store-sqlite";
@@ -48,11 +62,13 @@ var DOMAIN_DDL = `
     PRIMARY KEY (snapshot_id, file_id)
   );
 `;
+var SNAPSHOT_SCOPED_TABLES = ["node", "edge", "metric", "id_alias", "file_fingerprint"];
 var MIGRATIONS = [
   kitMigration(1, { snapshot: KIT.snapshot, entitySnap: KIT.entitySnap, cacheBlob: KIT.cacheBlob }),
   { 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) {
@@ -107,15 +123,81 @@ function rowToFingerprint(row) {
   };
 }
 
+// src/store-reads.ts
+var EDGE_COLS = "src_id, dst_id, kind, attrs";
+var AGGREGATE_SELECT = `SELECT m.name AS name, n.kind AS node_kind, COUNT(m.value) AS count,
+  SUM(m.value) AS sum, MIN(m.value) AS min, MAX(m.value) AS max
+  FROM metric m CROSS JOIN node n ON n.snapshot_id = m.snapshot_id AND n.id = m.node_id`;
+var TOP_SELECT = `SELECT m.node_id, m.value, m.unit, n.kind, n.name, n.role
+  FROM metric m JOIN node n ON n.snapshot_id = m.snapshot_id AND n.id = m.node_id
+  WHERE m.snapshot_id = ? AND m.name = ?`;
+var TOP_ORDER = "ORDER BY m.value DESC LIMIT ?";
+function prepareTargetedStatements(db) {
+  return {
+    listMetricsForNode: db.prepare(
+      "SELECT node_id, name, value, unit FROM metric WHERE snapshot_id = ? AND node_id = ?"
+    ),
+    // The second arm skips self-loops so an edge from a node to itself comes back once.
+    listEdgesTouching: db.prepare(
+      `SELECT ${EDGE_COLS} FROM edge WHERE snapshot_id = @snapshotId AND src_id = @nodeId
+       UNION ALL
+       SELECT ${EDGE_COLS} FROM edge WHERE snapshot_id = @snapshotId AND dst_id = @nodeId AND src_id <> @nodeId`
+    ),
+    aggregateMetric: db.prepare(
+      `${AGGREGATE_SELECT} WHERE m.snapshot_id = ? AND m.name = ? GROUP BY n.kind ORDER BY n.kind`
+    ),
+    aggregateMetrics: db.prepare(
+      `${AGGREGATE_SELECT} WHERE m.snapshot_id = ? GROUP BY m.name, n.kind ORDER BY m.name, n.kind`
+    ),
+    listMetricNames: db.prepare("SELECT DISTINCT name FROM metric WHERE snapshot_id = ? ORDER BY name"),
+    topByMetric: db.prepare(`${TOP_SELECT} ${TOP_ORDER}`),
+    topByMetricOfKind: db.prepare(`${TOP_SELECT} AND n.kind = ? ${TOP_ORDER}`)
+  };
+}
+function readMetricsForNode(stmts, snapshotId, nodeId) {
+  return stmts.listMetricsForNode.all(snapshotId, nodeId).map(rowToMetric);
+}
+function readEdgesTouching(stmts, snapshotId, nodeId) {
+  return stmts.listEdgesTouching.all({ snapshotId, nodeId }).map(rowToEdge);
+}
+function readMetricNames(stmts, snapshotId) {
+  return stmts.listMetricNames.all(snapshotId).map((r) => r.name);
+}
+function readTopByMetric(stmts, opts) {
+  const limit = opts.limit ?? 20;
+  const rows = opts.kind === void 0 ? stmts.topByMetric.all(opts.snapshotId, opts.metric, limit) : stmts.topByMetricOfKind.all(opts.snapshotId, opts.metric, opts.kind, limit);
+  return rows.map((r) => ({
+    nodeId: r.node_id,
+    name: r.name,
+    kind: r.kind,
+    role: r.role,
+    value: r.value,
+    unit: r.unit
+  }));
+}
+function readMetricAggregates(stmts, snapshotId, name) {
+  const rows = name === void 0 ? stmts.aggregateMetrics.all(snapshotId) : stmts.aggregateMetric.all(snapshotId, name);
+  return rows.map((r) => ({
+    name: r.name,
+    nodeKind: r.node_kind,
+    count: r.count,
+    sum: r.sum,
+    min: r.min,
+    max: r.max
+  }));
+}
+
 // src/store.ts
 var NODE_COLS = "id, kind, name, parent_id, language, role, attrs";
 var CodeGraphStore = class {
   constructor(db) {
     this.db = db;
     this.statements = prepareStatements(db);
+    this.targeted = prepareTargetedStatements(db);
   }
   db;
   statements;
+  targeted;
   createSnapshot(input) {
     const result = this.statements.insertSnapshot.run({
       ref: input.ref,
@@ -164,6 +246,21 @@ var CodeGraphStore = class {
       }
     })();
   }
+  /**
+   * Replace every metric of one `name` for a snapshot in a single transaction —
+   * for an overlay such as coverage, which is re-ingested wholesale and must not
+   * accumulate stale rows across runs.
+   */
+  replaceMetricsByName(snapshotId, name, metrics) {
+    const del = this.statements.deleteMetricsByName;
+    const insert = this.statements.insertMetric;
+    this.db.transaction(() => {
+      del.run(snapshotId, name);
+      for (const m of metrics) {
+        insert.run({ snapshotId, nodeId: m.nodeId, name: m.name, value: m.value, unit: m.unit ?? null });
+      }
+    })();
+  }
   insertAliases(snapshotId, aliases) {
     const stmt = this.statements.insertAlias;
     this.db.transaction(() => {
@@ -218,12 +315,53 @@ var CodeGraphStore = class {
   listMetrics(snapshotId) {
     return this.statements.listMetrics.all(snapshotId).map(rowToMetric);
   }
+  /** Every metric on one node, from the primary key instead of a whole-snapshot read. */
+  listMetricsForNode(snapshotId, nodeId) {
+    return readMetricsForNode(this.targeted, snapshotId, nodeId);
+  }
+  /** Distinct metric names stored for a snapshot, ascending. */
+  listMetricNames(snapshotId) {
+    return readMetricNames(this.targeted, snapshotId);
+  }
+  /** The highest-valued nodes for one metric, descending; `limit` defaults to 20. */
+  topByMetric(opts) {
+    return readTopByMetric(this.targeted, opts);
+  }
+  /** Edges into or out of one node; `references` edges are excluded unless asked, as in {@link listEdges}. */
+  listEdgesTouching(snapshotId, nodeId, opts) {
+    const edges = readEdgesTouching(this.targeted, snapshotId, nodeId);
+    return opts?.includeReferences ? edges : edges.filter((e) => e.kind !== "references");
+  }
+  /** Count, sum, min, and max per metric name and node kind; pass `name` for one metric. */
+  aggregateMetrics(snapshotId, opts) {
+    return readMetricAggregates(this.targeted, snapshotId, opts?.name);
+  }
   listAliases(snapshotId) {
     return this.statements.listAliases.all(snapshotId).map(rowToAlias);
   }
   listFingerprints(snapshotId) {
     return this.statements.listFingerprints.all(snapshotId).map(rowToFingerprint);
   }
+  /** Drop whole snapshots. The domain tables carry no foreign key, so each is cleared by hand. */
+  deleteSnapshots(ids) {
+    if (ids.length === 0) return;
+    this.db.transaction(() => {
+      for (const id of ids) {
+        for (const stmt of this.statements.deleteBySnapshot) stmt.run(id);
+      }
+    })();
+  }
+  vacuum() {
+    this.db.exec("VACUUM");
+  }
+  countRowsByTable(tables) {
+    const out = {};
+    for (const table of tables) {
+      const row = this.db.prepare(`SELECT COUNT(*) AS n FROM ${quoteIdent(table)}`).get();
+      out[table] = row.n;
+    }
+    return out;
+  }
   close() {
     this.db.close();
   }
@@ -266,130 +404,54 @@ function prepareStatements(db) {
     listAliases: db.prepare("SELECT old_id, new_id, reason FROM id_alias WHERE snapshot_id = ?"),
     listFingerprints: db.prepare(
       "SELECT file_id, content_hash, structural_hash FROM file_fingerprint WHERE snapshot_id = ?"
+    ),
+    deleteMetricsByName: db.prepare("DELETE FROM metric WHERE snapshot_id = ? AND name = ?"),
+    deleteBySnapshot: [...SNAPSHOT_SCOPED_TABLES, "snapshot"].map(
+      (table) => db.prepare(`DELETE FROM ${quoteIdent(table)} WHERE ${table === "snapshot" ? "id" : "snapshot_id"} = ?`)
     )
   };
 }
 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;
+// src/prune.ts
+var CASCADE_TABLES = SNAPSHOT_SCOPED_TABLES;
+function planPrune(store, options = {}) {
+  const keepCount = options.keep ?? 10;
+  const keepRefs = new Set(options.keepRefs ?? []);
+  const all = store.listSnapshots({ limit: 1e6 });
+  const keep = [];
+  const remove = [];
+  for (let i = 0; i < all.length; i++) {
+    const snap = all[i];
+    if (i < keepCount || keepRefs.has(snap.ref)) {
+      keep.push(snap);
+    } else {
+      remove.push(snap);
     }
   }
-  return null;
+  return { keep, remove };
+}
+function runPrune(store, options = {}) {
+  const plan = planPrune(store, options);
+  const tables = ["snapshot", ...CASCADE_TABLES];
+  const rowsBefore = store.countRowsByTable(tables);
+  store.deleteSnapshots(plan.remove.map((s) => s.id));
+  if (options.vacuum) store.vacuum();
+  const rowsAfter = store.countRowsByTable(tables);
+  return { plan, rowsBefore, rowsAfter, vacuumed: !!options.vacuum };
 }
 
+// src/indexer.ts
+import { realpathSync } from "fs";
+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 +461,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 +490,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 +520,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 +597,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 step2 = (node, scope) => {
+    visit(node, scope);
+    const inner = enter(scope, scopeSegment(node, python));
+    for (const child of node.children) {
+      if (child) step2(child, inner);
+    }
+  };
+  step2(root, "");
+}
+
 // src/declared-names.ts
 var TS_DECL_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
@@ -541,22 +663,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 +878,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 +900,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 +1152,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 +1162,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 +1203,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 +1214,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 +1224,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,16 +1257,15 @@ 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 resolveGitRef(repoRoot, ref) {
+  return runGit(repoRoot, ["rev-parse", ref]);
 }
 function detectRenames(options) {
   const threshold = options.similarityThreshold ?? 80;
@@ -1172,12 +1298,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 +1321,164 @@ 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;
+
+// src/identity/lineage.ts
+var ALIAS_BASE_ATTR = "aliasBase";
+var DEFAULT_MAX_HOPS = 1e4;
+function recordedBase(snap) {
+  if (!(ALIAS_BASE_ATTR in snap.attrs)) return void 0;
+  const base = snap.attrs[ALIAS_BASE_ATTR];
+  return typeof base === "number" && base < snap.id ? base : null;
+}
+function buildLineage(snapshots) {
+  const out = /* @__PURE__ */ new Map();
+  let lastWithCommit = null;
+  for (const snap of [...snapshots].sort((a, b) => a.id - b.id)) {
+    const recorded = recordedBase(snap);
+    out.set(snap.id, recorded === void 0 ? lastWithCommit : recorded);
+    if (snap.commitHash) lastWithCommit = snap.id;
+  }
+  return out;
 }
-function runGit(cwd, args) {
-  try {
-    return execFileSync("git", [...args], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      env: discoveryEnv()
-    }).trim();
-  } catch {
-    return null;
+function ancestry(lineage, snapshotId, maxHops = DEFAULT_MAX_HOPS) {
+  const out = [];
+  let current = snapshotId;
+  while (current !== null && current !== void 0 && out.length <= maxHops) {
+    out.push(current);
+    current = lineage.get(current);
+  }
+  return out;
+}
+function lineagePath(lineage, fromId, toId, maxHops = DEFAULT_MAX_HOPS) {
+  const up = ancestry(lineage, fromId, maxHops);
+  const down = ancestry(lineage, toId, maxHops);
+  const upIndex = new Map(up.map((id, i) => [id, i]));
+  const meet = down.findIndex((id) => upIndex.has(id));
+  if (meet < 0) return null;
+  const backward = up.slice(0, upIndex.get(down[meet])).map((id) => step(id, "backward"));
+  const forward = down.slice(0, meet).reverse().map((id) => step(id, "forward"));
+  return [...backward, ...forward];
+}
+function rootPath(lineage, toId, maxHops = DEFAULT_MAX_HOPS) {
+  return ancestry(lineage, toId, maxHops).reverse().map((id) => step(id, "forward"));
+}
+function step(snapshotId, direction) {
+  return { snapshotId, direction };
+}
+
+// src/identity/alias-chain.ts
+function stepMap(aliases, direction) {
+  const byId = /* @__PURE__ */ new Map();
+  const sorted = [...aliases].sort((a, b) => compare(a.oldId, b.oldId) || compare(a.newId, b.newId));
+  for (const alias of sorted) {
+    const key = direction === "forward" ? alias.oldId : alias.newId;
+    if (!byId.has(key)) byId.set(key, alias);
+  }
+  return { direction, byId };
+}
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function overallReason(hops) {
+  if (hops.length === 0) return void 0;
+  return hops.some((h) => h.reason === "move") ? "move" : hops[hops.length - 1].reason;
+}
+function walk(requestedId, maps) {
+  let id = requestedId;
+  const hops = [];
+  for (const { direction, byId } of maps) {
+    const alias = byId.get(id);
+    if (!alias) continue;
+    hops.push(alias);
+    id = direction === "forward" ? alias.newId : alias.oldId;
+  }
+  return { requestedId, id, hops, reason: overallReason(hops) };
+}
+function chainSteps(input) {
+  if (input.from === null) return { steps: rootPath(input.lineage, input.to, input.maxHops), connected: true };
+  const path11 = lineagePath(input.lineage, input.from, input.to, input.maxHops);
+  if (path11) return { steps: path11, connected: true };
+  return { steps: [{ snapshotId: input.to, direction: "forward" }], connected: false };
+}
+function createAliasChain(input) {
+  const { steps, connected } = chainSteps(input);
+  const maps = steps.map((s) => stepMap(input.loadAliases(s.snapshotId), s.direction));
+  const cache = /* @__PURE__ */ new Map();
+  const trace = (id) => {
+    let hit = cache.get(id);
+    if (!hit) cache.set(id, hit = walk(id, maps));
+    return hit;
+  };
+  return { fromSnapshotId: input.from, toSnapshotId: input.to, connected, steps, resolve: (id) => trace(id).id, trace };
+}
+
+// src/identity/store-identity.ts
+function allSnapshots(store) {
+  return store.db.prepare("SELECT * FROM snapshot ORDER BY id").all().map(rowToSnapshot);
+}
+function loadLineage(store) {
+  return buildLineage(allSnapshots(store));
+}
+function aliasChain(store, fromSnapshotId, toSnapshotId, options = {}) {
+  return createAliasChain({
+    lineage: loadLineage(store),
+    loadAliases: (id) => store.listAliases(id),
+    from: fromSnapshotId,
+    to: toSnapshotId,
+    maxHops: options.maxHops
+  });
+}
+function resolveAlias(store, id, toSnapshotId, options = {}) {
+  return aliasChain(store, options.fromSnapshotId ?? null, toSnapshotId, options).trace(id);
+}
+function priorSnapshotForRef(store, ref, options = {}) {
+  const before = options.before ?? Number.POSITIVE_INFINITY;
+  const candidates2 = allSnapshots(store).filter((s) => s.id < before).reverse();
+  const commit = options.repoRoot ? resolveGitRef(options.repoRoot, `${ref}^{commit}`) : null;
+  const byCommit = commit ? candidates2.find((s) => s.commitHash === commit) : void 0;
+  return byCommit ?? candidates2.find((s) => s.ref === ref) ?? null;
+}
+function aliasBaseFor(store, ref) {
+  const committed = allSnapshots(store).filter((s) => s.commitHash).reverse();
+  return committed.find((s) => s.ref === ref) ?? committed[0] ?? null;
+}
+
+// src/identity/index-aliases.ts
+var SYMBOLS_OF_FILE = `SELECT id FROM node
+  WHERE snapshot_id = ? AND id >= ? AND id < ? AND kind = 'symbol'`;
+function symbolIdsOf(store, snapshotId, fileId2) {
+  const rows = store.db.prepare(SYMBOLS_OF_FILE).all(snapshotId, `${fileId2}#`, `${fileId2}$`);
+  return rows.map((r) => r.id);
+}
+function movedSymbolAliases(store, baseSnapshotId, fileAliases, nodes) {
+  const out = [];
+  for (const alias of fileAliases) {
+    if (nodes.get(alias.newId)?.kind !== "file") continue;
+    for (const oldId of symbolIdsOf(store, baseSnapshotId, alias.oldId)) {
+      const newId = alias.newId + SYMBOL_ID_SEP + oldId.slice(alias.oldId.length + 1);
+      if (nodes.get(newId)?.kind === "symbol") out.push({ oldId, newId, reason: alias.reason });
+    }
   }
+  return out;
+}
+function renameAliases(input, baseCommit) {
+  if (input.detectRenames === false || !isInsideGitRepo(input.rootDir)) return [];
+  const target = input.commitHash ?? detectGitHead(input.rootDir) ?? void 0;
+  if (target === baseCommit) return [];
+  const pairs = detectRenames({ repoRoot: input.rootDir, fromCommit: baseCommit, toCommit: target });
+  return buildAliases(input.idRoot, pairs);
+}
+function computeAliasBridge(store, input) {
+  const base = aliasBaseFor(store, input.ref);
+  if (!base?.commitHash) return { baseSnapshotId: null, aliases: [] };
+  const fileAliases = renameAliases(input, base.commitHash);
+  const symbols = movedSymbolAliases(store, base.id, fileAliases, input.nodes);
+  return { baseSnapshotId: base.id, aliases: [...fileAliases, ...symbols] };
 }
 
 // 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 +1490,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 +1593,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 +1683,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 +2075,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 +2130,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 walk2 = (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) walk2(child);
+    }
+  };
+  walk2(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 walk2 = (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) walk2(child);
+    }
+  };
+  walk2(fn);
+}
+function countReferences(fn, declIds, out) {
+  const walk2 = (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) walk2(child);
+    }
+  };
+  walk2(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 +2433,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 +2530,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,12 +2675,205 @@ function computeMetrics(nodes, edges) {
   return out;
 }
 
-// src/index-metrics.ts
-function symbolNamesByFile(nodes) {
-  const out = /* @__PURE__ */ new Map();
+// 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 !== "symbol" || !n.parentId) continue;
-    const bucket = out.get(n.parentId);
+    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();
+  for (const n of nodes) {
+    if (n.kind !== "symbol" || !n.parentId) continue;
+    const bucket = out.get(n.parentId);
     if (bucket) bucket.add(n.name);
     else out.set(n.parentId, /* @__PURE__ */ new Set([n.name]));
   }
@@ -2176,6 +2881,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 +2889,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,8 +2924,45 @@ function mergeFragments(fragments) {
   return { nodes, edges };
 }
 
+// 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 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.11.0";
+var INDEX_VERSION = "0.15.0";
 var LANGUAGES = ["typescript", "python"];
 function canonicalizePath(p) {
   try {
@@ -2216,32 +2973,28 @@ function canonicalizePath(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 = {};
   for (const item of items) out[item.kind] = (out[item.kind] ?? 0) + 1;
   return out;
 }
-function persist(store, ref, commitHash, accumulator, aliases, metrics) {
-  const snapshotId = store.createSnapshot({ ref, commitHash, indexVersion: INDEX_VERSION });
+function persist(store, snapshot, accumulator, aliases, metrics) {
+  const { ref, commitHash, aliasBase } = snapshot;
+  const attrs = { [ALIAS_BASE_ATTR]: aliasBase };
+  const snapshotId = store.createSnapshot({ ref, commitHash, indexVersion: INDEX_VERSION, attrs });
   store.insertNodes(snapshotId, [...accumulator.nodes.values()]);
   store.insertEdges(snapshotId, [...accumulator.edges.values()]);
   if (aliases.length > 0) store.insertAliases(snapshotId, aliases);
   if (metrics.length > 0) store.insertMetrics(snapshotId, metrics);
   return snapshotId;
 }
-function findPriorCommit(store) {
-  return store.listSnapshots({ limit: 50 }).find((s) => s.commitHash)?.commitHash ?? null;
-}
-function resolveAliases(rootDir, idRoot, options, store) {
-  if (options.detectRenames === false) return [];
-  if (!isInsideGitRepo(rootDir)) return [];
-  const priorCommit = findPriorCommit(store);
-  if (!priorCommit) return [];
-  const target = options.commitHash ?? detectGitHead(rootDir) ?? void 0;
-  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);
@@ -2256,6 +3009,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,12 +3043,19 @@ 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 ref = options.ref ?? "wd";
+  const bridge = computeAliasBridge(store, { ...options, rootDir, idRoot, ref, nodes: accumulator.nodes });
+  const aliases = [
+    ...bridge.aliases,
+    ...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);
+  const snapshot = { ref, commitHash, aliasBase: bridge.baseSnapshotId };
+  const snapshotId = persist(store, snapshot, accumulator, aliases, metrics);
   store.insertFingerprints(snapshotId, buildFingerprints(readFiles, idRoot, classified.structuralByFileId));
   return {
     snapshotId,
@@ -2305,6 +3072,146 @@ 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/extractors/deep-ast.ts
+import { readFileSync as readFileSync2 } from "fs";
+import * as path10 from "path";
+import {
+  Node as Node4,
+  Project as Project2,
+  ScriptTarget as ScriptTarget2
+} from "ts-morph";
+function computeDeepAst(input) {
+  const sf = loadSourceFile(input.absPath);
+  if (!sf) return null;
+  const target = input.symbolName ? `${input.filePath}#${input.symbolName}` : input.filePath;
+  return input.symbolName ? symbolDeepAst(sf, input.symbolName, target) : fileDeepAst(sf, target);
+}
+function loadSourceFile(absPath) {
+  try {
+    const text = readFileSync2(absPath, "utf8");
+    const project = new Project2({
+      useInMemoryFileSystem: true,
+      compilerOptions: { target: ScriptTarget2.Latest, allowJs: true }
+    });
+    return project.createSourceFile(`f${path10.extname(absPath) || ".ts"}`, text);
+  } catch {
+    return null;
+  }
+}
+function symbolDeepAst(sf, name, target) {
+  const decl = lookupDeclaration(sf, name);
+  if (!decl) {
+    return { ...empty(target, "symbol"), note: "declaration not found in source" };
+  }
+  const text = declarationText(decl);
+  return {
+    target,
+    kind: "symbol",
+    declarationKind: decl.getKindName(),
+    signature: text.signature ?? null,
+    purpose: text.purpose ?? null,
+    params: paramsOf(decl),
+    returnType: returnTypeOf(decl),
+    members: membersOf(decl)
+  };
+}
+function fileDeepAst(sf, target) {
+  return {
+    ...empty(target, "file"),
+    declarationKind: "SourceFile",
+    members: exportedDeclarations(sf)
+  };
+}
+function empty(target, kind) {
+  return {
+    target,
+    kind,
+    declarationKind: null,
+    signature: null,
+    purpose: null,
+    params: [],
+    returnType: null,
+    members: []
+  };
+}
+function callableOf(decl) {
+  if (Node4.isFunctionDeclaration(decl) || Node4.isMethodDeclaration(decl)) return decl;
+  if (Node4.isVariableDeclaration(decl)) {
+    const init = decl.getInitializer();
+    if (init && (Node4.isArrowFunction(init) || Node4.isFunctionExpression(init))) return init;
+  }
+  return null;
+}
+function paramsOf(decl) {
+  const callable = callableOf(decl);
+  if (!callable) return [];
+  return callable.getParameters().map((p) => ({
+    name: p.getName(),
+    type: p.getTypeNode()?.getText() ?? null
+  }));
+}
+function returnTypeOf(decl) {
+  return callableOf(decl)?.getReturnTypeNode()?.getText() ?? null;
+}
+function membersOf(decl) {
+  if (Node4.isClassDeclaration(decl)) return classMembers(decl);
+  if (Node4.isInterfaceDeclaration(decl)) return interfaceMembers(decl);
+  return [];
+}
+function classMembers(cls) {
+  return cls.getMembers().map((m) => ({
+    name: memberName(m),
+    memberKind: m.getKindName(),
+    signature: memberSignature(m),
+    isStatic: Node4.isStaticable(m) ? m.isStatic() : false
+  }));
+}
+function interfaceMembers(iface) {
+  return iface.getMembers().map((m) => ({
+    name: memberName(m),
+    memberKind: m.getKindName(),
+    signature: memberSignature(m),
+    isStatic: false
+  }));
+}
+function exportedDeclarations(sf) {
+  const out = [];
+  for (const [name, decls] of sf.getExportedDeclarations()) {
+    const decl = decls[0];
+    if (!decl) continue;
+    out.push({
+      name,
+      memberKind: decl.getKindName(),
+      signature: declarationText(decl).signature ?? memberSignature(decl),
+      isStatic: false
+    });
+  }
+  return out;
+}
+function memberName(m) {
+  if (Node4.isConstructorDeclaration(m)) return "constructor";
+  return Node4.hasName(m) ? m.getName() : "";
+}
+function memberSignature(m) {
+  if (Node4.isMethodDeclaration(m) || Node4.isMethodSignature(m) || Node4.isConstructorDeclaration(m)) {
+    const params = m.getParameters().map((p) => oneLine2(p.getText())).join(", ");
+    const ret = m.getReturnTypeNode()?.getText();
+    const name = Node4.isConstructorDeclaration(m) ? "constructor" : memberName(m);
+    return oneLine2(`${name}(${params})${ret ? `: ${ret}` : ""}`);
+  }
+  if (Node4.isPropertyDeclaration(m) || Node4.isPropertySignature(m)) {
+    const type = m.getTypeNode()?.getText();
+    return oneLine2(`${memberName(m)}${type ? `: ${type}` : ""}`);
+  }
+  return null;
+}
+function oneLine2(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+
 // src/aliases.ts
 var METRIC_ALIASES = /* @__PURE__ */ new Map([
   ["lines", "loc"],
@@ -2334,6 +3241,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,71 +3253,1912 @@ 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/read.ts
-function listNodes(store, snapshotId, opts) {
-  return store.listNodes(snapshotId, opts);
+// 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 listEdges(store, snapshotId, opts) {
-  return store.listEdges(snapshotId, opts);
+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 listMetrics(store, snapshotId) {
-  return store.listMetrics(snapshotId);
+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/partition-quality.ts
+var FOUNDATION_INSTABILITY_MAX = 0.3;
+var TOP_INSTABILITY_MIN = 0.9;
+var WEAK_COHESION_MAX = 0.5;
+var TIGHT_INTENSITY_MIN = 0.6;
+var MODERATE_INTENSITY_MIN = 0.3;
+function computePartitionQuality(input) {
+  const resolveBarrels = input.resolveBarrels ?? false;
+  const pkgByFile = invertBuckets(input.fileByPackage);
+  const barrelTargets = resolveBarrels ? buildBarrelTargetMap(input.nodes, input.edges) : /* @__PURE__ */ new Map();
+  const resolvedPairs = buildResolvedPairs(
+    input.edges,
+    pkgByFile,
+    barrelTargets,
+    resolveBarrels
+  );
+  const counts = countByPackage(resolvedPairs);
+  const totalEdges = resolvedPairs.length;
+  const filesByPkg = filesPerPackage(input.fileByPackage);
+  const abstractByPkg = countAbstractFiles(input.nodes, pkgByFile);
+  const perPackage = input.packages.map(
+    (p) => buildPackageStats(p.id, counts, filesByPkg, abstractByPkg)
+  );
+  const pairCoupling = buildPairCoupling(resolvedPairs, filesByPkg);
+  const modularityQ = computeModularity(perPackage, totalEdges);
+  const flagsCount = perPackage.reduce((acc, p) => acc + p.flags.length, 0) + pairCoupling.filter((c) => c.flag === "tight").length;
+  return { modularityQ, totalEdges, perPackage, pairCoupling, flagsCount };
+}
+function invertBuckets(fileByPackage) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [pkgId, files] of fileByPackage) {
+    if (pkgId === "") continue;
+    for (const f of files) out.set(f, pkgId);
+  }
+  return out;
+}
+function filesPerPackage(fileByPackage) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [pkgId, files] of fileByPackage) {
+    out.set(pkgId, files.length);
+  }
+  return out;
+}
+function buildBarrelTargetMap(nodes, edges) {
+  const barrelIds = new Set(
+    nodes.filter((n) => n.role === "barrel").map((n) => n.id)
+  );
+  if (barrelIds.size === 0) return /* @__PURE__ */ new Map();
+  const directReExports = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (!barrelIds.has(e.srcId)) continue;
+    if (e.kind !== "re-exports") continue;
+    let list = directReExports.get(e.srcId);
+    if (!list) {
+      list = [];
+      directReExports.set(e.srcId, list);
+    }
+    list.push(e.dstId);
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  const resolve4 = (barrel, visiting) => {
+    if (resolved.has(barrel)) return resolved.get(barrel);
+    if (visiting.has(barrel)) return [];
+    visiting.add(barrel);
+    const out = [];
+    for (const target of directReExports.get(barrel) ?? []) {
+      if (barrelIds.has(target)) {
+        for (const inner of resolve4(target, visiting)) out.push(inner);
+      } else {
+        out.push(target);
+      }
+    }
+    visiting.delete(barrel);
+    resolved.set(barrel, out);
+    return out;
+  };
+  for (const id of barrelIds) resolve4(id, /* @__PURE__ */ new Set());
+  return resolved;
+}
+function buildResolvedPairs(edges, pkgByFile, barrelTargets, resolveBarrels) {
+  const out = [];
+  for (const e of edges) {
+    if (resolveBarrels && e.kind === "re-exports") continue;
+    const fromPkg = pkgByFile.get(e.srcId);
+    if (!fromPkg) continue;
+    const targets = barrelTargets.get(e.dstId) ?? [e.dstId];
+    for (const dst of targets) {
+      const toPkg = pkgByFile.get(dst);
+      if (toPkg) out.push({ from: fromPkg, to: toPkg });
+    }
+  }
+  return out;
+}
+function countByPackage(pairs) {
+  const out = /* @__PURE__ */ new Map();
+  const get = (id) => {
+    let c = out.get(id);
+    if (!c) {
+      c = { internal: 0, outgoing: 0, incoming: 0 };
+      out.set(id, c);
+    }
+    return c;
+  };
+  for (const p of pairs) {
+    if (p.from === p.to) {
+      get(p.from).internal += 1;
+    } else {
+      get(p.from).outgoing += 1;
+      get(p.to).incoming += 1;
+    }
+  }
+  return out;
+}
+function buildPackageStats(pkgId, counts, filesByPkg, abstractByPkg) {
+  const c = counts.get(pkgId) ?? { internal: 0, outgoing: 0, incoming: 0 };
+  const cohesion = ratioOrZero(c.internal, c.internal + c.outgoing);
+  const instability = ratioOrZero(c.outgoing, c.outgoing + c.incoming);
+  const fileCount = filesByPkg.get(pkgId) ?? 0;
+  const abstractness = ratioOrZero(abstractByPkg.get(pkgId) ?? 0, fileCount);
+  const layer = classifyLayer(instability);
+  const flags = [];
+  if (layer !== "top" && cohesion < WEAK_COHESION_MAX && c.internal + c.outgoing > 0) {
+    flags.push("weak-boundary");
+  }
+  return {
+    pkgId,
+    fileCount,
+    internalEdges: c.internal,
+    outgoingEdges: c.outgoing,
+    incomingEdges: c.incoming,
+    cohesion,
+    instability,
+    abstractness,
+    layer,
+    flags
+  };
+}
+function countAbstractFiles(nodes, pkgByFile) {
+  const out = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.kind !== "file" || n.role !== "types") continue;
+    const pkg = pkgByFile.get(n.id);
+    if (pkg) out.set(pkg, (out.get(pkg) ?? 0) + 1);
+  }
+  return out;
+}
+function ratioOrZero(num, denom) {
+  return denom === 0 ? 0 : num / denom;
+}
+function classifyLayer(instability) {
+  if (instability <= FOUNDATION_INSTABILITY_MAX) return "foundation";
+  if (instability >= TOP_INSTABILITY_MIN) return "top";
+  return "middle";
+}
+function buildPairCoupling(pairs, filesByPkg) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const p of pairs) {
+    if (p.from === p.to) continue;
+    const key = JSON.stringify([p.from, p.to]);
+    const entry = counts.get(key);
+    if (entry) entry.edges += 1;
+    else counts.set(key, { from: p.from, to: p.to, edges: 1 });
+  }
+  const out = [];
+  for (const { from, to, edges } of counts.values()) {
+    const filesFrom = filesByPkg.get(from) ?? 0;
+    const intensity = filesFrom === 0 ? 0 : edges / filesFrom;
+    const flag = classifyPairIntensity(intensity);
+    out.push({ from, to, edges, intensity, flag });
+  }
+  return out.sort(comparePairs2);
+}
+function classifyPairIntensity(intensity) {
+  if (intensity >= TIGHT_INTENSITY_MIN) return "tight";
+  if (intensity >= MODERATE_INTENSITY_MIN) return "moderate";
+  return "none";
+}
+function comparePairs2(a, b) {
+  if (a.from !== b.from) return a.from < b.from ? -1 : 1;
+  return a.to < b.to ? -1 : 1;
+}
+function computeModularity(perPackage, totalEdges) {
+  if (totalEdges === 0) return 0;
+  let Q = 0;
+  for (const p of perPackage) {
+    const e_cc = p.internalEdges / totalEdges;
+    const touching = p.internalEdges * 2 + p.outgoingEdges + p.incomingEdges;
+    const a_c = touching / (2 * totalEdges);
+    Q += e_cc - a_c * a_c;
+  }
+  return Q;
+}
+
+// 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) {
+  return store.listNodes(snapshotId, opts);
+}
+function listEdges(store, snapshotId, opts) {
+  return store.listEdges(snapshotId, opts);
+}
+function listMetrics(store, snapshotId) {
+  return store.listMetrics(snapshotId);
+}
+function listMetricsForNode(store, snapshotId, nodeId) {
+  return store.listMetricsForNode(snapshotId, nodeId);
+}
+function listEdgesTouching(store, snapshotId, nodeId, opts) {
+  return store.listEdgesTouching(snapshotId, nodeId, opts);
+}
+function aggregateMetrics(store, snapshotId, opts) {
+  return store.aggregateMetrics(snapshotId, opts);
+}
+
+// src/catalogue/entries.ts
+var FILE = ["file"];
+var SYMBOL = ["symbol"];
+var STRUCTURAL = ["file", "module", "external"];
+var DEGREE = [
+  {
+    name: "fan_in",
+    unit: "count",
+    appliesTo: STRUCTURAL,
+    rollup: "none",
+    direction: "neutral",
+    absent: "zero",
+    source: "degree",
+    description: "Import and re-export edges into the node. Summing over a group would count its internal edges."
+  },
+  {
+    name: "fan_out",
+    unit: "count",
+    appliesTo: STRUCTURAL,
+    rollup: "none",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "degree",
+    description: "Import and re-export edges out of the node. Summing over a group would count its internal edges."
+  },
+  {
+    name: "instability",
+    unit: "ratio",
+    appliesTo: STRUCTURAL,
+    rollup: "none",
+    direction: "neutral",
+    absent: "exclude",
+    source: "degree",
+    description: "fan_out / (fan_in + fan_out); written only when the node has an import edge."
+  },
+  {
+    name: "utilization",
+    unit: "count",
+    appliesTo: [...STRUCTURAL, "symbol"],
+    rollup: "none",
+    direction: "neutral",
+    absent: "zero",
+    source: "degree",
+    description: "Inbound edges weighted by reference count over the barrel-resolved graph: how heavily a node is used."
+  }
+];
+var SOURCE = [
+  {
+    name: "loc",
+    unit: "lines",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "source-metrics",
+    description: "Non-blank lines in the file."
+  },
+  {
+    name: "function_count",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "neutral",
+    absent: "zero",
+    source: "source-metrics",
+    description: "Functions, methods, and arrow functions declared in the file."
+  },
+  {
+    name: "cyclomatic_max",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Highest cyclomatic complexity of any function in the file."
+  },
+  {
+    name: "cyclomatic_sum",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "source-metrics",
+    description: "Cyclomatic complexity summed over the file's functions."
+  },
+  {
+    name: "cognitive_max",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Highest cognitive complexity of any function in the file."
+  },
+  {
+    name: "cognitive_sum",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "source-metrics",
+    description: "Cognitive complexity summed over the file's functions."
+  },
+  {
+    name: "max_nesting_depth",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Deepest block nesting inside any function in the file."
+  },
+  {
+    name: "symbol_cognitive",
+    unit: "count",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Cognitive complexity of the function a symbol names; the max when several functions share the name."
+  },
+  {
+    name: "symbol_cyclomatic",
+    unit: "count",
+    appliesTo: SYMBOL,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "source-metrics",
+    description: "Cyclomatic complexity of the function a symbol names; the max when several functions share the name."
+  },
+  {
+    name: "class_count",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "neutral",
+    absent: "zero",
+    source: "lcom",
+    description: "Classes declared in the file; written only when there is one."
+  },
+  {
+    name: "lcom4_max",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "lcom",
+    description: "Highest LCOM4 of any class in the file; above 1 means the class could split."
+  }
+];
+var SMELLS = [
+  {
+    name: "unreachable_statements",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "dead-code",
+    description: "Statements after an unconditional return, throw, break, or continue. TypeScript only."
+  },
+  {
+    name: "unused_locals",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "dead-code",
+    description: "Local bindings never read. TypeScript only."
+  },
+  {
+    name: "unused_params",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "dead-code",
+    description: "Trailing parameters never read. TypeScript only."
+  },
+  {
+    name: "loop_depth",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "max",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "growth-risk",
+    description: "Deepest lexical loop nesting; written at 2 or more."
+  },
+  {
+    name: "recursive_functions",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "growth-risk",
+    description: "Functions that call themselves by name. TypeScript only."
+  },
+  {
+    name: "search_in_loop",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "higher-worse",
+    absent: "zero",
+    source: "growth-risk",
+    description: "Linear searches such as .includes or .find inside a loop. TypeScript only."
+  }
+];
+var HISTORY = [
+  {
+    name: "churn_{w}",
+    unit: "lines",
+    appliesTo: FILE,
+    rollup: "sum",
+    direction: "neutral",
+    absent: "zero",
+    source: "history",
+    windowed: true,
+    description: "Lines added plus deleted in the {w} window."
+  },
+  {
+    name: "churn_{w}_commits",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "neutral",
+    absent: "zero",
+    source: "history",
+    windowed: true,
+    description: "Commits touching the file in the {w} window. A group's distinct commits are not the sum."
+  },
+  {
+    name: "churn_{w}_authors",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "neutral",
+    absent: "zero",
+    source: "history",
+    windowed: true,
+    description: "Distinct authors of the file's commits in the {w} window. Not additive."
+  },
+  {
+    name: "recency_{w}",
+    unit: "ratio",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "neutral",
+    absent: "exclude",
+    source: "history",
+    windowed: true,
+    description: "min(1, file age / window) for a file that churned in the {w} window; 1 for lifetime. A hotspot discount."
+  },
+  {
+    name: "file_age_days",
+    unit: "days",
+    appliesTo: FILE,
+    rollup: "max",
+    direction: "neutral",
+    absent: "exclude",
+    source: "history",
+    description: "Days since the file first appeared in git history."
+  },
+  {
+    name: "bus_factor_{w}",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "lower-worse",
+    absent: "exclude",
+    source: "history",
+    windowed: true,
+    description: "Fewest authors covering half the file's churn in the {w} window."
+  },
+  {
+    name: "top_author_share_{w}",
+    unit: "ratio",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "history",
+    windowed: true,
+    description: "Share of the file's churn in the {w} window written by its top author."
+  }
+];
+var TESTS = [
+  {
+    name: "linked_test_count",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "lower-worse",
+    absent: "zero",
+    source: "test-linker",
+    description: "Test files linked to this source. One test can link to several sources, so it does not sum."
+  },
+  {
+    name: "test_bus_factor_{w}",
+    unit: "count",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "lower-worse",
+    absent: "exclude",
+    source: "test-linker",
+    windowed: true,
+    description: "Bus factor of the churn on this source's linked tests in the {w} window."
+  },
+  {
+    name: "test_top_author_share_{w}",
+    unit: "ratio",
+    appliesTo: FILE,
+    rollup: "none",
+    direction: "higher-worse",
+    absent: "exclude",
+    source: "test-linker",
+    windowed: true,
+    description: "Top author's share of the churn on this source's linked tests in the {w} window."
+  },
+  {
+    name: "coverage_pct",
+    unit: "percent",
+    appliesTo: ["file", "symbol"],
+    rollup: "none",
+    direction: "lower-worse",
+    absent: "exclude",
+    source: "coverage",
+    description: "Functions covered over functions total, from an ingested Istanbul report. Never written by the indexer."
+  }
+];
+var METRIC_CATALOGUE = [...DEGREE, ...SOURCE, ...SMELLS, ...HISTORY, ...TESTS];
+
+// src/catalogue/describe.ts
+var WINDOW_TOKEN = "{w}";
+var WINDOW_PATTERN = "(\\d+d|lifetime)";
+var BY_NAME = new Map(METRIC_CATALOGUE.filter((d) => !d.windowed).map((d) => [d.name, d]));
+var WINDOWED = METRIC_CATALOGUE.filter((d) => d.windowed).map((template) => ({
+  pattern: new RegExp(`^${template.name.replace(WINDOW_TOKEN, WINDOW_PATTERN)}$`),
+  template
+}));
+function resolveWindow(template, window) {
+  const resolved = {
+    ...template,
+    name: template.name.replace(WINDOW_TOKEN, window),
+    description: template.description.replace(WINDOW_TOKEN, window),
+    window
+  };
+  delete resolved.windowed;
+  return resolved;
+}
+function describeMetric(name) {
+  const exact = BY_NAME.get(name);
+  if (exact) return exact;
+  for (const { pattern, template } of WINDOWED) {
+    const match = pattern.exec(name);
+    if (match) return resolveWindow(template, match[1]);
+  }
+  return null;
+}
+function describeMetrics(names) {
+  const described = [];
+  const unknown = [];
+  for (const name of new Set(names)) {
+    const descriptor = describeMetric(name);
+    if (descriptor) described.push(descriptor);
+    else unknown.push(name);
+  }
+  return { described, unknown };
+}
+
+// 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.snapshotId, 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 snapshotViolations(store, snapshotId, rules) {
+  const ctx = buildRuleContext(store, snapshotId);
+  return rules.flatMap((rule) => runRule(rule, ctx));
+}
+function collectBaselineKeys(store, baselineSnapshotId, snapshotId, rules) {
+  const ctx = buildRuleContext(store, baselineSnapshotId);
+  const chain = aliasChain(store, baselineSnapshotId, snapshotId);
+  const keys = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    for (const v of runRule(rule, ctx)) keys.add(rebasedViolationKey(v, chain.resolve));
+  }
+  return keys;
+}
+function violationKey(v) {
+  return v.destinationId ? `${v.ruleId}|${v.nodeId}|${v.destinationId}` : `${v.ruleId}|${v.nodeId}`;
+}
+function rebasedViolationKey(v, resolve4) {
+  const destinationId = v.destinationId ? resolve4(v.destinationId) : v.destinationId;
+  return violationKey({ ...v, nodeId: resolve4(v.nodeId), destinationId });
+}
+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(path11, options = {}) {
+  let raw;
+  try {
+    raw = await readFile2(path11, "utf8");
+  } catch (err) {
+    throw new Error(`Cannot read rules file at ${path11}: ${errorMessage(err)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${path11}: ${errorMessage(err)}`);
+  }
+  return validateRules(parsed, options);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/diff/diff.ts
+function resolveId(id, aliases) {
+  return aliases.resolve(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.trace(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 = aliasChain(store, fromSnapshotId, 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 });
+  const chain = aliasChain(store, options.fromSnapshotId, options.toSnapshotId);
+  return {
+    fromSnapshotId: options.fromSnapshotId,
+    toSnapshotId: options.toSnapshotId,
+    rulesEvaluated: options.rules.length,
+    ...bucketViolations(indexByKey(from.violations, chain.resolve), 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, resolve4) {
+  const out = /* @__PURE__ */ new Map();
+  for (const v of violations) out.set(resolve4 ? rebasedViolationKey(v, resolve4) : 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 {
+  ALIAS_BASE_ATTR,
   ALL_ROLES,
+  COVERAGE_METRIC_NAME,
   CodeGraphStore,
+  DEAD_CODE_METRIC_NAMES,
+  DEFAULT_CHURN_WINDOWS,
   DOMAIN_DDL,
+  GROWTH_RISK_METRIC_NAMES,
   INDEX_VERSION,
   KIT,
   LanguageExtractor,
+  METRIC_CATALOGUE,
   MIGRATIONS,
   PythonGraphExtractor,
+  SCHEMA_VERSION,
+  SNAPSHOT_SCOPED_TABLES,
   SOURCE_METRIC_NAMES,
+  SYMBOL_EMBEDDING_NAMESPACE,
   SYMBOL_ID_SEP,
   TsMorphGraphExtractor,
+  aggregateMetrics,
+  aliasChain,
   annotateRoles,
+  attributeCoverage,
   buildAliases,
+  buildEmbedText,
   buildFileModuleNodes,
   buildIndexerMetrics,
+  buildLineage,
   canonicalEdgeKind,
   canonicalMetricName,
   canonicalRole,
+  checkSnapshot,
   classifyRole,
   collectDeclaredNames,
   collectDeclaredSpans,
+  compilePatterns,
+  computeDeadCodeMetrics,
+  computeDeepAst,
+  computeGrowthRiskMetrics,
   computeMetrics,
+  computePageRank,
+  computePartitionQuality,
+  computeRecencyWindows,
+  computeRelevance,
   computeRoleHints,
   computeSourceMetrics,
+  computeSymbolConsumers,
+  computeSymbolCoupling,
+  computeTestCoverageOwnership,
+  createAliasChain,
+  describeMetric,
+  describeMetrics,
   detectGitHead,
   detectGitToplevel,
   detectRenames,
+  diffCheckResults,
+  diffSnapshots,
   edgeWeight,
+  embedSnapshot,
+  embedTextsCached,
   externalId,
   fileId,
-  getLanguageFromPath,
+  findSimilarCapability,
+  getEdgeWeight,
+  getLanguageFromPath3 as getLanguageFromPath,
   getSupportedLanguages,
+  groupTestsBySource,
   hashContent,
+  hashEmbedText,
   indexPaths,
+  invertBuckets,
   isGeneratedByHeuristic,
   isGeneratedFile,
   isInsideGitRepo,
+  lineagePath,
+  linkTestsToSources,
   listEdges,
+  listEdgesTouching,
+  listEmbeddableSymbols,
   listMetrics,
+  listMetricsForNode,
   listNodes,
+  loadCheckRules,
   loadGeneratedPatterns,
+  loadHistoryMetrics,
+  loadLineage,
+  matchesAny,
   moduleId,
   openCodeGraph,
   packageId,
   parentModuleId,
-  parseFile,
+  parseFile2 as parseFile,
   parseSymbolId,
+  patternToRegex,
+  planPrune,
+  priorSnapshotForRef,
   pruneDanglingReferences,
   readSourceFiles,
+  rebasedViolationKey,
+  resolveAlias,
   resolveBarrelEdges,
-  shouldIncludeFile,
+  resolveChurnWindows,
+  resolveGitRef,
+  resolveSnapshot,
+  runChecks,
+  runPrune,
+  shouldIncludeFile2 as shouldIncludeFile,
+  snapshotPageRank,
+  snapshotReferenceEdges,
+  snapshotRelevance,
+  snapshotSymbolConsumers,
+  snapshotSymbolCoupling,
+  snapshotViolations,
   structuralSignature,
   symbolId,
-  walkSourceFiles
+  testCoverageCountMetrics,
+  tryEmbedSnapshot,
+  validateRules,
+  violationKey,
+  walkSourceFiles,
+  windowSuffix
 };
 //# sourceMappingURL=index.js.map