@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/dist/clients/call-graph.js

@@ -0,0 +1,628 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "./file-utils.js";
+import { writeFileAtomic } from "./atomic-write.js";
+import { parseSymbolKey as parseCanonicalSymbolKey } from "./review-graph/symbol-id.js";
+import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
+export const CALL_GRAPH_CACHE_VERSION = 5;
+function severityForDepth(depth) {
+  if (depth === 1)
+    return "WillBreak";
+  if (depth === 2)
+    return "MayBreak";
+  return "Review";
+}
+export function impact(graph, startKey, maxDepth = 3, minWeight = 0.1) {
+  const results = [];
+  const visited = new Set([startKey]);
+  const queue = [
+    { key: startKey, depth: 0 }
+  ];
+  const edgeWeightMap = new Map;
+  for (const edge of graph.edges) {
+    const edgeKey = `${edge.calleeKey}→${edge.callerKey}`;
+    const existing = edgeWeightMap.get(edgeKey) ?? 0;
+    edgeWeightMap.set(edgeKey, Math.max(existing, edge.weight));
+  }
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (item.depth >= maxDepth)
+      continue;
+    const directCallers = graph.callers.get(item.key);
+    if (!directCallers)
+      continue;
+    for (const callerKey of directCallers) {
+      if (visited.has(callerKey))
+        continue;
+      const edgeKey = `${item.key}→${callerKey}`;
+      const weight = edgeWeightMap.get(edgeKey) ?? 1;
+      if (weight < minWeight)
+        continue;
+      visited.add(callerKey);
+      const depth = item.depth + 1;
+      results.push({
+        symbolKey: callerKey,
+        depth,
+        severity: severityForDepth(depth)
+      });
+      queue.push({ key: callerKey, depth });
+    }
+  }
+  return results.sort((a, b) => a.depth - b.depth || a.symbolKey.localeCompare(b.symbolKey));
+}
+export function parseSymbolKey(key, knownFilePath) {
+  return parseCanonicalSymbolKey(key, knownFilePath);
+}
+export function formatImpact(results, projectRoot) {
+  if (results.length === 0)
+    return "";
+  const willBreak = results.filter((r) => r.severity === "WillBreak");
+  const mayBreak = results.filter((r) => r.severity === "MayBreak");
+  const review = results.filter((r) => r.severity === "Review");
+  const parts = [];
+  const label = (r) => {
+    const parsed = parseSymbolKey(r.symbolKey);
+    const name = parsed.symbolName ?? r.symbolKey;
+    const file = toProjectRelativePath(parsed.filePath, projectRoot);
+    return file ? `${name} (${file})` : name;
+  };
+  if (willBreak.length > 0) {
+    parts.push(willBreak.slice(0, 3).map((r) => `${label(r)} ⚠ WillBreak`).join(", "));
+  }
+  if (mayBreak.length > 0) {
+    parts.push(mayBreak.slice(0, 2).map((r) => `${label(r)} MayBreak`).join(", "));
+  }
+  if (review.length > 0) {
+    parts.push(`${review.length} Review caller${review.length === 1 ? "" : "s"}`);
+  }
+  return parts.join(" → ");
+}
+const STDLIB_NAMES = new Set([
+  "console",
+  "Math",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Promise",
+  "Error",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "JSON",
+  "Date",
+  "RegExp",
+  "Symbol",
+  "BigInt",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "setTimeout",
+  "clearTimeout",
+  "setInterval",
+  "clearInterval",
+  "fetch",
+  "URL",
+  "URLSearchParams",
+  "Buffer",
+  "process",
+  "require",
+  "print",
+  "len",
+  "range",
+  "list",
+  "dict",
+  "str",
+  "int",
+  "float",
+  "bool",
+  "open",
+  "isinstance",
+  "issubclass",
+  "type",
+  "super",
+  "hasattr",
+  "getattr",
+  "setattr",
+  "enumerate",
+  "zip",
+  "map",
+  "filter",
+  "sorted",
+  "reversed",
+  "fmt",
+  "log",
+  "os",
+  "io",
+  "err",
+  "make",
+  "append",
+  "cap",
+  "copy",
+  "close",
+  "delete",
+  "panic",
+  "recover",
+  "new",
+  "eprintln",
+  "eprint",
+  "vec",
+  "Some",
+  "None",
+  "Ok",
+  "Err",
+  "Box",
+  "Rc",
+  "Arc",
+  "Vec",
+  "HashMap",
+  "HashSet",
+  "format",
+  "System",
+  "toString",
+  "equals",
+  "hashCode",
+  "Objects",
+  "this",
+  "self",
+  "nil",
+  "null",
+  "undefined",
+  "true",
+  "false"
+]);
+function buildDefIndex(allSymbols) {
+  const byName = new Map;
+  const byId = new Map;
+  for (const [, symbols] of allSymbols) {
+    for (const sym of symbols) {
+      if (!sym.name || !sym.id)
+        continue;
+      const key = sym.id;
+      byId.set(key, sym);
+      const existing = byName.get(sym.name) ?? [];
+      if (!existing.includes(key))
+        existing.push(key);
+      byName.set(sym.name, existing);
+    }
+  }
+  return { byName, byId };
+}
+function findEnclosingSymbol(symbols, refLine) {
+  let best;
+  for (const sym of symbols) {
+    if (sym.line <= refLine && (sym.endLine === undefined || refLine <= sym.endLine) && (sym.kind === "function" || sym.kind === "method")) {
+      if (!best || sym.line > best.line)
+        best = sym;
+    }
+  }
+  return best;
+}
+export function buildCallGraph(allSymbols, allRefs, inputCoverage) {
+  const canonicalSymbols = new Map;
+  for (const [filePath, symbols] of allSymbols)
+    canonicalSymbols.set(normalizeMapKey(filePath), symbols);
+  const defIndex = buildDefIndex(canonicalSymbols);
+  const callees = new Map;
+  const callers = new Map;
+  const inDegree = new Map;
+  const edgeByPair = new Map;
+  let unresolvedRefs = 0;
+  let totalRefs = 0;
+  const hasInputCoverage = inputCoverage !== undefined;
+  const coverage = inputCoverage ? { ...inputCoverage } : {
+    totalEvidence: 0,
+    callsEvidence: 0,
+    referencesEvidence: 0,
+    eligibleEvidence: 0,
+    resolvedEvidence: 0,
+    unresolvedEvidence: 0,
+    typeOnlyEvidence: 0,
+    unsupportedEvidence: 0,
+    sameFileEvidence: 0,
+    duplicateEvidence: 0,
+    complete: false
+  };
+  for (const [callerFile, refs] of allRefs) {
+    const callerFileKey = normalizeMapKey(callerFile);
+    const callerSymbols = canonicalSymbols.get(callerFileKey) ?? [];
+    for (const ref of refs) {
+      totalRefs++;
+      if (!hasInputCoverage) {
+        coverage.totalEvidence++;
+        if (ref.evidenceKind === "references" || ref.referenceKind === "type")
+          coverage.referencesEvidence++;
+        else
+          coverage.callsEvidence++;
+      }
+      if (ref.referenceKind === "type") {
+        if (!hasInputCoverage)
+          coverage.typeOnlyEvidence++;
+        continue;
+      }
+      if (ref.evidenceKind && ref.referenceKind !== "call") {
+        if (!hasInputCoverage)
+          coverage.unsupportedEvidence++;
+        continue;
+      }
+      const candidates = [];
+      if (ref.targetId) {
+        const callee = defIndex.byId.get(ref.targetId);
+        if (!callee || ref.resolution === "name-only" || ref.resolution === "unresolved") {
+          if (!hasInputCoverage) {
+            unresolvedRefs++;
+            coverage.unresolvedEvidence++;
+          }
+          continue;
+        }
+        candidates.push({
+          callee,
+          resolution: ref.resolution ?? "exact",
+          candidateCount: 1
+        });
+      } else {
+        const refName = ref.symbolName ?? parseSymbolKey(ref.symbolId, callerFile).symbolName ?? "";
+        if (STDLIB_NAMES.has(refName) || !refName) {
+          if (!hasInputCoverage)
+            coverage.unsupportedEvidence++;
+          continue;
+        }
+        const defs = defIndex.byName.get(refName);
+        if (!defs || defs.length === 0) {
+          if (!hasInputCoverage) {
+            unresolvedRefs++;
+            coverage.unresolvedEvidence++;
+          }
+          continue;
+        }
+        const crossFileDefs = defs.map((id) => defIndex.byId.get(id)).filter((candidate) => candidate !== undefined && normalizeMapKey(candidate.filePath) !== callerFileKey);
+        if (crossFileDefs.length === 0) {
+          if (!hasInputCoverage)
+            coverage.unsupportedEvidence++;
+          continue;
+        }
+        const resolution = crossFileDefs.length === 1 ? "exact" : "name-only";
+        for (const callee of crossFileDefs) {
+          candidates.push({
+            callee,
+            resolution,
+            candidateCount: crossFileDefs.length
+          });
+        }
+      }
+      if (ref.evidenceKind && candidates.some(({ resolution }) => resolution === "name-only")) {
+        if (!hasInputCoverage) {
+          unresolvedRefs++;
+          coverage.unresolvedEvidence++;
+        }
+        continue;
+      }
+      const caller = ref.callerSymbolId ? defIndex.byId.get(ref.callerSymbolId) : undefined;
+      const enclosing = caller ?? findEnclosingSymbol(callerSymbols, ref.line);
+      const callerKey = enclosing?.id ?? `file:${callerFile}`;
+      let producedEdge = false;
+      let duplicateRef = false;
+      for (const { callee, resolution, candidateCount } of candidates) {
+        if (normalizeMapKey(callee.filePath) === callerFileKey) {
+          coverage.sameFileEvidence++;
+          if (hasInputCoverage) {
+            coverage.eligibleEvidence--;
+            coverage.resolvedEvidence--;
+          }
+          continue;
+        }
+        producedEdge = true;
+        const pairKey = `${callerKey}\x00${callee.id}`;
+        const existing = edgeByPair.get(pairKey);
+        if (existing) {
+          existing.evidenceCount = (existing.evidenceCount ?? 1) + 1;
+          existing.evidenceKind = existing.evidenceKind === ref.evidenceKind ? existing.evidenceKind : "mixed";
+          duplicateRef = true;
+          continue;
+        }
+        const weight = ref.evidenceKind ? 1 : 1 / Math.max(1, candidateCount);
+        const edge = {
+          callerFile,
+          callerSymbol: enclosing?.name,
+          callerKey,
+          callerKind: enclosing?.kind,
+          callerLine: enclosing?.line,
+          callerColumn: enclosing?.column,
+          calleeFile: callee.filePath,
+          calleeSymbol: callee.name,
+          calleeKey: callee.id,
+          calleeKind: callee.kind,
+          calleeLine: callee.line,
+          calleeColumn: callee.column,
+          evidenceKind: ref.evidenceKind,
+          resolution,
+          evidenceCount: 1,
+          weight
+        };
+        edgeByPair.set(pairKey, edge);
+        const callerCallees = callees.get(callerKey) ?? new Set;
+        callerCallees.add(callee.id);
+        callees.set(callerKey, callerCallees);
+        const calleeCallers = callers.get(callee.id) ?? new Set;
+        calleeCallers.add(callerKey);
+        callers.set(callee.id, calleeCallers);
+        inDegree.set(callee.id, (inDegree.get(callee.id) ?? 0) + weight);
+      }
+      if (!hasInputCoverage && producedEdge) {
+        coverage.eligibleEvidence++;
+        coverage.resolvedEvidence++;
+        if (duplicateRef)
+          coverage.duplicateEvidence++;
+      }
+      if (hasInputCoverage && producedEdge && duplicateRef)
+        coverage.duplicateEvidence++;
+    }
+  }
+  if (hasInputCoverage)
+    totalRefs = coverage.totalEvidence;
+  const languagesKnownComplete = Object.values(coverage.languages ?? {}).every((status) => status === "complete");
+  coverage.complete = coverage.complete && hasInputCoverage && coverage.unsupportedEvidence === 0 && languagesKnownComplete && (allSymbols.size > 0 || coverage.totalEvidence > 0);
+  return {
+    callees,
+    callers,
+    inDegree,
+    edges: [...edgeByPair.values()],
+    unresolvedRefs: hasInputCoverage ? coverage.unresolvedEvidence : unresolvedRefs,
+    totalRefs,
+    coverage,
+    builtAt: new Date().toISOString()
+  };
+}
+function cacheFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "call-graph.json");
+}
+function metaFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "call-graph.meta.json");
+}
+export function saveCallGraph(cwd, graph, identity) {
+  const cacheFile = cacheFilePath(cwd);
+  const metaFile = metaFilePath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+    const persisted = {
+      version: CALL_GRAPH_CACHE_VERSION,
+      builtAt: graph.builtAt,
+      reviewGraphVersion: identity.reviewGraphVersion,
+      reviewGraphSignature: identity.reviewGraphSignature,
+      edges: graph.edges,
+      callees: [...graph.callees.entries()].map(([k, v]) => [k, [...v]]),
+      callers: [...graph.callers.entries()].map(([k, v]) => [k, [...v]]),
+      inDegree: [...graph.inDegree.entries()],
+      totalRefs: graph.totalRefs,
+      unresolvedRefs: graph.unresolvedRefs,
+      coverage: graph.coverage
+    };
+    writeFileAtomic(cacheFile, JSON.stringify(persisted));
+    writeFileAtomic(metaFile, JSON.stringify({
+      savedAt: new Date().toISOString(),
+      edgeCount: graph.edges.length
+    }));
+  } catch {}
+}
+function inferLegacyCoverage(edges) {
+  let weightedTotalEvidence = 0;
+  let weightedReferencesEvidence = 0;
+  let weightedDuplicateEvidence = 0;
+  for (const edge of edges) {
+    const count = Number.isFinite(edge.evidenceCount) && (edge.evidenceCount ?? 0) > 0 ? Math.floor(edge.evidenceCount) : 1;
+    const weight = Number.isFinite(edge.weight) && edge.weight >= 0 ? edge.weight : 1;
+    weightedTotalEvidence += count * weight;
+    weightedDuplicateEvidence += Math.max(0, count - 1) * weight;
+    if (edge.evidenceKind === "references")
+      weightedReferencesEvidence += count * weight;
+  }
+  const totalEvidence = Math.max(0, Math.round(weightedTotalEvidence));
+  const referencesEvidence = Math.max(0, Math.round(weightedReferencesEvidence));
+  const duplicateEvidence = Math.max(0, Math.round(weightedDuplicateEvidence));
+  return {
+    totalEvidence,
+    callsEvidence: totalEvidence - referencesEvidence,
+    referencesEvidence,
+    eligibleEvidence: totalEvidence,
+    resolvedEvidence: totalEvidence,
+    unresolvedEvidence: 0,
+    typeOnlyEvidence: 0,
+    unsupportedEvidence: 0,
+    sameFileEvidence: 0,
+    duplicateEvidence,
+    complete: false
+  };
+}
+function loadCoverage(rawCoverage, edges) {
+  const inferred = inferLegacyCoverage(edges);
+  return rawCoverage ? {
+    ...inferred,
+    ...rawCoverage
+  } : inferred;
+}
+function finiteCount(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function countsMatch(left, right) {
+  return Math.abs(left - right) <= 0.000000001 * Math.max(1, Math.abs(left), Math.abs(right));
+}
+function validatePersistedCallGraph(raw, coverage) {
+  const nonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+  const enumValue = (value, values) => typeof value === "string" && values.includes(value);
+  const edgeKinds = ["calls", "references", "mixed"];
+  const resolutions = [
+    "exact",
+    "import",
+    "receiver-type",
+    "name-only",
+    "unresolved"
+  ];
+  if (!raw || raw.version !== CALL_GRAPH_CACHE_VERSION || !nonEmptyString(raw.builtAt))
+    return false;
+  if (!nonEmptyString(raw.reviewGraphVersion) || !nonEmptyString(raw.reviewGraphSignature))
+    return false;
+  if (raw.coverage !== undefined && (!raw.coverage || typeof raw.coverage !== "object" || Array.isArray(raw.coverage)))
+    return false;
+  if (!Array.isArray(raw.edges) || !Array.isArray(raw.callees) || !Array.isArray(raw.callers) || !Array.isArray(raw.inDegree))
+    return false;
+  const coverageValues = [
+    coverage.totalEvidence,
+    coverage.callsEvidence,
+    coverage.referencesEvidence,
+    coverage.eligibleEvidence,
+    coverage.resolvedEvidence,
+    coverage.unresolvedEvidence,
+    coverage.typeOnlyEvidence,
+    coverage.unsupportedEvidence,
+    coverage.sameFileEvidence,
+    coverage.duplicateEvidence
+  ];
+  if (typeof coverage.complete !== "boolean" || coverageValues.some((value) => !finiteCount(value)))
+    return false;
+  if (coverage.languages !== undefined && (!coverage.languages || typeof coverage.languages !== "object" || Array.isArray(coverage.languages) || Object.entries(coverage.languages).some(([language, status]) => !nonEmptyString(language) || !enumValue(status, ["complete", "partial", "unavailable"]))))
+    return false;
+  if (coverage.callsEvidence + coverage.referencesEvidence !== coverage.totalEvidence)
+    return false;
+  if (coverage.resolvedEvidence > coverage.eligibleEvidence)
+    return false;
+  if (coverage.eligibleEvidence !== coverage.resolvedEvidence)
+    return false;
+  if (coverage.resolvedEvidence + coverage.unresolvedEvidence + coverage.typeOnlyEvidence + coverage.unsupportedEvidence + coverage.sameFileEvidence !== coverage.totalEvidence)
+    return false;
+  if (coverage.complete && coverage.unsupportedEvidence > 0)
+    return false;
+  if (coverage.complete && Object.values(coverage.languages ?? {}).some((status) => status !== "complete"))
+    return false;
+  const expectedCallees = new Map;
+  const expectedCallers = new Map;
+  const expectedInDegree = new Map;
+  const pairKeys = new Set;
+  let weightedEdgeEvidence = 0;
+  let weightedDuplicateEvidence = 0;
+  for (const edge of raw.edges) {
+    if (!edge || typeof edge !== "object" || !nonEmptyString(edge.callerKey) || !nonEmptyString(edge.calleeKey) || !nonEmptyString(edge.callerFile) || !nonEmptyString(edge.calleeFile) || !nonEmptyString(edge.calleeSymbol) || typeof edge.weight !== "number" || !Number.isFinite(edge.weight) || edge.weight <= 0 || edge.weight > 1)
+      return false;
+    if (edge.callerSymbol !== undefined && !nonEmptyString(edge.callerSymbol))
+      return false;
+    if (edge.callerKind !== undefined && !nonEmptyString(edge.callerKind))
+      return false;
+    if (edge.calleeKind !== undefined && !nonEmptyString(edge.calleeKind))
+      return false;
+    if (edge.evidenceKind !== undefined && !enumValue(edge.evidenceKind, edgeKinds))
+      return false;
+    if (edge.resolution !== undefined && !enumValue(edge.resolution, resolutions))
+      return false;
+    if (edge.evidenceCount !== undefined && (!finiteCount(edge.evidenceCount) || edge.evidenceCount < 1))
+      return false;
+    const evidenceCount = edge.evidenceCount ?? 1;
+    const callerIdentity = parseCanonicalSymbolKey(edge.callerKey, edge.callerFile);
+    const calleeIdentity = parseCanonicalSymbolKey(edge.calleeKey, edge.calleeFile);
+    if (normalizeMapKey(callerIdentity.filePath) !== normalizeMapKey(edge.callerFile) || normalizeMapKey(calleeIdentity.filePath) !== normalizeMapKey(edge.calleeFile) || calleeIdentity.symbolName !== undefined && calleeIdentity.symbolName !== edge.calleeSymbol || callerIdentity.symbolName !== undefined && edge.callerSymbol !== undefined && callerIdentity.symbolName !== edge.callerSymbol)
+      return false;
+    const pair = `${edge.callerKey}\x00${edge.calleeKey}`;
+    if (pairKeys.has(pair))
+      return false;
+    pairKeys.add(pair);
+    weightedEdgeEvidence += evidenceCount * edge.weight;
+    weightedDuplicateEvidence += (evidenceCount - 1) * edge.weight;
+    const callees = expectedCallees.get(edge.callerKey) ?? new Set;
+    callees.add(edge.calleeKey);
+    expectedCallees.set(edge.callerKey, callees);
+    const callers = expectedCallers.get(edge.calleeKey) ?? new Set;
+    callers.add(edge.callerKey);
+    expectedCallers.set(edge.calleeKey, callers);
+    expectedInDegree.set(edge.calleeKey, (expectedInDegree.get(edge.calleeKey) ?? 0) + edge.weight);
+  }
+  if (!countsMatch(weightedEdgeEvidence, coverage.resolvedEvidence))
+    return false;
+  if (!countsMatch(weightedDuplicateEvidence, coverage.duplicateEvidence))
+    return false;
+  if (!countsMatch(coverage.totalEvidence, weightedEdgeEvidence + coverage.unresolvedEvidence + coverage.typeOnlyEvidence + coverage.unsupportedEvidence + coverage.sameFileEvidence))
+    return false;
+  if (raw.totalRefs !== undefined && !finiteCount(raw.totalRefs))
+    return false;
+  if (raw.unresolvedRefs !== undefined && !finiteCount(raw.unresolvedRefs))
+    return false;
+  if (raw.totalRefs !== undefined && raw.totalRefs !== coverage.totalEvidence)
+    return false;
+  if (raw.unresolvedRefs !== undefined && raw.unresolvedRefs !== coverage.unresolvedEvidence)
+    return false;
+  const readAdjacency = (entries) => {
+    const result = new Map;
+    if (!Array.isArray(entries))
+      return;
+    for (const entry of entries) {
+      if (!Array.isArray(entry) || !nonEmptyString(entry[0]) || !Array.isArray(entry[1]) || entry[1].some((key) => !nonEmptyString(key)))
+        return;
+      const keys = entry[1];
+      if (new Set(keys).size !== keys.length || result.has(entry[0]))
+        return;
+      result.set(entry[0], new Set(keys));
+    }
+    return result;
+  };
+  const actualCallees = readAdjacency(raw.callees);
+  const actualCallers = readAdjacency(raw.callers);
+  if (!actualCallees || !actualCallers || actualCallees.size !== expectedCallees.size || actualCallers.size !== expectedCallers.size)
+    return false;
+  const sameSets = (actual, expected) => {
+    for (const [key, values] of expected) {
+      const got = actual.get(key);
+      if (!got || got.size !== values.size || [...values].some((value) => !got.has(value)))
+        return false;
+    }
+    return true;
+  };
+  if (!sameSets(actualCallees, expectedCallees) || !sameSets(actualCallers, expectedCallers))
+    return false;
+  const actualInDegree = new Map;
+  for (const entry of raw.inDegree) {
+    if (!Array.isArray(entry) || !nonEmptyString(entry[0]) || typeof entry[1] !== "number" || !Number.isFinite(entry[1]) || entry[1] < 0 || actualInDegree.has(entry[0]))
+      return false;
+    actualInDegree.set(entry[0], entry[1]);
+  }
+  if (actualInDegree.size !== expectedInDegree.size)
+    return false;
+  for (const [key, value] of expectedInDegree) {
+    if (actualInDegree.get(key) !== value)
+      return false;
+  }
+  return true;
+}
+export function loadCallGraph(cwd, expectedIdentity) {
+  const cacheFile = cacheFilePath(cwd);
+  try {
+    const raw = JSON.parse(fs.readFileSync(cacheFile, "utf-8"));
+    if (raw.version !== CALL_GRAPH_CACHE_VERSION)
+      return;
+    if (typeof raw.reviewGraphVersion !== "string" || typeof raw.reviewGraphSignature !== "string")
+      return;
+    const identity = {
+      reviewGraphVersion: raw.reviewGraphVersion,
+      reviewGraphSignature: raw.reviewGraphSignature
+    };
+    if (expectedIdentity && (identity.reviewGraphVersion !== expectedIdentity.reviewGraphVersion || identity.reviewGraphSignature !== expectedIdentity.reviewGraphSignature))
+      return;
+    const coverage = loadCoverage(raw.coverage, raw.edges);
+    if (!validatePersistedCallGraph(raw, coverage))
+      return;
+    return {
+      graph: {
+        callees: new Map(raw.callees.map(([k, v]) => [k, new Set(v)])),
+        callers: new Map(raw.callers.map(([k, v]) => [k, new Set(v)])),
+        inDegree: new Map(raw.inDegree),
+        edges: raw.edges,
+        unresolvedRefs: raw.unresolvedRefs ?? coverage.unresolvedEvidence,
+        totalRefs: raw.totalRefs ?? coverage.totalEvidence,
+        coverage,
+        builtAt: raw.builtAt
+      },
+      identity
+    };
+  } catch {
+    return;
+  }
+}