@titan-design/code-graph 0.11.0 → 0.13.0

package/dist/chunk-L5KU543A.js

@@ -0,0 +1,1395 @@
+import {
+  couplingFor
+} from "./chunk-HIVVDGWE.js";
+
+// src/extractors/symbol-id.ts
+var SYMBOL_ID_SEP = "#";
+function symbolId(fileId, qualifiedName) {
+  return `${fileId}${SYMBOL_ID_SEP}${qualifiedName}`;
+}
+function parseSymbolId(id) {
+  const idx = id.indexOf(SYMBOL_ID_SEP);
+  if (idx < 0) return null;
+  return { fileId: id.slice(0, idx), name: id.slice(idx + 1) };
+}
+
+// src/analysis/test-linker.ts
+var DEFAULT_MIN_CO_EDIT_COUNT = 2;
+var TEST_INFIX_RE = /\.(?:test|spec)(\.[^./]+)$/;
+var TESTS_DIR_RE = /(^|\/)(?:__tests__|tests?)\//;
+function pathCandidates(testId) {
+  const out = /* @__PURE__ */ new Set();
+  const deInfixed = testId.replace(TEST_INFIX_RE, "$1");
+  if (deInfixed !== testId) out.add(deInfixed);
+  const deDir = deInfixed.replace(TESTS_DIR_RE, "$1");
+  if (deDir !== testId) out.add(deDir);
+  return [...out];
+}
+function splitFileIds(nodes) {
+  const testIds = [];
+  const nonTestIds = /* @__PURE__ */ new Set();
+  for (const n of nodes) {
+    if (n.kind !== "file") continue;
+    if (n.role === "test") testIds.push(n.id);
+    else nonTestIds.add(n.id);
+  }
+  return { testIds, nonTestIds };
+}
+function linkTestsToSources(nodes, coEditPairs, options = {}) {
+  const minCount = options.minCoEditCount ?? DEFAULT_MIN_CO_EDIT_COUNT;
+  const { testIds, nonTestIds } = splitFileIds(nodes);
+  const links = [];
+  for (const testId of testIds) {
+    const matched = pathCandidates(testId).filter((c) => nonTestIds.has(c));
+    if (matched.length > 0) {
+      for (const sourceId of matched) {
+        links.push({ testId, sourceId, method: "path" });
+      }
+      continue;
+    }
+    const partner = couplingFor(coEditPairs, testId).find((p) => p.count >= minCount && nonTestIds.has(p.partner));
+    if (partner) {
+      links.push({ testId, sourceId: partner.partner, method: "coedit" });
+    }
+  }
+  return links;
+}
+function testCoverageCountMetrics(links) {
+  const testsBySource = groupTestsBySource(links);
+  const out = [];
+  for (const [sourceId, tests] of testsBySource) {
+    out.push({
+      nodeId: sourceId,
+      name: "linked_test_count",
+      value: tests.size,
+      unit: "count"
+    });
+  }
+  return out;
+}
+function groupTestsBySource(links) {
+  const out = /* @__PURE__ */ new Map();
+  for (const l of links) {
+    let set = out.get(l.sourceId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      out.set(l.sourceId, set);
+    }
+    set.add(l.testId);
+  }
+  return out;
+}
+
+// src/history-recency.ts
+var DAY_SECONDS = 86400;
+function windowSuffix(window) {
+  return window === "lifetime" ? "lifetime" : `${window}d`;
+}
+function computeRecencyWindows(firstSeen, churnedIdsByWindow, nowEpoch) {
+  const out = [];
+  const ageEmitted = /* @__PURE__ */ new Set();
+  for (const [windowDays, ids] of churnedIdsByWindow) {
+    const suffix = windowSuffix(windowDays);
+    for (const id of ids) {
+      const seen = firstSeen.get(id);
+      let recency = 1;
+      if (seen !== void 0) {
+        const ageDays = Math.max(0, (nowEpoch - seen) / DAY_SECONDS);
+        if (windowDays !== "lifetime") recency = Math.min(1, ageDays / windowDays);
+        if (!ageEmitted.has(id)) {
+          out.push({ nodeId: id, name: "file_age_days", value: Math.round(ageDays), unit: "days" });
+          ageEmitted.add(id);
+        }
+      }
+      out.push({ nodeId: id, name: `recency_${suffix}`, value: round3(recency), unit: "ratio" });
+    }
+  }
+  return out;
+}
+function round3(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/unimported-roles.ts
+var UNIMPORTED_ROLES = /* @__PURE__ */ new Set([
+  "test",
+  "fixture",
+  "story",
+  "lab",
+  "config",
+  "script",
+  "entry"
+]);
+
+// 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/dashboard-node-metrics.ts
+var METRIC_FIELD = {
+  loc: "loc",
+  cognitive_max: "cognitiveMax",
+  cyclomatic_max: "cyclomaticMax",
+  max_nesting_depth: "maxNesting",
+  fan_in: "fanIn",
+  fan_out: "fanOut",
+  utilization: "utilization",
+  linked_test_count: "linkedTests",
+  // Per-symbol complexity (C-58) lands on `symbol` nodes; map onto the same
+  // fields so a symbol node reads its OWN complexity (file nodes never carry the
+  // `symbol_*` names, so there's no collision on a shared field).
+  symbol_cognitive: "cognitiveMax",
+  symbol_cyclomatic: "cyclomaticMax"
+};
+function collectNodeMetrics(rows) {
+  const byNode = /* @__PURE__ */ new Map();
+  for (const m of rows) {
+    const field = METRIC_FIELD[m.name];
+    if (!field || m.value === null) continue;
+    const entry = byNode.get(m.nodeId) ?? {};
+    entry[field] = m.value;
+    byNode.set(m.nodeId, entry);
+  }
+  return byNode;
+}
+function referencedNodes(report) {
+  const referenced = /* @__PURE__ */ new Set();
+  for (const h of report.hotspots) referenced.add(h.nodeId);
+  for (const b of report.busFactorRisks) referenced.add(b.nodeId);
+  for (const t of report.testCoverageRisks) referenced.add(t.nodeId);
+  for (const c of report.couplingClusters) {
+    referenced.add(c.fileA);
+    referenced.add(c.fileB);
+  }
+  for (const c of report.centralFiles) referenced.add(c.nodeId);
+  const drift = report.drift;
+  if (drift) {
+    for (const h of drift.newHotspots) referenced.add(h.nodeId);
+    for (const d of drift.worsenedHotspots) referenced.add(d.nodeId);
+    for (const c of drift.newCoupling) {
+      referenced.add(c.fileA);
+      referenced.add(c.fileB);
+    }
+  }
+  return referenced;
+}
+function buildNodeMetrics(report, metrics) {
+  const out = {};
+  for (const id of referencedNodes(report)) {
+    const m = metrics.get(id);
+    if (m) out[id] = m;
+  }
+  return out;
+}
+function buildCentralFiles(report, centrality) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const c of report.centralFiles) byId.set(c.nodeId, c.score);
+  const referenced = /* @__PURE__ */ new Set();
+  for (const h of report.hotspots) referenced.add(h.nodeId);
+  for (const b of report.busFactorRisks) referenced.add(b.nodeId);
+  for (const c of report.couplingClusters) {
+    referenced.add(c.fileA);
+    referenced.add(c.fileB);
+  }
+  for (const id of referenced) if (!byId.has(id)) byId.set(id, centrality.get(id) ?? 0);
+  return [...byId].map(([nodeId, score]) => ({ nodeId, score })).sort((a, b) => b.score - a.score);
+}
+function collectSymbolUtil(nodes, metrics) {
+  const out = [];
+  for (const n of nodes) {
+    if (n.kind !== "symbol" || !n.parentId) continue;
+    out.push({
+      symbolId: n.id,
+      name: n.name,
+      fileId: n.parentId,
+      utilization: metrics.get(n.id)?.utilization ?? 0,
+      exported: n.attrs?.exported !== false
+    });
+  }
+  return out;
+}
+function buildHotExports(symbols, referenced, metrics, consumersBySymbol) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const s of symbols) {
+    if (!referenced.has(s.fileId)) continue;
+    const bucket = byFile.get(s.fileId) ?? [];
+    bucket.push({
+      name: s.name,
+      utilization: s.utilization,
+      cognitive: metrics.get(s.symbolId)?.cognitiveMax,
+      consumers: consumersBySymbol.get(s.symbolId) ?? 0,
+      exported: s.exported
+    });
+    byFile.set(s.fileId, bucket);
+  }
+  const out = {};
+  for (const [fileId, syms] of byFile) {
+    const exports = syms.filter((s) => s.exported).sort((a, b) => b.utilization - a.utilization || (b.cognitive ?? 0) - (a.cognitive ?? 0)).slice(0, 8);
+    const internal = syms.filter((s) => !s.exported).sort((a, b) => (b.cognitive ?? 0) - (a.cognitive ?? 0) || a.name.localeCompare(b.name)).slice(0, 8);
+    out[fileId] = [...exports, ...internal];
+  }
+  return out;
+}
+function buildBlastRadius(symbols, metrics, churnByFile, limit = 15) {
+  const out = [];
+  for (const s of symbols) {
+    const complexity = metrics.get(s.symbolId)?.cognitiveMax ?? metrics.get(s.fileId)?.cognitiveMax ?? 0;
+    const churn = churnByFile.get(s.fileId) ?? 0;
+    const score = s.utilization * complexity * churn;
+    if (score <= 0) continue;
+    out.push({ symbolId: s.symbolId, name: s.name, fileId: s.fileId, utilization: s.utilization, complexity, churn, score });
+  }
+  return out.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// 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 resolve = (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 resolve(target, visiting)) out.push(inner);
+      } else {
+        out.push(target);
+      }
+    }
+    visiting.delete(barrel);
+    resolved.set(barrel, out);
+    return out;
+  };
+  for (const id of barrelIds) resolve(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/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/analysis/graph-report-sections.ts
+var COMPLEXITY_METRICS = ["cognitive_max", "cyclomatic_max"];
+function buildReportContext(input) {
+  const metricsByName = /* @__PURE__ */ new Map();
+  for (const m of input.metrics) {
+    if (m.value === null) continue;
+    let bucket = metricsByName.get(m.name);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      metricsByName.set(m.name, bucket);
+    }
+    bucket.set(m.nodeId, m.value);
+  }
+  return {
+    nodes: input.nodes,
+    nodeById: new Map(input.nodes.map((n) => [n.id, n])),
+    metricsByName,
+    excluders: input.excluders,
+    excludedRoles: input.excludedRoles,
+    windowDays: input.windowDays,
+    windowSuffix: windowSuffix(input.windowDays)
+  };
+}
+function keepNode(ctx, nodeId) {
+  if (matchesAny(nodeId, ctx.excluders)) return false;
+  const node = ctx.nodeById.get(nodeId);
+  if (!node || node.kind !== "file") return false;
+  if (node.role === "generated") return false;
+  if (node.role && ctx.excludedRoles.has(node.role)) return false;
+  return true;
+}
+function lookupMetric(ctx, name, nodeId) {
+  return ctx.metricsByName.get(name)?.get(nodeId);
+}
+function pickComplexityMetric(ctx) {
+  for (const m of COMPLEXITY_METRICS) {
+    if (ctx.metricsByName.has(m)) return m;
+  }
+  return "cyclomatic_max";
+}
+function topHotspots(ctx, limit) {
+  const churnName = `churn_${ctx.windowSuffix}`;
+  const complexityName = pickComplexityMetric(ctx);
+  const rows = [];
+  for (const node of ctx.nodes) {
+    if (!keepNode(ctx, node.id)) continue;
+    const churn = lookupMetric(ctx, churnName, node.id) ?? 0;
+    const complexity = lookupMetric(ctx, complexityName, node.id) ?? 0;
+    if (churn === 0 || complexity === 0) continue;
+    const recency = lookupMetric(ctx, `recency_${ctx.windowSuffix}`, node.id) ?? 1;
+    rows.push({ nodeId: node.id, churn, complexity, recency, score: Math.round(churn * complexity * recency) });
+  }
+  rows.sort((a, b) => b.score - a.score);
+  return rows.slice(0, limit);
+}
+function hotspotScoreOf(ctx, nodeId) {
+  if (!keepNode(ctx, nodeId)) return 0;
+  const churn = lookupMetric(ctx, `churn_${ctx.windowSuffix}`, nodeId) ?? 0;
+  const complexity = lookupMetric(ctx, pickComplexityMetric(ctx), nodeId) ?? 0;
+  if (churn === 0 || complexity === 0) return 0;
+  return hotspotScore(ctx, nodeId, churn, complexity);
+}
+function hotspotComplexityOf(ctx, nodeId) {
+  return lookupMetric(ctx, pickComplexityMetric(ctx), nodeId);
+}
+function hotspotScore(ctx, nodeId, churn, complexity) {
+  const recency = lookupMetric(ctx, `recency_${ctx.windowSuffix}`, nodeId) ?? 1;
+  return Math.round(churn * complexity * recency);
+}
+function busFactorOf(ctx, nodeId) {
+  return lookupMetric(ctx, `bus_factor_${ctx.windowSuffix}`, nodeId);
+}
+function topBusFactorRisks(ctx, limit) {
+  const churnName = `churn_${ctx.windowSuffix}`;
+  const bfName = `bus_factor_${ctx.windowSuffix}`;
+  const shareName = `top_author_share_${ctx.windowSuffix}`;
+  const rows = [];
+  for (const node of ctx.nodes) {
+    if (!keepNode(ctx, node.id)) continue;
+    const bf = lookupMetric(ctx, bfName, node.id);
+    if (bf === void 0 || bf > 1) continue;
+    rows.push({
+      nodeId: node.id,
+      busFactor: bf,
+      topAuthorShare: lookupMetric(ctx, shareName, node.id) ?? 1,
+      churn: lookupMetric(ctx, churnName, node.id) ?? 0
+    });
+  }
+  rows.sort((a, b) => b.churn - a.churn);
+  return rows.slice(0, limit);
+}
+function topTestCoverageRisks(ctx, limit) {
+  const bfName = `test_bus_factor_${ctx.windowSuffix}`;
+  const shareName = `test_top_author_share_${ctx.windowSuffix}`;
+  const rows = [];
+  for (const node of ctx.nodes) {
+    if (!keepNode(ctx, node.id)) continue;
+    const bf = lookupMetric(ctx, bfName, node.id);
+    if (bf === void 0 || bf > 1) continue;
+    rows.push({
+      nodeId: node.id,
+      testBusFactor: bf,
+      testTopAuthorShare: lookupMetric(ctx, shareName, node.id) ?? 1,
+      linkedTests: lookupMetric(ctx, "linked_test_count", node.id) ?? 0
+    });
+  }
+  rows.sort((a, b) => b.linkedTests - a.linkedTests);
+  return rows.slice(0, limit);
+}
+function topCentralFiles(nodes, edges, ctx, limit) {
+  const pageRank = computePageRank(nodes, edges, {});
+  const rows = [];
+  for (const r of pageRank.rows) {
+    if (!keepNode(ctx, r.nodeId)) continue;
+    rows.push({ nodeId: r.nodeId, score: r.score });
+    if (rows.length >= limit) break;
+  }
+  return rows;
+}
+
+// src/analysis/unused-exports.ts
+function publicApiFiles(nodes, edges) {
+  const barrels = new Set(
+    nodes.filter((n) => n.role === "barrel").map((n) => n.id)
+  );
+  const out = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.kind === "re-exports" && barrels.has(e.srcId)) out.add(e.dstId);
+  }
+  return out;
+}
+function topUnusedExports(symbolNodes, publicApi, ctx, limit) {
+  const rows = [];
+  for (const n of symbolNodes) {
+    if (n.kind !== "symbol" || n.attrs?.exported !== true) continue;
+    if ((lookupMetric(ctx, "utilization", n.id) ?? 0) > 0) continue;
+    const fileId = n.parentId;
+    if (!fileId || !keepNode(ctx, fileId)) continue;
+    rows.push({
+      nodeId: n.id,
+      name: n.name,
+      fileId,
+      cognitive: lookupMetric(ctx, "symbol_cognitive", n.id) ?? 0,
+      publicApi: publicApi.has(fileId)
+    });
+  }
+  rows.sort(
+    (a, b) => Number(a.publicApi) - Number(b.publicApi) || b.cognitive - a.cognitive || a.nodeId.localeCompare(b.nodeId)
+  );
+  return rows.slice(0, limit);
+}
+
+// src/analysis/dead-modules.ts
+var ENTRY_ROOT_ROLES = /* @__PURE__ */ new Set([...UNIMPORTED_ROLES, "barrel"]);
+var ENTRY_FILE_RE = /(?:^|\/)main\.[jt]sx?$/;
+function isEntryRoot(node) {
+  return node.kind === "file" && (node.role !== void 0 && ENTRY_ROOT_ROLES.has(node.role) || ENTRY_FILE_RE.test(node.id));
+}
+function topDeadModules(nodes, edges, ctx, limit) {
+  const reached = reachableFromEntryRoots(nodes, edges);
+  const rows = [];
+  for (const n of nodes) {
+    if (n.kind !== "file" || reached.has(n.id) || isEntryRoot(n)) continue;
+    if (!keepNode(ctx, n.id)) continue;
+    rows.push({ nodeId: n.id, loc: lookupMetric(ctx, "loc", n.id) ?? 0, role: n.role ?? "source" });
+  }
+  rows.sort((a, b) => b.loc - a.loc || a.nodeId.localeCompare(b.nodeId));
+  return rows.slice(0, limit);
+}
+function outgoingModuleEdges(edges) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.kind !== "imports" && e.kind !== "re-exports") continue;
+    const bucket = out.get(e.srcId);
+    if (bucket) bucket.push(e.dstId);
+    else out.set(e.srcId, [e.dstId]);
+  }
+  return out;
+}
+function reachableFromEntryRoots(nodes, edges) {
+  const out = outgoingModuleEdges(edges);
+  const reached = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const n of nodes) {
+    if (isEntryRoot(n)) {
+      reached.add(n.id);
+      queue.push(n.id);
+    }
+  }
+  for (let i = 0; i < queue.length; i++) {
+    for (const dst of out.get(queue[i]) ?? []) {
+      if (reached.has(dst)) continue;
+      reached.add(dst);
+      queue.push(dst);
+    }
+  }
+  return reached;
+}
+
+// src/analysis/growth-risks.ts
+var LOOP_SHAPES = { 2: "quadratic-shaped", 3: "cubic-shaped" };
+function loopShape(depth) {
+  return LOOP_SHAPES[depth] ?? `${depth}-deep loop nesting`;
+}
+function fileSmells(ctx, nodeId) {
+  const smells = [];
+  const depth = lookupMetric(ctx, "loop_depth", nodeId) ?? 0;
+  if (depth >= 2) smells.push(`${loopShape(depth)} loop nesting`);
+  const rec = lookupMetric(ctx, "recursive_functions", nodeId) ?? 0;
+  if (rec > 0) smells.push(`${rec} recursive function${rec === 1 ? "" : "s"}`);
+  const search = lookupMetric(ctx, "search_in_loop", nodeId) ?? 0;
+  if (search > 0) smells.push(`${search} linear search${search === 1 ? "" : "es"} in loops`);
+  return smells;
+}
+function topGrowthRisks(ctx, limit) {
+  const rows = [];
+  for (const node of ctx.nodes) {
+    if (!keepNode(ctx, node.id)) continue;
+    const smells = fileSmells(ctx, node.id);
+    if (smells.length === 0) continue;
+    rows.push({
+      nodeId: node.id,
+      loopDepth: lookupMetric(ctx, "loop_depth", node.id) ?? 0,
+      smells
+    });
+  }
+  rows.sort(
+    (a, b) => b.loopDepth - a.loopDepth || b.smells.length - a.smells.length || a.nodeId.localeCompare(b.nodeId)
+  );
+  return rows.slice(0, limit);
+}
+
+// src/analysis/untested-risks.ts
+function topUntestedRisks(ctx, limit) {
+  const rows = [];
+  for (const node of ctx.nodes) {
+    if (!keepNode(ctx, node.id)) continue;
+    const coverage = lookupMetric(ctx, "coverage_pct", node.id);
+    if (coverage === void 0 || coverage >= 100) continue;
+    const hotspot = hotspotScoreOf(ctx, node.id);
+    const score = Math.round(hotspot * (1 - coverage / 100));
+    if (score <= 0) continue;
+    rows.push({ nodeId: node.id, coverage, hotspot, score });
+  }
+  rows.sort((a, b) => b.score - a.score || a.nodeId.localeCompare(b.nodeId));
+  return rows.slice(0, limit);
+}
+
+// src/analysis/graph-report-drift.ts
+function computeReportDrift(input) {
+  const hot = diffHotspots(
+    input.currentHotspots,
+    input.baselineHotspots,
+    input.currentHotspotScore,
+    input.baselineHotspotScore ?? (() => void 0)
+  );
+  const silos = diffSilos(
+    input.currentSilos,
+    input.baselineSilos,
+    input.currentBusFactor
+  );
+  const coupling = diffCoupling(input.currentCoupling, input.baselineCoupling);
+  return {
+    baselineSnapshot: input.baselineSnapshot,
+    newHotspots: hot.added,
+    resolvedHotspots: hot.resolved,
+    displacedHotspots: hot.displaced,
+    worsenedHotspots: hot.worsened,
+    improvedHotspots: hot.improved,
+    newSilos: silos.added,
+    resolvedSilos: silos.resolved,
+    displacedSilos: silos.displaced,
+    newCoupling: coupling.added,
+    intensifiedCoupling: coupling.intensified
+  };
+}
+function diffHotspots(cur, base, currentScore, baselineScore) {
+  const baseById = new Map(base.map((r) => [r.nodeId, r]));
+  const curById = new Map(cur.map((r) => [r.nodeId, r]));
+  const added = [];
+  const resolved = [];
+  const displaced = [];
+  const worsened = [];
+  const improved = [];
+  for (const r of cur) {
+    const b = baseById.get(r.nodeId);
+    if (!b) {
+      added.push({ ...r, before: baselineScore(r.nodeId) });
+      continue;
+    }
+    const delta = r.score - b.score;
+    if (delta > 0) worsened.push({ nodeId: r.nodeId, before: b.score, after: r.score, delta });
+    else if (delta < 0) improved.push({ nodeId: r.nodeId, before: b.score, after: r.score, delta });
+  }
+  for (const b of base) {
+    if (curById.has(b.nodeId)) continue;
+    const after = currentScore(b.nodeId);
+    const delta = after - b.score;
+    const row = { nodeId: b.nodeId, before: b.score, after, delta };
+    if (after < b.score) resolved.push(row);
+    else displaced.push(row);
+  }
+  worsened.sort((a, b) => b.delta - a.delta);
+  improved.sort((a, b) => a.delta - b.delta);
+  resolved.sort((a, b) => a.delta - b.delta);
+  displaced.sort((a, b) => b.before - a.before);
+  return { added, resolved, displaced, worsened, improved };
+}
+function diffSilos(cur, base, currentBusFactor) {
+  const baseIds = new Set(base.map((r) => r.nodeId));
+  const curIds = new Set(cur.map((r) => r.nodeId));
+  const added = [];
+  const resolved = [];
+  const displaced = [];
+  for (const r of cur) {
+    if (!baseIds.has(r.nodeId)) added.push({ nodeId: r.nodeId, churn: r.churn });
+  }
+  for (const r of base) {
+    if (curIds.has(r.nodeId)) continue;
+    const bf = currentBusFactor(r.nodeId);
+    if (bf === void 0 || bf > 1) {
+      resolved.push({ nodeId: r.nodeId, churn: r.churn });
+    } else {
+      displaced.push({ nodeId: r.nodeId, churn: r.churn });
+    }
+  }
+  added.sort((a, b) => b.churn - a.churn);
+  resolved.sort((a, b) => b.churn - a.churn);
+  displaced.sort((a, b) => b.churn - a.churn);
+  return { added, resolved, displaced };
+}
+function diffCoupling(cur, base) {
+  const key = (r) => `${r.fileA}	${r.fileB}`;
+  const baseByKey = new Map(base.map((r) => [key(r), r]));
+  const added = [];
+  const intensified = [];
+  for (const r of cur) {
+    const b = baseByKey.get(key(r));
+    if (!b) added.push(r);
+    else if (r.count > b.count) {
+      intensified.push({
+        fileA: r.fileA,
+        fileB: r.fileB,
+        before: b.count,
+        after: r.count
+      });
+    }
+  }
+  intensified.sort((a, b) => b.after - b.before - (a.after - a.before));
+  return { added, intensified };
+}
+
+// src/analysis/dashboard-health.ts
+var DEFAULT_HEALTH_WEIGHTS = {
+  hotspots: { each: 10, cap: 30 },
+  findings: { eachNew: 8, eachCarry: 3, cap: 20 },
+  complexity: { each: 1, budget: 30, cap: 15 },
+  hiddenCoupling: { each: 2, cap: 10 }
+};
+function healthComponents(x, w) {
+  const over = Math.max(0, x.maxComplexity - w.complexity.budget);
+  return [
+    { key: "hotspots", label: "scary hotspots", penalty: Math.min(w.hotspots.cap, x.scary * w.hotspots.each), cap: w.hotspots.cap, detail: `${x.scary} file(s) \u2265 ${x.scaryCutoff ?? 3e3}` },
+    {
+      key: "findings",
+      label: "fitness violations",
+      penalty: Math.min(w.findings.cap, x.newViolations * w.findings.eachNew + x.carryViolations * w.findings.eachCarry),
+      cap: w.findings.cap,
+      detail: `${x.newViolations} new, ${x.carryViolations} parked (non-hotspot rules)`
+    },
+    { key: "complexity", label: "complexity over budget", penalty: Math.min(w.complexity.cap, over * w.complexity.each), cap: w.complexity.cap, detail: `max ${x.maxComplexity} vs budget ${w.complexity.budget}` },
+    { key: "hidden-coupling", label: "hidden coupling", penalty: Math.min(w.hiddenCoupling.cap, x.hiddenCoupling * w.hiddenCoupling.each), cap: w.hiddenCoupling.cap, detail: `${x.hiddenCoupling} pair(s) co-change without an import` }
+  ];
+}
+function computeHealth(x, weights = DEFAULT_HEALTH_WEIGHTS) {
+  const breakdown = healthComponents(x, weights);
+  const total = breakdown.reduce((s, c) => s + c.penalty, 0);
+  return { health: Math.max(0, 100 - total), healthBreakdown: breakdown };
+}
+
+// src/analysis/dashboard-coupling.ts
+function classifyCoupling(a, b, ctx) {
+  const unindexed = !ctx.connectedNodes.has(a) || !ctx.connectedNodes.has(b);
+  if (unindexed) return { hidden: false, unindexed: true };
+  return { hidden: !ctx.linkedPairs.has(pairKey(a, b)), unindexed: false };
+}
+function pairKey(a, b) {
+  return a < b ? JSON.stringify([a, b]) : JSON.stringify([b, a]);
+}
+
+// src/analysis/package-buckets.ts
+function bucketFilesByPackage(fileIds, packages) {
+  const sorted = [...packages].sort((a, b) => b.id.length - a.id.length);
+  const out = /* @__PURE__ */ new Map();
+  for (const id of fileIds) {
+    const pkg = matchPackage(id, sorted);
+    const key = pkg?.id ?? "";
+    let list = out.get(key);
+    if (!list) {
+      list = [];
+      out.set(key, list);
+    }
+    list.push(id);
+  }
+  return out;
+}
+function matchPackage(fileId, packagesByLongestId) {
+  for (const p of packagesByLongestId) {
+    if (p.id === "") continue;
+    if (fileId === p.id) return p;
+    if (fileId.startsWith(`${p.id}/`)) return p;
+  }
+  return null;
+}
+
+// src/analysis/graph-arch-compute.ts
+var EXTERNAL_BUCKET = "(external)";
+var DEFAULT_MAX_PACKAGE_SIZE = 30;
+function computeArch(input) {
+  const fileIds = filteredFileIds(input.nodes, input);
+  const fileByPackage = bucketFilesByPackage(fileIds, input.packages);
+  const drill = planDrill(input, fileByPackage);
+  const nodeByFile = buildNodeByFile(fileByPackage, drill);
+  const pkgByFile = invertBuckets(fileByPackage);
+  const externalIds = new Set(
+    input.nodes.filter((n) => n.kind === "external").map((n) => n.id)
+  );
+  const counts = aggregateEdges(
+    input.edges,
+    pkgByFile,
+    nodeByFile,
+    externalIds,
+    Boolean(input.includeExternal)
+  );
+  const minEdges = Math.max(1, input.minEdges ?? 1);
+  return {
+    snapshot: input.snapshot,
+    packages: activePackages(
+      input.packages,
+      fileByPackage,
+      Boolean(input.includeExternal),
+      counts,
+      drill
+    ),
+    edges: toSortedEdges(counts, minEdges),
+    includesExternal: Boolean(input.includeExternal)
+  };
+}
+var DEFAULT_GRAPH_EXCLUDED_ROLES = ["test", "fixture"];
+function filteredFileIds(nodes, options) {
+  const excluders = compilePatterns(options.exclude);
+  const excludedRoles = /* @__PURE__ */ new Set([
+    ...DEFAULT_GRAPH_EXCLUDED_ROLES,
+    ...options.excludeRole ?? []
+  ]);
+  return nodes.filter((n) => n.kind === "file").filter((n) => !excludedRoles.has(n.role ?? "")).filter((n) => !matchesAny(n.id, excluders)).map((n) => n.id);
+}
+function aggregateEdges(edges, pkgByFile, nodeByFile, externalIds, includeExternal) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const fromPkg = pkgByFile.get(e.srcId);
+    if (!fromPkg) continue;
+    const dest = resolveDestination(
+      e.dstId,
+      pkgByFile,
+      nodeByFile,
+      externalIds,
+      includeExternal
+    );
+    if (!dest || dest.pkg === fromPkg) continue;
+    bump(counts, nodeByFile.get(e.srcId) ?? fromPkg, dest.node);
+  }
+  return counts;
+}
+function resolveDestination(dstId, pkgByFile, nodeByFile, externalIds, includeExternal) {
+  const pkg = pkgByFile.get(dstId);
+  if (pkg !== void 0) return { pkg, node: nodeByFile.get(dstId) ?? pkg };
+  if (externalIds.has(dstId) && includeExternal) {
+    return { pkg: EXTERNAL_BUCKET, node: EXTERNAL_BUCKET };
+  }
+  return null;
+}
+function bump(counts, from, to) {
+  let row = counts.get(from);
+  if (!row) {
+    row = /* @__PURE__ */ new Map();
+    counts.set(from, row);
+  }
+  row.set(to, (row.get(to) ?? 0) + 1);
+}
+function toSortedEdges(counts, minEdges) {
+  const out = [];
+  for (const [from, row] of counts) {
+    for (const [to, count] of row) {
+      if (count < minEdges) continue;
+      out.push({ from, to, count });
+    }
+  }
+  out.sort(compareArchEdges);
+  return out;
+}
+function compareArchEdges(a, b) {
+  if (a.from !== b.from) return a.from < b.from ? -1 : 1;
+  return a.to < b.to ? -1 : 1;
+}
+function activePackages(all, fileByPackage, includeExternal, counts, drill) {
+  const referenced = packagesReferencedByEdges(counts);
+  const out = [];
+  for (const p of all) {
+    const files = fileByPackage.get(p.id)?.length ?? 0;
+    if (files === 0 && !referenced.has(p.id)) continue;
+    const plan = drill.get(p.id);
+    out.push(
+      plan ? { id: p.id, name: p.name, files, subNodes: plan.subNodes } : { id: p.id, name: p.name, files }
+    );
+  }
+  if (includeExternal && referenced.has(EXTERNAL_BUCKET)) {
+    out.push({ id: EXTERNAL_BUCKET, name: EXTERNAL_BUCKET, files: 0 });
+  }
+  return out;
+}
+function packagesReferencedByEdges(counts) {
+  const referenced = /* @__PURE__ */ new Set();
+  for (const [from, row] of counts) {
+    referenced.add(from);
+    for (const to of row.keys()) referenced.add(to);
+  }
+  return referenced;
+}
+function planDrill(input, fileByPackage) {
+  const enabled = input.depth === "modules" || input.maxPackageSize !== void 0;
+  if (!enabled) return /* @__PURE__ */ new Map();
+  const threshold = Math.max(1, input.maxPackageSize ?? DEFAULT_MAX_PACKAGE_SIZE);
+  const out = /* @__PURE__ */ new Map();
+  for (const [pkgId, files] of fileByPackage) {
+    if (pkgId === "" || files.length <= threshold) continue;
+    out.set(pkgId, buildDrillPlan(pkgId, files));
+  }
+  return out;
+}
+function buildNodeByFile(fileByPackage, drill) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [pkgId, files] of fileByPackage) {
+    if (pkgId === "") continue;
+    const plan = drill.get(pkgId);
+    for (const f of files) out.set(f, plan?.fileToSub.get(f) ?? pkgId);
+  }
+  return out;
+}
+function buildDrillPlan(pkgId, files) {
+  const rels = files.map((f) => stripPkgPrefix(f, pkgId));
+  const commonRoot = drillRoot(rels.map(dirSegments));
+  const fileToSub = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  files.forEach((file, i) => {
+    const { id, label } = subNodeFor(pkgId, rels[i], commonRoot);
+    fileToSub.set(file, id);
+    const g = groups.get(id);
+    if (g) g.count += 1;
+    else groups.set(id, { label, count: 1 });
+  });
+  const subNodes = [...groups.entries()].map(([id, g]) => ({ id, label: g.label, files: g.count })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return { subNodes, fileToSub };
+}
+function subNodeFor(pkgId, rel, commonRoot) {
+  const segment = dirSegments(rel).slice(commonRoot.length)[0] ?? "";
+  if (segment !== "") {
+    return { id: `${pkgId}/${[...commonRoot, segment].join("/")}`, label: segment };
+  }
+  const id = commonRoot.length ? `${pkgId}/${commonRoot.join("/")}` : `${pkgId}/(root)`;
+  return { id, label: "(root)" };
+}
+function stripPkgPrefix(fileId, pkgId) {
+  if (fileId === pkgId) return "";
+  return fileId.startsWith(`${pkgId}/`) ? fileId.slice(pkgId.length + 1) : fileId;
+}
+function dirSegments(rel) {
+  const i = rel.lastIndexOf("/");
+  return i < 0 ? [] : rel.slice(0, i).split("/");
+}
+function drillRoot(dirs) {
+  const root = [];
+  for (; ; ) {
+    const deeper = dirs.filter((d) => d.length > root.length);
+    if (deeper.length === 0) break;
+    const seg = deeper[0][root.length];
+    const singleChild = deeper.every((d) => d[root.length] === seg);
+    if (!singleChild || countGroups(dirs, root.length + 1) < 2) break;
+    root.push(seg);
+  }
+  return root;
+}
+function countGroups(dirs, rootLen) {
+  const groups = /* @__PURE__ */ new Set();
+  for (const d of dirs) groups.add(d.length <= rootLen ? "(root)" : d[rootLen]);
+  return groups.size;
+}
+
+// src/check/violation-key.ts
+function violationKey(v) {
+  return v.destinationId ? `${v.ruleId}|${v.nodeId}|${v.destinationId}` : `${v.ruleId}|${v.nodeId}`;
+}
+function rebasedViolationKey(v, resolve) {
+  const destinationId = v.destinationId ? resolve(v.destinationId) : v.destinationId;
+  return violationKey({ ...v, nodeId: resolve(v.nodeId), destinationId });
+}
+
+// src/diff/violation-buckets.ts
+function bucketViolations(from, to, resolve) {
+  const fromByKey = indexByKey(from, resolve);
+  const toByKey = indexByKey(to);
+  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 entry = { from: fromV, to: toV, delta: computeDelta(fromV, toV) };
+    buckets.unchanged.push(entry);
+    if (entry.delta !== null && entry.delta > 0) buckets.worsened.push(entry);
+    else if (entry.delta !== null && entry.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, resolve) {
+  const out = /* @__PURE__ */ new Map();
+  for (const v of violations) out.set(resolve ? rebasedViolationKey(v, resolve) : 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;
+}
+
+export {
+  SYMBOL_ID_SEP,
+  symbolId,
+  parseSymbolId,
+  linkTestsToSources,
+  testCoverageCountMetrics,
+  groupTestsBySource,
+  windowSuffix,
+  computeRecencyWindows,
+  round3,
+  UNIMPORTED_ROLES,
+  getEdgeWeight,
+  computePageRank,
+  collectNodeMetrics,
+  referencedNodes,
+  buildNodeMetrics,
+  buildCentralFiles,
+  collectSymbolUtil,
+  buildHotExports,
+  buildBlastRadius,
+  computeSymbolConsumers,
+  computeSymbolCoupling,
+  computePartitionQuality,
+  invertBuckets,
+  patternToRegex,
+  compilePatterns,
+  matchesAny,
+  buildReportContext,
+  keepNode,
+  lookupMetric,
+  topHotspots,
+  hotspotScoreOf,
+  hotspotComplexityOf,
+  busFactorOf,
+  topBusFactorRisks,
+  topTestCoverageRisks,
+  topCentralFiles,
+  publicApiFiles,
+  topUnusedExports,
+  topDeadModules,
+  topGrowthRisks,
+  topUntestedRisks,
+  computeReportDrift,
+  DEFAULT_HEALTH_WEIGHTS,
+  computeHealth,
+  classifyCoupling,
+  pairKey,
+  bucketFilesByPackage,
+  EXTERNAL_BUCKET,
+  DEFAULT_MAX_PACKAGE_SIZE,
+  computeArch,
+  filteredFileIds,
+  aggregateEdges,
+  toSortedEdges,
+  packagesReferencedByEdges,
+  violationKey,
+  rebasedViolationKey,
+  bucketViolations
+};
+//# sourceMappingURL=chunk-L5KU543A.js.map