weavatrix 0.3.14 → 1.0.0

package/src/analysis/source-correctness/retry-patterns.js

@@ -1,93 +0,0 @@
-import {makeFinding} from '../findings.js'
-
-const RETRY_SIGNAL = /\b(?:retry|retries|retrying|reconnect|backoff|attempts?)\b/i
-const WAIT_SIGNAL = /\b(?:sleep|delay)\s*\(/i
-const FAILURE_SIGNAL = /\b(?:catch|isError|error|exception|failed?|healthCheck)\b/i
-const TERMINATION_POLICY = /\b(?:max(?:imum)?(?:Retries|Attempts)|retryLimit|attemptLimit|deadline|timeout|isInterrupted)\b|\bcontext\s*\.\s*Done\b|\bsignal\s*\.\s*aborted\b|\battempts?\s*(?:>=|>)\s*\w+|\bbreak\s*;/i
-
-const lineAt = (text, index) => {
-    let line = 1
-    for (let i = 0; i < index && i < text.length; i++) if (text[i] === '\n') line++
-    return line
-}
-
-const lineText = (text, index) => {
-    const start = text.lastIndexOf('\n', Math.max(0, index - 1)) + 1
-    const end = text.indexOf('\n', index)
-    return text.slice(start, end < 0 ? text.length : end).trim().slice(0, 300)
-}
-
-function balancedEnd(text, openAt) {
-    if (text[openAt] !== '{') return -1
-    let depth = 0
-    for (let i = openAt; i < text.length; i++) {
-        if (text[i] === '{') depth++
-        else if (text[i] === '}' && --depth === 0) return i + 1
-    }
-    return -1
-}
-
-function retryFinding(text, file, index) {
-    return makeFinding({
-        category: 'structure',
-        rule: 'unbounded-retry-loop',
-        severity: 'low',
-        confidence: 'medium',
-        title: 'Retry/poll loop has no visible attempt, deadline, or cancellation bound',
-        detail: 'A repeating loop contains retry/failure plus wait behavior but no local maximum-attempt, deadline, cancellation, interrupt, or explicit break policy was recognized. This is a review signal, not proof of an infinite loop; success or a called helper may terminate it.',
-        file,
-        line: lineAt(text, index),
-        evidence: [{file, line: lineAt(text, index), snippet: lineText(text, index)}],
-        fixHint: 'confirm and document the retry termination/cancellation policy',
-    })
-}
-
-function retryBehavior(source) {
-    return RETRY_SIGNAL.test(source) || (WAIT_SIGNAL.test(source) && FAILURE_SIGNAL.test(source))
-}
-
-function bracedRetryFindings(text, masked, file) {
-    const findings = []
-    const re = /\bwhile\s*\(([^)]*)\)\s*\{|\bfor\s*\(\s*;\s*;\s*\)\s*\{|\bfor\s*\{|\bdo\s*\{/g
-    let match
-    while ((match = re.exec(masked))) {
-        const open = re.lastIndex - 1
-        const end = balancedEnd(masked, open)
-        if (end < 0) continue
-        const body = masked.slice(open + 1, end - 1)
-        const context = masked.slice(Math.max(0, match.index - 250), match.index)
-        let condition = match[1] || '', tailLength = 0
-        if (/^do\b/.test(match[0])) {
-            const tail = /^\s*while\s*\(([^)]*)\)\s*;/.exec(masked.slice(end))
-            condition = tail?.[1] || ''
-            tailLength = tail?.[0]?.length || 0
-        }
-        const evidence = `${context}\n${condition}\n${body}`
-        if (retryBehavior(evidence) && !TERMINATION_POLICY.test(`${condition}\n${body}`)) {
-            findings.push(retryFinding(text, file, match.index))
-        }
-        re.lastIndex = end + tailLength
-    }
-    return findings
-}
-
-function pythonRetryFindings(text, masked, file) {
-    const findings = [], lines = masked.split(/\r?\n/)
-    for (let i = 0; i < lines.length; i++) {
-        const match = /^(\s*)while\s+True\s*:/.exec(lines[i])
-        if (!match) continue
-        const indent = match[1].length
-        let end = i + 1
-        while (end < lines.length && (!lines[end].trim() || /^\s*/.exec(lines[end])[0].length > indent)) end++
-        const body = lines.slice(i + 1, end).join('\n')
-        const context = lines.slice(Math.max(0, i - 8), i).join('\n')
-        if (retryBehavior(`${context}\n${body}`) && !TERMINATION_POLICY.test(body)) {
-            findings.push(retryFinding(text, file, text.split(/\r?\n/).slice(0, i).join('\n').length + (i ? 1 : 0)))
-        }
-    }
-    return findings
-}
-
-export function retryFindings(text, masked, file, {python = false} = {}) {
-    return python ? pythonRetryFindings(text, masked, file) : bracedRetryFindings(text, masked, file)
-}

package/src/analysis/source-correctness.js

@@ -1,222 +0,0 @@
-// Conservative source-level correctness review signals. These checks deliberately recognize only
-// a few grounded patterns with local evidence; they are not a compiler, race detector, or proof that
-// the surrounding behavior is wrong.
-import { makeFinding } from "./findings.js";
-import {retryFindings} from './source-correctness/retry-patterns.js'
-import {lineNumberAt} from '../util.js'
-
-const lineAt = lineNumberAt;
-
-const lineText = (text, index) => {
-  const start = text.lastIndexOf("\n", Math.max(0, index - 1)) + 1;
-  const end = text.indexOf("\n", index);
-  return text.slice(start, end < 0 ? text.length : end).trim().slice(0, 300);
-};
-
-// Preserve byte offsets/newlines while removing comments and string contents from regex input.
-function maskNonCode(text, { hashComments = false } = {}) {
-  const chars = String(text || "").split("");
-  let quote = "", escaped = false, lineComment = false, blockComment = false;
-  for (let i = 0; i < chars.length; i++) {
-    const ch = chars[i], next = chars[i + 1];
-    if (lineComment) {
-      if (ch === "\n" || ch === "\r") lineComment = false;
-      else chars[i] = " ";
-      continue;
-    }
-    if (blockComment) {
-      if (ch === "*" && next === "/") { chars[i] = chars[i + 1] = " "; i++; blockComment = false; }
-      else if (ch !== "\n" && ch !== "\r") chars[i] = " ";
-      continue;
-    }
-    if (quote) {
-      if (ch !== "\n" && ch !== "\r") chars[i] = " ";
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === quote) quote = "";
-      continue;
-    }
-    if (ch === '"' || ch === "'" || ch === "`") { quote = ch; chars[i] = " "; continue; }
-    if (hashComments && ch === "#") { chars[i] = " "; lineComment = true; continue; }
-    if (ch === "/" && next === "/") { chars[i] = chars[i + 1] = " "; i++; lineComment = true; continue; }
-    if (ch === "/" && next === "*") { chars[i] = chars[i + 1] = " "; i++; blockComment = true; }
-  }
-  return chars.join("");
-}
-
-function balancedEnd(text, openAt) {
-  if (text[openAt] !== "{") return -1;
-  let depth = 0;
-  for (let i = openAt; i < text.length; i++) {
-    if (text[i] === "{") depth++;
-    else if (text[i] === "}" && --depth === 0) return i + 1;
-  }
-  return -1;
-}
-
-const escapeRegex = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const upperSnake = (value) => String(value || "")
-  .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-  .replace(/[^A-Za-z0-9]+/g, "_")
-  .replace(/^_+|_+$/g, "")
-  .toUpperCase();
-
-function goFunctions(masked) {
-  const functions = [];
-  const re = /\bfunc\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(([^)]*)\)[^{]*\{/g;
-  let match;
-  while ((match = re.exec(masked))) {
-    const open = re.lastIndex - 1;
-    const end = balancedEnd(masked, open);
-    if (end < 0) continue;
-    functions.push({ name: match[1], params: match[2], open, end, body: masked.slice(open + 1, end - 1) });
-    re.lastIndex = end;
-  }
-  return functions;
-}
-
-function goSliceFindings(text, masked, file) {
-  const findings = [];
-  for (const fn of goFunctions(masked)) {
-    const sliceParams = [...fn.params.matchAll(/(?:^|,)\s*([A-Za-z_]\w*)\s+\[\][^,)]*/g)].map((match) => match[1]);
-    for (const parameter of sliceParams) {
-      const slice = new RegExp(`\\b${escapeRegex(parameter)}\\s*\\[\\s*(?:0\\s*)?:\\s*(\\d+)\\s*\\]`, "g").exec(fn.body);
-      if (!slice || Number(slice[1]) < 1) continue;
-      const before = fn.body.slice(0, slice.index);
-      const lenGuard = new RegExp(`\\blen\\s*\\(\\s*${escapeRegex(parameter)}\\s*\\)`).test(before);
-      if (lenGuard) continue;
-      const index = fn.open + 1 + slice.index;
-      findings.push(makeFinding({
-        category: "structure",
-        rule: "go-unguarded-fixed-slice",
-        severity: "medium",
-        confidence: "high",
-        title: `Potential slice-bounds panic in ${fn.name}: ${parameter}[:${slice[1]}]`,
-        detail: `The slice parameter "${parameter}" is read to a fixed upper bound before any visible len(${parameter}) guard in this function. Confirm every caller guarantees at least ${slice[1]} element(s), or guard the access locally.`,
-        file,
-        line: lineAt(text, index),
-        symbol: `${fn.name}()`,
-        evidence: [{ file, line: lineAt(text, index), snippet: lineText(text, index) }],
-        fixHint: `validate len(${parameter}) >= ${slice[1]} before slicing`,
-      }));
-    }
-  }
-  return findings;
-}
-
-function goConstructorTypeFindings(text, masked, file) {
-  const findings = [];
-  for (const fn of goFunctions(masked)) {
-    if (!/^New[A-Z]/.test(fn.name)) continue;
-    const suffix = upperSnake(fn.name.slice(3));
-    if (!suffix) continue;
-    const assigned = /\b(?:Type|Kind)\s*:\s*([A-Z][A-Z0-9_]*(?:_TYPE_|_KIND_)[A-Z0-9_]+)\b/g.exec(fn.body);
-    if (!assigned) continue;
-    const markerAt = Math.max(assigned[1].lastIndexOf("_TYPE_"), assigned[1].lastIndexOf("_KIND_"));
-    const markerLength = 6;
-    const expected = `${assigned[1].slice(0, markerAt + markerLength)}${suffix}`;
-    if (expected === assigned[1] || !new RegExp(`\\b${escapeRegex(expected)}\\b`).test(masked)) continue;
-    const index = fn.open + 1 + assigned.index;
-    findings.push(makeFinding({
-      category: "structure",
-      rule: "constructor-enum-mismatch",
-      severity: "medium",
-      confidence: "high",
-      title: `Constructor/type discriminator mismatch: ${fn.name} uses ${assigned[1]}`,
-      detail: `The constructor name corresponds to the declared discriminator ${expected}, but the returned literal assigns ${assigned[1]}. This is a focused copy/paste review signal; confirm the intended wire type before changing it.`,
-      file,
-      line: lineAt(text, index),
-      symbol: `${fn.name}()`,
-      evidence: [{ file, line: lineAt(text, index), snippet: lineText(text, index) }],
-      fixHint: `verify whether the discriminator should be ${expected}`,
-    }));
-  }
-  return findings;
-}
-
-function javaInterruptFindings(text, masked, file) {
-  const findings = [];
-  const re = /\bcatch\s*\(\s*InterruptedException\s+([A-Za-z_]\w*)\s*\)\s*\{/g;
-  let match;
-  while ((match = re.exec(masked))) {
-    const open = re.lastIndex - 1;
-    const end = balancedEnd(masked, open);
-    if (end < 0) continue;
-    const body = masked.slice(open + 1, end - 1);
-    const restores = /\bThread\s*\.\s*currentThread\s*\(\s*\)\s*\.\s*interrupt\s*\(/.test(body);
-    const rethrows = new RegExp(`\\bthrow\\s+${escapeRegex(match[1])}\\s*;`).test(body)
-      || /\bthrow\s+new\s+InterruptedException\b/.test(body);
-    if (restores || rethrows) continue;
-    findings.push(makeFinding({
-      category: "structure",
-      rule: "java-interrupt-status-not-restored",
-      severity: "medium",
-      confidence: "high",
-      title: "InterruptedException caught without a visible interrupt restore",
-      detail: "The catch block neither directly rethrows InterruptedException nor calls Thread.currentThread().interrupt(). A helper may restore it indirectly, so review before changing; otherwise cancellation can be lost.",
-      file,
-      line: lineAt(text, match.index),
-      evidence: [{ file, line: lineAt(text, match.index), snippet: lineText(text, match.index) }],
-      fixHint: "restore the interrupt status or propagate the interruption according to the method contract",
-    }));
-    re.lastIndex = end;
-  }
-  return findings;
-}
-
-export function analyzeSourceCorrectness(sources, { isNonProductPath = () => false } = {}) {
-  const findings = [];
-  const supportedRuntimeFiles = new Set();
-  const concurrencyFiles = new Set();
-  const checks = {
-    goFixedSlice: { supportedFiles: 0, findings: 0 },
-    constructorDiscriminator: { supportedFiles: 0, findings: 0 },
-    javaInterrupt: { supportedFiles: 0, findings: 0 },
-    retryTermination: { supportedFiles: 0, findings: 0 },
-  };
-  for (const [file, source] of sources || []) {
-    if (isNonProductPath(file)) continue;
-    const text = String(source || "");
-    const go = /\.go$/i.test(file), java = /\.java$/i.test(file), python = /\.py$/i.test(file);
-    const masked = maskNonCode(text, { hashComments: python });
-    const retrySupported = /\.(?:[cm]?[jt]sx?|java|go|py)$/i.test(file);
-    if (go) {
-      supportedRuntimeFiles.add(file);
-      checks.goFixedSlice.supportedFiles++;
-      checks.constructorDiscriminator.supportedFiles++;
-      const slice = goSliceFindings(text, masked, file);
-      const discriminator = goConstructorTypeFindings(text, masked, file);
-      findings.push(...slice, ...discriminator);
-      checks.goFixedSlice.findings += slice.length;
-      checks.constructorDiscriminator.findings += discriminator.length;
-    }
-    if (java) {
-      supportedRuntimeFiles.add(file);
-      concurrencyFiles.add(file);
-      checks.javaInterrupt.supportedFiles++;
-      const interruption = javaInterruptFindings(text, masked, file);
-      findings.push(...interruption);
-      checks.javaInterrupt.findings += interruption.length;
-    }
-    if (retrySupported) {
-      supportedRuntimeFiles.add(file);
-      checks.retryTermination.supportedFiles++;
-      const retry = retryFindings(text, masked, file, {python});
-      findings.push(...retry);
-      checks.retryTermination.findings += retry.length;
-    }
-  }
-  return {
-    findings,
-    coverage: {
-      runtimeCorrectnessFiles: supportedRuntimeFiles.size,
-      concurrencyFiles: concurrencyFiles.size,
-      checks,
-      limitations: [
-        "bounded source patterns only",
-        "no compiler or runtime execution",
-        "no race detector; race freedom is not claimed",
-      ],
-    },
-  };
-}

package/src/analysis/static-test-reachability.js

@@ -1,150 +0,0 @@
-// A deliberately weaker fallback than real coverage: follow runtime graph edges out of test files
-// and report nearest test paths. This is evidence of static reachability only; it never claims a line,
-// branch or symbol executed. The traversal is bounded for large repositories.
-import { createPathClassifier, hasPathClass } from "../path-classification.js";
-import { isStructuralRelation } from "../graph/relations.js";
-
-const MAX_TEST_FILES = 250;
-const MAX_NEAREST_TESTS = 3;
-const MAX_DEPTH = 10;
-const MAX_STATES = 100_000;
-
-const normalize = (value) => String(value || "").replace(/\\/g, "/").replace(/^\.\//, "");
-const endpoint = (value) => String(value && typeof value === "object" ? value.id : value || "");
-const confidenceScore = (value) => {
-  const normalized = String(value || "").toUpperCase();
-  if (["EXTRACTED", "EXACT", "HIGH"].includes(normalized)) return 3;
-  if (["INFERRED", "MEDIUM"].includes(normalized)) return 2;
-  return 1;
-};
-const confidenceLabel = (score) => score >= 3 ? "HIGH" : score >= 2 ? "MEDIUM" : "LOW";
-const pathInScope = (path, prefix) => !prefix || path === prefix || path.startsWith(`${prefix}/`);
-
-export function computeStaticTestReachability(graph, {
-  repoRoot = null,
-  path = "",
-  maxDepth = MAX_DEPTH,
-  maxStates = MAX_STATES,
-  maxTests = MAX_TEST_FILES,
-  maxNearestTests = MAX_NEAREST_TESTS,
-} = {}) {
-  const nodes = graph?.nodes || [];
-  const links = graph?.links || [];
-  const classifier = createPathClassifier(repoRoot);
-  const classificationCache = new Map();
-  const classify = (file) => {
-    const normalized = normalize(file);
-    if (!classificationCache.has(normalized)) classificationCache.set(normalized, classifier.explain(normalized, { content: "" }));
-    return classificationCache.get(normalized);
-  };
-  // Files that carry inline test surfaces (Rust `#[cfg(test)]` modules / `#[test]` fns live inside the
-  // production file, so path classification alone never sees them). The graph flags these per symbol.
-  // These files are NOT seeded as whole-file BFS sources: at file granularity we cannot tell an inline
-  // test's out-edge from a same-file production call, so seeding the file would propagate its PRODUCTION
-  // call chains as if a test reached them. They are self-covered at distance 0 instead (an honest,
-  // conservative signal: "this file has its own tests"), never over-claiming reach to other files.
-  const testSurfaceFiles = new Set();
-  const isTest = (file) => hasPathClass(classify(file), "test", "e2e");
-  const isProduct = (file) => {
-    const info = classify(file);
-    return !info.excluded && !hasPathClass(info, "test", "e2e", "generated", "vendored", "mock", "story", "docs", "benchmark", "temp");
-  };
-
-  const idToFile = new Map();
-  const files = new Set();
-  for (const node of nodes) {
-    const file = normalize(node?.source_file || (!String(node?.id || "").includes("#") ? node?.id : ""));
-    if (!file) continue;
-    idToFile.set(String(node.id), file);
-    files.add(file);
-    if (node?.test_surface === true) testSurfaceFiles.add(file);
-  }
-
-  // Collapse symbol/file edges to directed file dependencies. Multiple symbol edges retain the best
-  // confidence for the same hop; compile-time-only and ownership relations never imply test reach.
-  const adjacency = new Map();
-  for (const link of links) {
-    if (!link || link.typeOnly === true || link.compileOnly === true || isStructuralRelation(link.relation)) continue;
-    const from = idToFile.get(endpoint(link.source));
-    const to = idToFile.get(endpoint(link.target));
-    if (!from || !to || from === to) continue;
-    if (!adjacency.has(from)) adjacency.set(from, new Map());
-    const score = confidenceScore(link.confidence);
-    const previous = adjacency.get(from).get(to);
-    if (!previous || score > previous.score) adjacency.get(from).set(to, { score, relation: link.relation || "dependency" });
-  }
-
-  const allTests = [...files].filter(isTest).sort((a, b) => a.localeCompare(b));
-  const testLimit = Math.max(0, Math.min(MAX_TEST_FILES, Number(maxTests) || MAX_TEST_FILES));
-  const tests = allTests.slice(0, testLimit);
-  const scope = normalize(path).replace(/\/+$/, "");
-  const productFiles = [...files].filter(isProduct).filter((file) => pathInScope(file, scope)).sort((a, b) => a.localeCompare(b));
-  const productSet = new Set(productFiles);
-  const nearest = new Map();
-  // A production file that carries its own inline tests is self-covered at distance 0: its tests exercise
-  // its own production symbols. This is the honest floor that fixes a false "0 reachable" for repos whose
-  // tests are all inline (Rust); it never asserts reach to OTHER files, so it cannot over-claim.
-  const inlineCovered = productFiles.filter((file) => testSurfaceFiles.has(file));
-  for (const file of inlineCovered) {
-    nearest.set(file, [{ test: file, distance: 0, score: 3, confidence: confidenceLabel(3), path: [file] }]);
-  }
-  const queue = tests.map((test) => ({ file: test, test, distance: 0, score: 3, path: [test] }));
-  const seen = new Map(tests.map((test) => [`${test}\0${test}`, 0]));
-  let cursor = 0;
-  let traversedStates = 0;
-  const depthLimit = Math.max(1, Math.min(MAX_DEPTH, Number(maxDepth) || MAX_DEPTH));
-  const stateLimit = Math.max(100, Math.min(MAX_STATES, Number(maxStates) || MAX_STATES));
-  const nearestLimit = Math.max(1, Math.min(MAX_NEAREST_TESTS, Number(maxNearestTests) || MAX_NEAREST_TESTS));
-
-  while (cursor < queue.length && traversedStates < stateLimit) {
-    const current = queue[cursor++];
-    traversedStates++;
-    if (current.distance >= depthLimit) continue;
-    for (const [next, edge] of adjacency.get(current.file) || []) {
-      const distance = current.distance + 1;
-      const score = Math.min(current.score, edge.score);
-      const key = `${current.test}\0${next}`;
-      if ((seen.get(key) ?? Infinity) <= distance) continue;
-      seen.set(key, distance);
-      const record = { test: current.test, distance, score, confidence: confidenceLabel(score), path: [...current.path, next] };
-      if (productSet.has(next)) {
-        const records = nearest.get(next) || [];
-        records.push(record);
-        records.sort((a, b) => a.distance - b.distance || b.score - a.score || a.test.localeCompare(b.test));
-        if (records.length > nearestLimit) records.length = nearestLimit;
-        nearest.set(next, records);
-      }
-      // Once enough nearer test paths meet at the same file, a longer test prefix cannot become a
-      // nearest path downstream because every continuation from this point is shared.
-      const records = nearest.get(next);
-      if (records?.length >= nearestLimit && !records.some((item) => item.test === current.test) && distance > records[records.length - 1].distance) continue;
-      queue.push({ file: next, test: current.test, distance, score, path: record.path });
-    }
-  }
-
-  const reachable = productFiles
-    .filter((file) => nearest.has(file))
-    .map((file) => ({ file, nearestTests: nearest.get(file) }))
-    .sort((a, b) => a.nearestTests[0].distance - b.nearestTests[0].distance || a.file.localeCompare(b.file));
-  const unreachable = productFiles.filter((file) => !nearest.has(file));
-  return {
-    kind: "staticTestReachability",
-    actualCoverage: "NOT_AVAILABLE",
-    // Inline-test files self-cover rather than seed the traversal, but they ARE test-bearing files, so
-    // the reported counts include them — otherwise a Rust repo would read "0 test files" beside real reach.
-    testFiles: tests.length + inlineCovered.length,
-    totalTestFiles: allTests.length + inlineCovered.length,
-    productFiles: productFiles.length,
-    reachableFiles: reachable.length,
-    unreachableFiles: unreachable.length,
-    reachable,
-    unreachable,
-    bounds: {
-      maxDepth: depthLimit,
-      maxStates: stateLimit,
-      traversedStates,
-      maxTests: testLimit,
-      truncated: allTests.length > tests.length || (cursor < queue.length && traversedStates >= stateLimit),
-    },
-  };
-}

package/src/analysis/structure/dependency-graph.js

@@ -1,151 +0,0 @@
-import {ENTRY_FILE} from '../dead-check.js'
-import {fileOfId, graphEndpointId} from '../../graph/node-id.js'
-
-const TEST_FILE_RE = /(^|[/])(test|tests|__tests__|spec|e2e|__mocks__)([/]|$)|[._-](test|spec)\.[a-z0-9]+$/i
-const NON_CODE_RE = /\.(json|ya?ml|sh|ps1|md|txt|html?|css|scss|less)$|(^|[/])(dockerfile|containerfile)/i
-const dirOf = (file) => file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
-
-export function buildFileImportGraph(graph, {includeTypeOnly = false, includeCompileOnly = false} = {}) {
-    const fileIds = new Set()
-    for (const node of graph.nodes || []) if (!String(node.id).includes('#')) fileIds.add(String(node.id))
-    const runtimeAdj = new Map(), allAdj = new Map()
-    const edges = [], allEdges = [], typeOnlyEdges = [], compileOnlyEdges = [], compileTimeEdges = []
-    const runtimeSeen = new Set(), allSeen = new Set(), typeSeen = new Set(), compileSeen = new Set(), compileTimeSeen = new Set()
-    const add = (map, source, target) => {
-        let targets = map.get(source)
-        if (!targets) map.set(source, (targets = new Set()))
-        targets.add(target)
-    }
-    for (const link of graph.links || []) {
-        if (link.relation !== 'imports' && link.relation !== 're_exports') continue
-        const source = graphEndpointId(link.source), target = graphEndpointId(link.target)
-        if (!fileIds.has(source) || !fileIds.has(target) || source === target) continue
-        if (source.endsWith('.go') && target.endsWith('.go') && dirOf(source) === dirOf(target)) continue
-        const key = `${source}\0${target}`
-        if (!allSeen.has(key)) { allSeen.add(key); add(allAdj, source, target); allEdges.push([source, target]) }
-        if (link.typeOnly === true || link.compileOnly === true) {
-            if (link.typeOnly === true && !typeSeen.has(key)) { typeSeen.add(key); typeOnlyEdges.push([source, target]) }
-            if (link.compileOnly === true && !compileSeen.has(key)) { compileSeen.add(key); compileOnlyEdges.push([source, target]) }
-            if (!compileTimeSeen.has(key)) { compileTimeSeen.add(key); compileTimeEdges.push([source, target]) }
-            continue
-        }
-        if (!runtimeSeen.has(key)) { runtimeSeen.add(key); add(runtimeAdj, source, target); edges.push([source, target]) }
-    }
-    return {
-        fileIds,
-        adj: includeTypeOnly || includeCompileOnly ? allAdj : runtimeAdj,
-        edges: includeTypeOnly || includeCompileOnly ? allEdges : edges,
-        runtimeAdj,
-        runtimeEdges: edges,
-        allAdj,
-        allEdges,
-        typeOnlyEdges: typeOnlyEdges.filter(([a, b]) => !runtimeSeen.has(`${a}\0${b}`)),
-        compileOnlyEdges: compileOnlyEdges.filter(([a, b]) => !runtimeSeen.has(`${a}\0${b}`)),
-        compileTimeEdges: compileTimeEdges.filter(([a, b]) => !runtimeSeen.has(`${a}\0${b}`)),
-    }
-}
-
-// Iterative Tarjan: repository graphs can be deep enough to overflow recursive JavaScript.
-export function findSccs(adjacency) {
-    const index = new Map(), low = new Map(), onStack = new Set(), nodes = []
-    let counter = 0
-    const components = []
-    for (const root of adjacency.keys()) {
-        if (index.has(root)) continue
-        index.set(root, counter); low.set(root, counter); counter++
-        nodes.push(root); onStack.add(root)
-        const stack = [{value: root, child: 0, neighbors: [...(adjacency.get(root) || [])]}]
-        while (stack.length) {
-            const frame = stack[stack.length - 1]
-            if (frame.child < frame.neighbors.length) {
-                const next = frame.neighbors[frame.child++]
-                if (!index.has(next)) {
-                    index.set(next, counter); low.set(next, counter); counter++
-                    nodes.push(next); onStack.add(next)
-                    stack.push({value: next, child: 0, neighbors: [...(adjacency.get(next) || [])]})
-                } else if (onStack.has(next)) low.set(frame.value, Math.min(low.get(frame.value), index.get(next)))
-                continue
-            }
-            stack.pop()
-            if (stack.length) {
-                const parent = stack[stack.length - 1]
-                low.set(parent.value, Math.min(low.get(parent.value), low.get(frame.value)))
-            }
-            if (low.get(frame.value) !== index.get(frame.value)) continue
-            const component = []
-            let value
-            do { value = nodes.pop(); onStack.delete(value); component.push(value) } while (value !== frame.value)
-            if (component.length > 1) components.push(component)
-        }
-    }
-    return components
-}
-
-export function representativeCycle(adjacency, component) {
-    const members = new Set(component)
-    const start = [...component].sort()[0]
-    const previous = new Map([[start, null]])
-    const queue = [start]
-    while (queue.length) {
-        const current = queue.shift()
-        for (const next of [...(adjacency.get(current) || [])].sort()) {
-            if (next === start) {
-                const path = []
-                for (let value = current; value != null; value = previous.get(value)) path.push(value)
-                return [...path.reverse(), start]
-            }
-            if (!members.has(next) || previous.has(next)) continue
-            previous.set(next, current)
-            queue.push(next)
-        }
-    }
-    const fallback = [...component].sort()
-    return [...fallback, fallback[0]]
-}
-
-export function findOrphans(graph, {entrySet = new Set(), externalImportFiles = new Set()} = {}) {
-    const degree = new Map()
-    for (const link of graph.links || []) {
-        if (link.relation === 'contains') continue
-        const source = fileOfId(graphEndpointId(link.source)), target = fileOfId(graphEndpointId(link.target))
-        if (source === target) continue
-        degree.set(source, (degree.get(source) || 0) + 1)
-        degree.set(target, (degree.get(target) || 0) + 1)
-    }
-    const out = []
-    for (const node of graph.nodes || []) {
-        const id = String(node.id)
-        if (id.includes('#') || (degree.get(id) || 0) > 0) continue
-        const file = node.source_file
-        if (entrySet.has(file) || ENTRY_FILE.test(file) || TEST_FILE_RE.test(file) || NON_CODE_RE.test(file)) continue
-        out.push({file, importsExternals: externalImportFiles.has(file)})
-    }
-    return out
-}
-
-export function globToRe(glob) {
-    const parts = String(glob).split('**').map((part) => part
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]'))
-    let source = parts.join('.*')
-    source = source.replace(/\/\.\*\//g, '/(?:.*/)?').replace(/^\.\*\//, '(?:.*/)?')
-    return new RegExp(`^${source}$`)
-}
-
-export function checkBoundaries(edges, rules = {}) {
-    const violations = []
-    const forbidden = (rules.forbidden || []).map((rule) => ({...rule, fromRe: globToRe(rule.from), toRe: globToRe(rule.to)}))
-    const allowedOnly = (rules.allowedOnly || []).map((rule) => ({
-        ...rule,
-        fromRe: globToRe(rule.from),
-        toRes: (Array.isArray(rule.to) ? rule.to : [rule.to]).map(globToRe),
-    }))
-    for (const [source, target] of edges) {
-        for (const rule of forbidden) if (rule.fromRe.test(source) && rule.toRe.test(target)) {
-            violations.push({name: rule.name, comment: rule.comment || '', severity: rule.severity, from: source, to: target, kind: 'forbidden'})
-        }
-        for (const rule of allowedOnly) if (rule.fromRe.test(source) && !rule.toRes.some((regexp) => regexp.test(target))) {
-            violations.push({name: rule.name, comment: rule.comment || '', severity: rule.severity, from: source, to: target, kind: 'allowedOnly'})
-        }
-    }
-    return violations
-}