weavatrix 0.1.4 → 0.2.0

package/src/graph/builder/lang-js.js

@@ -16,6 +16,16 @@ const TOPVARS = `
   (program (export_statement (variable_declaration (variable_declarator) @decl)))`;
 const REQUIRE = `(variable_declarator name: (_) @lhs value: (call_expression function: (identifier) @req arguments: (arguments (string (string_fragment) @src))))`;
 
+function parseExportSpecifiers(raw) {
+  return String(raw || "").split(",").map((part) => {
+    const text = part.trim();
+    const typeOnly = /^type\s+/.test(text);
+    const clean = text.replace(/^type\s+/, "").trim();
+    const match = clean.match(/^([A-Za-z_$][\w$]*|default)(?:\s+as\s+([A-Za-z_$][\w$]*|default))?$/);
+    return match ? { imported: match[1], exported: match[2] || match[1], typeOnly } : null;
+  }).filter(Boolean);
+}
+
 export default {
   family: "js",
   grammars: ["javascript", "typescript", "tsx"],
@@ -26,6 +36,7 @@ export default {
 
   pass1(ctx) {
     const { grammar, tree, fileRel, caps, field, addSym, addImportEdge, addExternalImport, markExported, imports, resolveJsImport, resolveAlias } = ctx;
+    const recordJsExport = typeof ctx.recordJsExport === "function" ? ctx.recordJsExport : () => {};
     // exported-ness of a declaration = an export_statement ancestor (export function/class/const …).
     // BOUNDED climb: web-tree-sitter's node.parent is O(depth) (re-walks a cursor from the root each call),
     // so an UNBOUNDED walk to `program` for every symbol was O(depth^3) and HUNG the build for minutes/hours
@@ -34,15 +45,16 @@ export default {
     // not a module-level export → bail immediately. See [[graph-builder-internalization]].
     // Early-out for nested scopes keeps this O(1); class members are intentionally never module exports even
     // when their owner class is exported. The hop cap remains a backstop for malformed/deep syntax trees.
-    const isExportedDecl = (node) => {
+    const exportStatementOf = (node) => {
       let p = node.parent;
       for (let hops = 0; p && hops < 6; hops++) {
-        if (p.type === "export_statement") return true;
-        if (p.type === "program" || p.type === "statement_block" || p.type === "class_body") return false;
+        if (p.type === "export_statement") return p;
+        if (p.type === "program" || p.type === "statement_block" || p.type === "class_body") return null;
         p = p.parent;
       }
-      return false;
+      return null;
     };
+    const isExportedDecl = (node) => !!exportStatementOf(node);
     const isModuleDeclaration = (node) => {
       let p = node.parent;
       for (let hops = 0; p && hops < 8; hops++) {
@@ -78,21 +90,32 @@ export default {
     };
     for (const cap of caps(grammar, FUNCS, tree.rootNode)) {
       const isMethod = cap.name === "method";
+      const exportStatement = !isMethod && exportStatementOf(cap.node);
       addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name !== "class", {
         sourceNode: cap.node.parent,
-        ...(!isMethod && isExportedDecl(cap.node) ? { exported: true } : {}),
+        ...(exportStatement ? { exported: true } : {}),
         ...(isMethod ? methodMetadata(cap.node) : { symbolKind: cap.name === "class" ? "class" : "function", moduleDeclaration: isModuleDeclaration(cap.node) })
       });
+      if (exportStatement) {
+        recordJsExport({
+          kind: "local",
+          exported: /^\s*export\s+default\b/.test(exportStatement.text) ? "default" : cap.node.text,
+          local: cap.node.text,
+          typeOnly: false,
+        });
+      }
     }
     for (const cap of caps(grammar, TOPVARS, tree.rootNode)) {
       const nameNode = field(cap.node, "name"); if (!nameNode || nameNode.type !== "identifier") continue;
       const val = field(cap.node, "value");
+      const exported = isExportedDecl(cap.node);
       addSym(nameNode.text, nameNode.startPosition.row + 1, !!(val && CALLABLE.test(val.type)), {
         sourceNode: val || cap.node,
-        ...(isExportedDecl(cap.node) ? { exported: true } : {}),
+        ...(exported ? { exported: true } : {}),
         symbolKind: "variable",
         moduleDeclaration: true
       });
+      if (exported) recordJsExport({ kind: "local", exported: nameNode.text, local: nameNode.text, typeOnly: false });
     }
 
     const importTypeOnly = (node) => {
@@ -127,9 +150,9 @@ export default {
       addImportEdge(tgt, { typeOnly, line, specifier: rawSpec });
       const clause = node.namedChildren.find((c) => c.type === "import_clause"); if (!clause) continue;
       for (const c of clause.namedChildren) {
-        if (c.type === "identifier") imports.set(c.text, { imported: "default", targetFile: tgt, typeOnly });
-        else if (c.type === "namespace_import") { const id = c.namedChildren.find((x) => x.type === "identifier"); if (id) imports.set(id.text, { imported: "*", targetFile: tgt, typeOnly }); }
-        else if (c.type === "named_imports") for (const s of c.namedChildren) { if (s.type !== "import_specifier") continue; const nm = field(s, "name"), al = field(s, "alias"); if (nm) imports.set((al || nm).text, { imported: nm.text, targetFile: tgt, typeOnly: typeOnly || /^\s*type\b/.test(s.text) }); }
+        if (c.type === "identifier") imports.set(c.text, { imported: "default", targetFile: tgt, typeOnly, line, specifier: rawSpec });
+        else if (c.type === "namespace_import") { const id = c.namedChildren.find((x) => x.type === "identifier"); if (id) imports.set(id.text, { imported: "*", targetFile: tgt, typeOnly, line, specifier: rawSpec }); }
+        else if (c.type === "named_imports") for (const s of c.namedChildren) { if (s.type !== "import_specifier") continue; const nm = field(s, "name"), al = field(s, "alias"); if (nm) imports.set((al || nm).text, { imported: nm.text, targetFile: tgt, typeOnly: typeOnly || /^\s*type\b/.test(s.text), line, specifier: rawSpec }); }
       }
     }
 
@@ -140,8 +163,8 @@ export default {
       const tgt = resolveJsImport(fileRel, cap.node.text); if (!tgt) continue;
       addImportEdge(tgt, { typeOnly: false, line: cap.node.startPosition.row + 1, specifier: cap.node.text });
       const lhs = dv && field(dv, "name");
-      if (lhs && lhs.type === "identifier") imports.set(lhs.text, { imported: "*", targetFile: tgt });
-      else if (lhs && lhs.type === "object_pattern") for (const p of lhs.namedChildren) { const key = field(p, "key") || (p.type === "shorthand_property_identifier_pattern" ? p : null); const val = field(p, "value"); const local = (val && val.type === "identifier") ? val : key; if (key && local) imports.set(local.text, { imported: key.text, targetFile: tgt }); }
+      if (lhs && lhs.type === "identifier") imports.set(lhs.text, { imported: "*", targetFile: tgt, line: cap.node.startPosition.row + 1, specifier: cap.node.text });
+      else if (lhs && lhs.type === "object_pattern") for (const p of lhs.namedChildren) { const key = field(p, "key") || (p.type === "shorthand_property_identifier_pattern" ? p : null); const val = field(p, "value"); const local = (val && val.type === "identifier") ? val : key; if (key && local) imports.set(local.text, { imported: key.text, targetFile: tgt, line: cap.node.startPosition.row + 1, specifier: cap.node.text }); }
     }
 
     // ---- CJS require, ALL forms (side-effect require("dotenv/config") included): bare-pkg records +
@@ -186,11 +209,47 @@ export default {
       const line = node.startPosition.row + 1;
       const typeOnly = reexportTypeOnly(node);
       const tgt = resolveJsImport(fileRel, rawSpec);
-      if (tgt) addImportEdge(tgt, { relation: "re_exports", typeOnly, line, specifier: rawSpec });
+      if (tgt) {
+        addImportEdge(tgt, { relation: "re_exports", typeOnly, line, specifier: rawSpec });
+        const text = node.text.trim();
+        const star = text.match(/^export\s+(type\s+)?\*\s+from\b/);
+        const namespace = text.match(/^export\s+(type\s+)?\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\b/);
+        const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}\s+from\b/);
+        if (namespace) {
+          recordJsExport({ kind: "namespace", exported: namespace[2], targetFile: tgt, typeOnly: !!namespace[1] });
+        } else if (star) {
+          recordJsExport({ kind: "star", targetFile: tgt, typeOnly: !!star[1] });
+        } else if (clause) {
+          for (const spec of parseExportSpecifiers(clause[2])) {
+            recordJsExport({ kind: "named", exported: spec.exported, imported: spec.imported, targetFile: tgt, typeOnly: !!clause[1] || spec.typeOnly });
+          }
+        }
+      }
       else if (isBareSpec(rawSpec)) addExternalImport({ spec: rawSpec, kind: "reexport", line, typeOnly });
       else if (rawSpec) recordUnresolved(rawSpec, "reexport", line, typeOnly);
     }
 
+    // Local aliases (`export { internal as publicName }`) and default identifiers are part of the
+    // same export table used by the post-pass barrel resolver. Sourced clauses were recorded above.
+    for (const cap of caps(grammar, `(export_statement) @exp`, tree.rootNode)) {
+      const node = cap.node;
+      if (field(node, "source")) continue;
+      const text = node.text.trim();
+      const clause = text.match(/^export\s+(type\s+)?\{([\s\S]*?)\}/);
+      if (clause) for (const spec of parseExportSpecifiers(clause[2])) {
+        recordJsExport({ kind: "local", exported: spec.exported, local: spec.imported, typeOnly: !!clause[1] || spec.typeOnly });
+      }
+      const identifierDefault = text.match(/^export\s+default\s+([A-Za-z_$][\w$]*)\s*;?$/);
+      if (identifierDefault) recordJsExport({ kind: "local", exported: "default", local: identifierDefault[1], typeOnly: false });
+      const typedDeclaration = text.match(/^export\s+(?:declare\s+)?(type|interface|enum)\s+([A-Za-z_$][\w$]*)\b/);
+      if (typedDeclaration) recordJsExport({
+        kind: "local",
+        exported: typedDeclaration[2],
+        local: typedDeclaration[2],
+        typeOnly: typedDeclaration[1] !== "enum",
+      });
+    }
+
     // ---- export markers beyond declarations: `export { a, b }`, `export default X`, CJS module.exports ----
     for (const cap of caps(grammar, `(export_statement (export_clause (export_specifier name: (identifier) @n)))`, tree.rootNode)) {
       let st = cap.node.parent; while (st && st.type !== "export_statement") st = st.parent;

package/src/graph/community.js

@@ -15,3 +15,13 @@ export function communityTerritoryOf(file) {
   const dirs = normalized.split("/").filter(Boolean).slice(0, -1);
   return dirs.length ? dirs.slice(0, 2).join("/") : "(root)";
 }
+
+// Community ids are serialized into graph.json and therefore must not depend on which subset of
+// files happened to be reparsed. Assign ids from the complete, sorted territory universe so a
+// scoped incremental merge produces the same ids as a full build.
+export function assignDeterministicCommunities(nodes = []) {
+  const territories = [...new Set(nodes.map((node) => communityTerritoryOf(node?.source_file)))].sort();
+  const ids = new Map(territories.map((territory, index) => [territory, index]));
+  for (const node of nodes) node.community = ids.get(communityTerritoryOf(node?.source_file));
+  return nodes;
+}

package/src/graph/file-lock.js

@@ -0,0 +1,69 @@
+// Small cross-process lock + atomic file replacement helpers for derived graph state. Multiple MCP
+// clients commonly run at once (Claude, Codex, desktop); a plain read -> write sequence can lose a
+// registry record or expose a half-written multi-megabyte graph to another reader.
+import {mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync} from 'node:fs'
+import {dirname} from 'node:path'
+import process from 'node:process'
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+const waitSync = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
+
+function clearStaleLock(lockDir, staleMs) {
+    try {
+        if (Date.now() - statSync(lockDir).mtimeMs <= staleMs) return false
+        try {
+            const ownerPid = Number(readFileSync(`${lockDir}/owner`, 'utf8').split(/\s+/)[0])
+            if (Number.isInteger(ownerPid) && ownerPid > 0) {
+                try { process.kill(ownerPid, 0); return false }
+                catch (error) { if (error?.code === 'EPERM') return false }
+            }
+        } catch { /* missing owner: stale age remains the authority */ }
+        rmSync(lockDir, {recursive: true, force: true})
+        return true
+    } catch { return false }
+}
+
+function acquired(lockDir) {
+    mkdirSync(dirname(lockDir), {recursive: true})
+    try {
+        mkdirSync(lockDir)
+        writeFileSync(`${lockDir}/owner`, `${process.pid}\n${new Date().toISOString()}\n`, 'utf8')
+        return true
+    } catch (error) {
+        if (error?.code === 'EEXIST') return false
+        throw error
+    }
+}
+
+export async function withFileLock(lockDir, fn, {timeoutMs = 10_000, staleMs = 60_000, pollMs = 25} = {}) {
+    const started = Date.now()
+    while (!acquired(lockDir)) {
+        clearStaleLock(lockDir, staleMs)
+        if (Date.now() - started >= timeoutMs) throw new Error(`timed out waiting for derived-state lock: ${lockDir}`)
+        await wait(pollMs)
+    }
+    try { return await fn() }
+    finally { rmSync(lockDir, {recursive: true, force: true}) }
+}
+
+export function withFileLockSync(lockDir, fn, {timeoutMs = 10_000, staleMs = 60_000, pollMs = 20} = {}) {
+    const started = Date.now()
+    while (!acquired(lockDir)) {
+        clearStaleLock(lockDir, staleMs)
+        if (Date.now() - started >= timeoutMs) throw new Error(`timed out waiting for derived-state lock: ${lockDir}`)
+        waitSync(pollMs)
+    }
+    try { return fn() }
+    finally { rmSync(lockDir, {recursive: true, force: true}) }
+}
+
+export function atomicWriteFileSync(path, data, encoding = undefined) {
+    mkdirSync(dirname(path), {recursive: true})
+    const temp = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+    try {
+        writeFileSync(temp, data, encoding)
+        renameSync(temp, path)
+    } finally {
+        try { rmSync(temp, {force: true}) } catch { /* already renamed */ }
+    }
+}

package/src/graph/freshness-probe.js

@@ -0,0 +1,141 @@
+// Fast repository freshness probe. Full graph snapshots hash every source file and are still the
+// authority when something changed; this exact Git/worktree token is safe to cache in-process and in
+// versioned graph metadata when HEAD + dirty/untracked/control-file content remain unchanged.
+import {createHash} from 'node:crypto'
+import {spawnSync} from 'node:child_process'
+import {readFileSync, statSync} from 'node:fs'
+import {createRequire} from 'node:module'
+import {childProcessEnv} from '../child-env.js'
+import {createRepoBoundary} from '../repo-path.js'
+
+export const REPOSITORY_FRESHNESS_PROBE_V = 1
+export const GRAPH_BUILDER_SCHEMA_V = 1
+export const GRAPH_BUILDER_VERSION = (() => {
+    try { return String(createRequire(import.meta.url)('../../package.json').version) }
+    catch { return '0.0.0' }
+})()
+
+// These are the graph capabilities whose meaning is owned by the current builder. The package
+// version invalidates stamps across releases; the explicit schema requirements also fail closed when
+// a saved graph is hand-edited or a development build bumps a structural schema without a version bump.
+const CURRENT_GRAPH_SCHEMA = Object.freeze({
+    extImportsV: 2,
+    edgeTypesV: 2,
+    complexityV: 1,
+    repoBoundaryV: 1,
+    barrelResolutionV: 1,
+    extractorSchemaV: 1,
+})
+const CONTROL_FILES = ['.gitignore', '.weavatrixignore', '.weavatrix.json']
+const MAX_CONTROL_BYTES = 1_000_000
+
+function git(repoRoot, args) {
+    const result = spawnSync('git', ['-C', repoRoot, ...args], {
+        encoding: 'buffer', timeout: 8000, windowsHide: true, env: childProcessEnv(), maxBuffer: 16 * 1024 * 1024,
+    })
+    return result.status === 0 ? Buffer.from(result.stdout || '') : null
+}
+
+function statusPaths(status) {
+    const records = status.toString('utf8').split('\0').filter(Boolean)
+    const paths = []
+    for (let index = 0; index < records.length; index++) {
+        const record = records[index]
+        if (record.length < 4) continue
+        paths.push(record.slice(3))
+        // In porcelain -z, rename/copy destinations are followed by the original path as a bare item.
+        if (/^[RC]/.test(record) || /^[RC]/.test(record.slice(1, 2))) {
+            if (records[index + 1]) paths.push(records[++index])
+        }
+    }
+    return [...new Set(paths)]
+}
+
+export function repositoryFreshnessProbe(repoRoot) {
+    const head = git(repoRoot, ['rev-parse', '--verify', 'HEAD'])
+    const status = git(repoRoot, ['status', '--porcelain=v1', '-z', '--untracked-files=all', '--ignored=no'])
+    if (!head || !status) return null
+    const digest = createHash('sha256').update(head).update(status)
+    const boundary = createRepoBoundary(repoRoot)
+    for (const rel of statusPaths(status).sort()) {
+        digest.update(rel)
+        const resolved = boundary.resolve(rel)
+        if (!resolved.ok) { digest.update(`!${resolved.reason}`); continue }
+        try {
+            const stats = statSync(resolved.path)
+            if (!stats.isFile()) { digest.update('!not-file'); continue }
+            // Dirty sets are normally tiny. Hashing their content makes same-size rapid edits exact while
+            // still avoiding reads of every clean file in the repository.
+            digest.update(readFileSync(resolved.path))
+        } catch { digest.update('!unreadable') }
+    }
+    // Control files can intentionally be gitignored. Always include their bounded contents so a
+    // matching Git status can never hide a changed graph universe/classification policy.
+    for (const rel of CONTROL_FILES) {
+        digest.update(`control:${rel}\0`)
+        const resolved = boundary.resolve(rel)
+        if (!resolved.ok) { digest.update(`!${resolved.reason}`); continue }
+        try {
+            const stats = statSync(resolved.path)
+            if (!stats.isFile()) { digest.update('!not-file'); continue }
+            if (stats.size > MAX_CONTROL_BYTES) { digest.update('!oversized'); continue }
+            digest.update(readFileSync(resolved.path))
+        } catch { digest.update('!unreadable') }
+    }
+    return digest.digest('hex')
+}
+
+const isHash = (value) => /^[a-f0-9]{64}$/.test(String(value || ''))
+
+export function graphSchemaIsCurrent(graph) {
+    return Boolean(graph) && Object.entries(CURRENT_GRAPH_SCHEMA)
+        .every(([key, expected]) => Number(graph[key]) === expected)
+}
+
+// Returns true only when a graph stamp was produced by this exact builder contract for the active
+// complete build mode. Legacy, scoped, non-Git, malformed and schema-old graphs all fall through to
+// the authoritative repository snapshot path.
+export function persistedFreshnessMatches(graph, probe, mode = graph?.graphBuildMode || 'full') {
+    if (!graph || !isHash(probe) || !graphSchemaIsCurrent(graph)) return false
+    if (Number(graph.repositoryFreshnessProbeV) !== REPOSITORY_FRESHNESS_PROBE_V) return false
+    if (Number(graph.repositoryFreshnessBuilderSchemaV) !== GRAPH_BUILDER_SCHEMA_V) return false
+    if (String(graph.repositoryFreshnessBuilderVersion || '') !== GRAPH_BUILDER_VERSION) return false
+    if (String(graph.repositoryFreshnessProbe || '') !== probe) return false
+    if (String(graph.repositoryFreshnessMode || '') !== String(mode || 'full')) return false
+    if (String(graph.graphBuildMode || '') !== String(mode || 'full')) return false
+    if (String(graph.graphBuildScope || '') !== '') return false
+    return true
+}
+
+// Mutates the graph metadata and reports whether serialization is required. A null probe deliberately
+// removes an older stamp: non-Git repos and repositories that changed while parsing must never inherit
+// a stale fast-path token.
+export function stampRepositoryFreshness(graph, probe, mode = graph?.graphBuildMode || 'full') {
+    if (!graph || typeof graph !== 'object') return false
+    const next = isHash(probe) && graphSchemaIsCurrent(graph) && !graph.graphBuildScope
+        ? {
+            repositoryFreshnessProbeV: REPOSITORY_FRESHNESS_PROBE_V,
+            repositoryFreshnessBuilderSchemaV: GRAPH_BUILDER_SCHEMA_V,
+            repositoryFreshnessBuilderVersion: GRAPH_BUILDER_VERSION,
+            repositoryFreshnessProbe: probe,
+            repositoryFreshnessMode: String(mode || 'full'),
+        }
+        : null
+    const keys = [
+        'repositoryFreshnessProbeV',
+        'repositoryFreshnessBuilderSchemaV',
+        'repositoryFreshnessBuilderVersion',
+        'repositoryFreshnessProbe',
+        'repositoryFreshnessMode',
+    ]
+    let changed = false
+    for (const key of keys) {
+        if (next && Object.hasOwn(next, key)) {
+            if (graph[key] !== next[key]) { graph[key] = next[key]; changed = true }
+        } else if (Object.hasOwn(graph, key)) {
+            delete graph[key]
+            changed = true
+        }
+    }
+    return changed
+}

package/src/graph/graph-filter.js

@@ -1,44 +1,61 @@
-// Pure graph filters applied to a built graph.json (no I/O). graph-builder itself has no test/scope
-// filter, so we post-process the graph object: drop test nodes, keep only a subpath, etc.
+// Graph filters applied to a built graph.json. Test semantics come from the shared repository path
+// classifier, so no-tests agrees with duplicate/audit/coverage tools (including repo config).
+import { createPathClassifier, hasPathClass } from "../path-classification.js";
 
 export function isTestPath(path) {
-  return /(^|[\\/])(__tests?__|tests?)([\\/]|$)|\.(test|itest|spec|e2e)\.|_test\.go$|(^|[\\/])test_[^\\/]*\.py$/i.test(String(path || ""));
+  return hasPathClass(createPathClassifier(null).explain(path), "test", "e2e");
+}
+
+const normalizedPath = (value) => String(value || "").replace(/\\/g, "/");
+
+function externalImportsForNodes(graph, nodes) {
+  if (!Array.isArray(graph.externalImports)) return undefined;
+  const files = new Set(nodes.map((node) => normalizedPath(node.source_file)).filter(Boolean));
+  return graph.externalImports.filter((item) => files.has(normalizedPath(item?.file)));
 }
 
 // Filter a built graph.json by test-mode: drop test nodes ("no-tests") or keep only tests + the
 // nodes they depend on ("tests-only"). graph-builder update has no test filter, so we do it post-build.
-export function filterGraphForMode(graph, mode) {
+export function filterGraphForMode(graph, mode, { repoRoot = null } = {}) {
   if (mode !== "no-tests" && mode !== "tests-only") return graph;
   const nodes = graph.nodes || [];
   const links = graph.links || [];
   const endpoint = (value) => (value && typeof value === "object" ? value.id : value);
+  const classifier = createPathClassifier(repoRoot);
+  const isTest = (path) => hasPathClass(classifier.explain(path), "test", "e2e");
   let keep;
   if (mode === "no-tests") {
-    keep = new Set(nodes.filter((node) => !isTestPath(node.source_file)).map((node) => node.id));
+    keep = new Set(nodes.filter((node) => !isTest(node.source_file)).map((node) => node.id));
   } else {
-    const testIds = new Set(nodes.filter((node) => isTestPath(node.source_file)).map((node) => node.id));
+    const testIds = new Set(nodes.filter((node) => isTest(node.source_file)).map((node) => node.id));
     keep = new Set(testIds);
     for (const link of links) {
       if (testIds.has(endpoint(link.source))) keep.add(endpoint(link.target)); // a test's dependency
     }
   }
+  const keptNodes = nodes.filter((node) => keep.has(node.id));
+  const externalImports = externalImportsForNodes(graph, keptNodes);
   return {
     ...graph,
-    nodes: nodes.filter((node) => keep.has(node.id)),
-    links: links.filter((link) => keep.has(endpoint(link.source)) && keep.has(endpoint(link.target)))
+    nodes: keptNodes,
+    links: links.filter((link) => keep.has(endpoint(link.source)) && keep.has(endpoint(link.target))),
+    ...(externalImports ? { externalImports } : {})
   };
 }
 
 // Keep only nodes under a subpath (path-scope), drop links touching removed nodes.
 export function filterGraphByScope(graph, scope) {
   if (!scope) return graph;
-  const norm = (p) => String(p || "").replace(/\\/g, "/");
+  const norm = normalizedPath;
   const prefix = norm(scope).replace(/\/+$/, "") + "/";
   const endpoint = (value) => (value && typeof value === "object" ? value.id : value);
   const keep = new Set((graph.nodes || []).filter((node) => (norm(node.source_file) + "/").startsWith(prefix)).map((node) => node.id));
+  const keptNodes = (graph.nodes || []).filter((node) => keep.has(node.id));
+  const externalImports = externalImportsForNodes(graph, keptNodes);
   return {
     ...graph,
-    nodes: (graph.nodes || []).filter((node) => keep.has(node.id)),
-    links: (graph.links || []).filter((link) => keep.has(endpoint(link.source)) && keep.has(endpoint(link.target)))
+    nodes: keptNodes,
+    links: (graph.links || []).filter((link) => keep.has(endpoint(link.source)) && keep.has(endpoint(link.target))),
+    ...(externalImports ? { externalImports } : {})
   };
 }