weavatrix 0.1.3 → 0.2.0

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

@@ -1,29 +1,192 @@
-// Java extractor. Symbols: class/interface/enum + method/constructor + fields.
-// Imports: `import a.b.C;` → the C.java file (package path = dir; suffix-matched). Calls: `x.method()` /
-// `method()` (name only). Heritage: `extends` + `implements`.
-const SYMS = `
+// Java extractor. Keeps file-level imports/calls while modelling the Java ownership and type system:
+// classes/interfaces/enums/records own their methods, heritage distinguishes extends from implements,
+// and project-local type references resolve to the declaration node (never to synthetic type-name nodes).
+const TYPE_CORE = `
   (class_declaration name: (identifier) @class)
-  (interface_declaration name: (identifier) @class)
-  (enum_declaration name: (identifier) @class)
+  (interface_declaration name: (identifier) @interface)
+  (enum_declaration name: (identifier) @enum)`;
+// Keep grammar-version-dependent declarations separate: one unknown node type invalidates a whole query.
+const TYPE_OPTIONAL = [
+  `(record_declaration name: (identifier) @record)`,
+  `(annotation_type_declaration name: (identifier) @annotation)`,
+];
+const MEMBERS = `
   (method_declaration name: (identifier) @method)
-  (constructor_declaration name: (identifier) @method)
+  (constructor_declaration name: (identifier) @constructor)
   (field_declaration declarator: (variable_declarator name: (identifier) @field))`;
 
+const TYPE_DECLARATIONS = new Set([
+  "class_declaration", "interface_declaration", "enum_declaration",
+  "record_declaration", "annotation_type_declaration",
+]);
+const FIELD_DECLARATIONS = new Set(["field_declaration"]);
+
+const ancestor = (node, accepted) => {
+  let current = node?.parent;
+  for (let hops = 0; current && hops < 12; hops++, current = current.parent) {
+    if (accepted.has(current.type)) return current;
+  }
+  return null;
+};
+
+const visibilityOf = (declaration, owner) => {
+  const modifiers = declaration?.namedChildren?.find((node) => node.type === "modifiers")?.text || "";
+  if (/\bprivate\b/.test(modifiers)) return "private";
+  if (/\bprotected\b/.test(modifiers)) return "protected";
+  if (/\bpublic\b/.test(modifiers)) return "public";
+  if (["interface_declaration", "annotation_type_declaration"].includes(owner?.type)) return "public";
+  return "package";
+};
+
+const lineOf = (node) => node.startPosition.row + 1;
+const symbolBaseId = (fileRel, nameNode) => `${fileRel}#${nameNode.text}@${lineOf(nameNode)}`;
+const declarationKey = (node) => `${node?.startIndex ?? -1}:${node?.endIndex ?? -1}`;
+const exactJavaTarget = (resolveJavaImport, parts) => {
+  const target = resolveJavaImport(parts);
+  const suffix = parts.join("/") + ".java";
+  return target && (target === suffix || target.endsWith("/" + suffix)) ? target : null;
+};
+
 export default {
   family: "java",
   grammars: ["java"],
   exts: { ".java": "java" },
   isWeb: false,
   calls: `(method_invocation name: (identifier) @callee)`,
-  heritage: [`(superclass (type_identifier) @super)`, `(super_interfaces (type_list (type_identifier) @super))`],
+  // Capturing the base type_identifier (rather than the whole generic/scoped type) gives the shared
+  // resolver the imported/local declaration name. Each query is deliberately non-overlapping.
+  heritage: [
+    { relation: "inherits", query: `(superclass (type_identifier) @super)` },
+    { relation: "inherits", query: `(superclass (generic_type (type_identifier) @super))` },
+    { relation: "inherits", query: `(superclass (scoped_type_identifier name: (type_identifier) @super))` },
+    { relation: "inherits", query: `(superclass (generic_type (scoped_type_identifier name: (type_identifier) @super)))` },
+    { relation: "inherits", query: `(extends_interfaces (type_list (type_identifier) @super))` },
+    { relation: "inherits", query: `(extends_interfaces (type_list (generic_type (type_identifier) @super)))` },
+    { relation: "inherits", query: `(extends_interfaces (type_list (scoped_type_identifier name: (type_identifier) @super)))` },
+    { relation: "inherits", query: `(extends_interfaces (type_list (generic_type (scoped_type_identifier name: (type_identifier) @super))))` },
+    { relation: "implements", query: `(super_interfaces (type_list (type_identifier) @super))` },
+    { relation: "implements", query: `(super_interfaces (type_list (generic_type (type_identifier) @super)))` },
+    { relation: "implements", query: `(super_interfaces (type_list (scoped_type_identifier name: (type_identifier) @super)))` },
+    { relation: "implements", query: `(super_interfaces (type_list (generic_type (scoped_type_identifier name: (type_identifier) @super))))` },
+  ],
 
   pass1(ctx) {
-    const { grammar, tree, caps, addSym, addImportEdge, imports, resolveJavaImport } = ctx;
-    for (const cap of caps(grammar, SYMS, tree.rootNode)) addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "method", { sourceNode: cap.node.parent });
-    for (const cap of caps(grammar, `(import_declaration (scoped_identifier) @imp)`, tree.rootNode)) {
-      const parts = cap.node.text.split("."); const cls = parts[parts.length - 1];
-      const tgt = resolveJavaImport(parts); if (!tgt) continue;
-      addImportEdge(tgt); imports.set(cls, { imported: "*", targetFile: tgt });
+    const {
+      grammar, tree, fileRel, caps, field, addSym, addImportEdge, imports,
+      resolveJavaImport, fileSet, links, nodeIds,
+    } = ctx;
+    const ownerIds = new Map();
+    const addJavaSym = (nameNode, callable, extra) => {
+      const base = symbolBaseId(fileRel, nameNode);
+      // Compact/generated Java can put an owner, constructor and overloads with the same name on one
+      // line. Preserve historical IDs normally; disambiguate only an actual collision by source column.
+      const id = nodeIds.has(base) ? `${base}:c${nameNode.startPosition.column + 1}` : base;
+      addSym(nameNode.text, lineOf(nameNode), callable, {
+        ...extra,
+        ...(id === base ? {} : { idSuffix: id.slice(base.length) }),
+      });
+      return nodeIds.has(id) ? id : null;
+    };
+
+    // Add owners first even though tree-sitter captures are source-ordered. This makes ownership edges
+    // deterministic for nested types and methods declared before/after other nested declarations.
+    for (const src of [TYPE_CORE, ...TYPE_OPTIONAL]) {
+      for (const cap of caps(grammar, src, tree.rootNode)) {
+        const declaration = cap.node.parent;
+        const id = addJavaSym(cap.node, false, {
+          sourceNode: cap.node.parent,
+          symbolKind: cap.name,
+        });
+        if (id) ownerIds.set(declarationKey(declaration), id);
+      }
+    }
+
+    for (const cap of caps(grammar, MEMBERS, tree.rootNode)) {
+      const declaration = cap.name === "field" ? ancestor(cap.node, FIELD_DECLARATIONS) : cap.node.parent;
+      const owner = ancestor(cap.node, TYPE_DECLARATIONS);
+      const ownerNameNode = owner && field(owner, "name");
+      const memberKind = cap.name === "constructor" ? "constructor" : cap.name;
+      const memberId = addJavaSym(cap.node, cap.name !== "field", {
+        sourceNode: declaration,
+        symbolKind: memberKind,
+        ...(ownerNameNode ? { memberOf: ownerNameNode.text } : {}),
+        visibility: visibilityOf(declaration, owner),
+      });
+      if (!ownerNameNode || cap.name === "field") continue;
+      const ownerId = ownerIds.get(declarationKey(owner));
+      if (ownerId && memberId && ownerId !== memberId) {
+        links.push({ source: ownerId, target: memberId, relation: "method", confidence: "EXTRACTED" });
+      }
+    }
+
+    const wildcardPackages = [];
+    const staticWildcardTargets = [];
+    const importStatements = caps(grammar, `(import_declaration) @imp`, tree.rootNode);
+    for (const cap of importStatements) {
+      const match = cap.node.text.match(/^\s*import\s+(static\s+)?([\w.]+?)(\.\*)?\s*;?\s*$/);
+      if (!match) continue;
+      const isStatic = !!match[1];
+      const parts = match[2].split(".").filter(Boolean);
+      const wildcard = !!match[3];
+      const line = lineOf(cap.node);
+      if (!isStatic && wildcard) {
+        wildcardPackages.push(parts);
+        continue;
+      }
+      if (!isStatic) {
+        const target = exactJavaTarget(resolveJavaImport, parts);
+        if (!target) continue;
+        const local = parts[parts.length - 1];
+        addImportEdge(target, { line, specifier: parts.join("."), compileOnly: true });
+        imports.set(local, { imported: local, targetFile: target });
+        continue;
+      }
+
+      // Static imports end in a member name. Walk prefixes until the declaring project class resolves.
+      let target = null; let classParts = null;
+      const max = wildcard ? parts.length : parts.length - 1;
+      for (let take = max; take > 0 && !target; take--) {
+        const candidate = parts.slice(0, take);
+        target = exactJavaTarget(resolveJavaImport, candidate);
+        if (target) classParts = candidate;
+      }
+      if (!target) continue;
+      addImportEdge(target, { line, specifier: `${isStatic ? "static " : ""}${parts.join(".")}${wildcard ? ".*" : ""}`, compileOnly: true });
+      if (wildcard) staticWildcardTargets.push(target);
+      else {
+        const member = parts[classParts.length];
+        if (member) imports.set(member, { imported: member, targetFile: target });
+      }
+    }
+
+    // Seed the shared pass-2 resolver with Java's implicit same-package types and wildcard imports.
+    // Exact-path validation is important: the general basename fallback is useful for explicit imports,
+    // but must not bind an unimported Foo to an unrelated package's Foo.java.
+    const slash = fileRel.lastIndexOf("/");
+    const ownDir = slash < 0 ? "" : fileRel.slice(0, slash);
+    const bindType = (name) => {
+      if (!name || imports.has(name)) return;
+      const samePackage = `${ownDir ? ownDir + "/" : ""}${name}.java`;
+      if (fileSet.has(samePackage)) {
+        imports.set(name, { imported: name, targetFile: samePackage });
+        return;
+      }
+      for (const pkg of wildcardPackages) {
+        const target = exactJavaTarget(resolveJavaImport, [...pkg, name]);
+        if (target) { imports.set(name, { imported: name, targetFile: target }); return; }
+      }
+    };
+    for (const cap of caps(grammar, `(type_identifier) @type`, tree.rootNode)) bindType(cap.node.text);
+    for (const cap of caps(grammar, `(scoped_type_identifier) @type`, tree.rootNode)) {
+      const parts = cap.node.text.split(".").filter(Boolean);
+      const target = exactJavaTarget(resolveJavaImport, parts);
+      const name = parts[parts.length - 1];
+      if (target && name && !imports.has(name)) imports.set(name, { imported: name, targetFile: target });
+    }
+    if (staticWildcardTargets.length === 1) {
+      for (const cap of caps(grammar, `(method_invocation name: (identifier) @callee)`, tree.rootNode)) {
+        if (!imports.has(cap.node.text)) imports.set(cap.node.text, { imported: cap.node.text, targetFile: staticWildcardTargets[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/builder/lang-rust.js

@@ -1,10 +1,8 @@
 // Rust extractor. Symbols: fn (incl. impl methods) + struct/enum/trait/type/mod + const/static
 // (+ macro_rules!/union via optional queries). Calls: `foo()` / `x.foo()` / `path::foo()` (name only).
-// Heritage: `impl Trait for Type` resolves only when the impl block sits inside a tracked symbol
-// (e.g. a mod) — a top-level impl has no enclosing symbol to anchor the edge, so v1 usually skips it.
-// `use` paths map to files only through the crate's module tree, which needs Cargo layout resolution —
-// no import edges in v1; cross-file connectivity comes from the name-based calls pass plus the
-// same-folder scope (mod.rs convention).
+// File dependencies follow Rust's module tree: outlined `mod`, `use` trees, public re-exports, and anchored
+// `crate/self/super` paths resolve to repo-local .rs or */mod.rs files. External crates deliberately stay out
+// of this adapter; Cargo dependency analysis owns them.
 const SYMS_CORE = `
   (function_item name: (identifier) @method)
   (struct_item name: (type_identifier) @class)
@@ -20,6 +18,66 @@ const SYMS_OPTIONAL = [
   `(union_item name: (type_identifier) @class)`,
 ];
 
+const cleanSegment = (part) => String(part || "").trim().replace(/^r#/, "");
+const pathParts = (node) => String(node?.text || "").split("::").map(cleanSegment).filter(Boolean);
+const under = (node, type) => { for (let p = node?.parent; p; p = p.parent) if (p.type === type) return true; return false; };
+
+function pathAttribute(modNode) {
+  for (let prev = modNode?.previousNamedSibling; prev?.type === "attribute_item"; prev = prev.previousNamedSibling) {
+    const hashedRaw = prev.text.match(/\bpath\s*=\s*r(#+)"([^"]+)"\1/);
+    if (hashedRaw) return hashedRaw[2] || "";
+    const plain = prev.text.match(/\bpath\s*=\s*(?:r)?"([^"]+)"/);
+    if (plain) return plain[1] || "";
+  }
+  return "";
+}
+
+function inlineAncestors(node) {
+  const result = [];
+  for (let p = node?.parent; p; p = p.parent) {
+    if (p.type !== "declaration_list" || p.parent?.type !== "mod_item") continue;
+    const mod = p.parent;
+    const name = mod.namedChildren.find((child) => child.type === "identifier")?.text;
+    if (name) result.unshift({ name: cleanSegment(name), path: pathAttribute(mod) });
+  }
+  return result;
+}
+
+// Expand a Rust use tree into its leaf paths while retaining aliases. Examples:
+// `crate::api::{self, Client as C, types::*}` -> api, api::Client, api::types.
+function useLeaves(node, prefix = []) {
+  if (!node) return [];
+  if (node.type === "use_declaration") {
+    const body = node.namedChildren.find((child) => child.type !== "visibility_modifier");
+    return useLeaves(body, prefix);
+  }
+  if (node.type === "use_list") return node.namedChildren.flatMap((child) => useLeaves(child, prefix));
+  if (node.type === "scoped_use_list") {
+    const list = node.namedChildren.find((child) => child.type === "use_list");
+    const head = node.namedChildren.find((child) => child !== list);
+    return useLeaves(list, [...prefix, ...pathParts(head)]);
+  }
+  if (node.type === "use_as_clause") {
+    const named = node.namedChildren;
+    const alias = cleanSegment(named[named.length - 1]?.text);
+    return useLeaves(named[0], prefix).map((leaf) => ({ ...leaf, local: alias }));
+  }
+  if (node.type === "use_wildcard") {
+    return [{ segments: [...prefix, ...pathParts(node.namedChildren[0])], wildcard: true, local: null }];
+  }
+  if (node.type === "self") {
+    const local = [...prefix].reverse().find((part) => !["crate", "self", "super"].includes(part)) || null;
+    return [{ segments: prefix.length ? [...prefix] : ["self"], moduleSelf: true, local }];
+  }
+  if (["identifier", "scoped_identifier", "scoped_type_identifier", "crate", "super"].includes(node.type)) {
+    const own = pathParts(node);
+    const segments = [...prefix, ...own];
+    const local = [...own].reverse().find((part) => !["crate", "self", "super"].includes(part)) || null;
+    return [{ segments, local }];
+  }
+  return [];
+}
+
 export default {
   family: "rust",
   grammars: ["rust"],
@@ -35,11 +93,76 @@ export default {
   ],
 
   pass1(ctx) {
-    const { grammar, tree, caps, addSym } = ctx;
+    const { grammar, tree, fileRel, caps, addSym, addImportEdge, imports, resolveRustMod, resolveRustPath } = ctx;
     for (const src of [SYMS_CORE, ...SYMS_OPTIONAL]) {
       for (const cap of caps(grammar, src, tree.rootNode)) {
         addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "method", { sourceNode: cap.node.parent });
       }
     }
+
+    // File dependency edges are intentionally unique per source/target/relation. A qualified path can be
+    // nested in another qualified path and often repeats an existing `mod`/`use`; counting occurrences would
+    // inflate module coupling without adding structure.
+    const emitted = new Set();
+    const emit = (target, meta = {}) => {
+      if (!target || target === fileRel) return;
+      const relation = meta.relation || "imports";
+      const key = relation + ">" + target;
+      if (emitted.has(key)) return;
+      emitted.add(key);
+      // Rust `mod`/`use`/`pub use` relationships are resolved by the compiler. They describe real
+      // architectural coupling, but they are not runtime module loading and therefore must not create
+      // JavaScript-style initialization cycles or runtime boundary/blast-radius findings.
+      addImportEdge(target, { ...meta, relation, compileOnly: true });
+    };
+
+    // `mod foo;` loads foo.rs or foo/mod.rs. Inline `mod foo { ... }` stays in the current file, but any
+    // outlined modules declared inside it are captured separately with their inline ancestor path.
+    for (const cap of caps(grammar, `(mod_item) @mod`, tree.rootNode)) {
+      const mod = cap.node;
+      if (mod.namedChildren.some((child) => child.type === "declaration_list")) continue;
+      const name = mod.namedChildren.find((child) => child.type === "identifier")?.text;
+      if (!name) continue;
+      const target = resolveRustMod(fileRel, cleanSegment(name), {
+        inlineModules: inlineAncestors(mod),
+        explicitPath: pathAttribute(mod),
+      });
+      emit(target, { line: mod.startPosition.row + 1, specifier: `mod ${name}` });
+    }
+
+    // Imports/re-exports may be nested trees and aliases. Besides the file edge, retain direct item aliases
+    // so the existing pass-2 call resolver can connect `use crate::worker::run; run()` across folders.
+    for (const cap of caps(grammar, `(use_declaration) @use`, tree.rootNode)) {
+      const use = cap.node;
+      const relation = use.namedChildren.some((child) => child.type === "visibility_modifier") ? "re_exports" : "imports";
+      const ancestors = inlineAncestors(use);
+      for (const leaf of useLeaves(use)) {
+        const resolved = resolveRustPath(fileRel, leaf.segments, { inlineModules: ancestors, unqualified: true });
+        if (!resolved) continue;
+        emit(resolved.targetFile, { relation, line: use.startPosition.row + 1, specifier: use.text.replace(/;\s*$/, "") });
+        if (!leaf.wildcard && leaf.local && leaf.local !== "_") {
+          const imported = resolved.remaining.length ? cleanSegment(resolved.remaining.at(-1)) : "*";
+          imports.set(cleanSegment(leaf.local), { imported, targetFile: resolved.targetFile, rustModule: imported === "*" });
+        }
+      }
+    }
+
+    // Fully-qualified paths need no `use` declaration but still prove a dependency. Restrict this pass to
+    // explicit crate/self/super anchors so associated paths such as `Type::method` cannot be mistaken for a
+    // same-named module file. Inner prefixes are skipped; only the maximal path emits an edge.
+    for (const cap of caps(grammar, `[(scoped_identifier) (scoped_type_identifier)] @path`, tree.rootNode)) {
+      const node = cap.node;
+      if (under(node, "use_declaration")) continue;
+      if (["scoped_identifier", "scoped_type_identifier"].includes(node.parent?.type)) continue;
+      const segments = pathParts(node);
+      if (!["crate", "self", "super"].includes(segments[0])) continue;
+      const resolved = resolveRustPath(fileRel, segments, { inlineModules: inlineAncestors(node), unqualified: false });
+      if (!resolved) continue;
+      emit(resolved.targetFile, { line: node.startPosition.row + 1, specifier: node.text });
+      const finalName = cleanSegment(segments.at(-1));
+      if (resolved.remaining.length && finalName && !imports.has(finalName)) {
+        imports.set(finalName, { imported: finalName, targetFile: resolved.targetFile, rustQualified: true });
+      }
+    }
   },
 };

package/src/graph/community.js

@@ -0,0 +1,27 @@
+// Deterministic community territories. Most languages keep the historical top-two-folder bucket. Java
+// Maven/Gradle trees need package depth: otherwise every class under application/src becomes one giant blob.
+export function communityTerritoryOf(file) {
+  const normalized = String(file || "").replace(/\\/g, "/");
+  if (/\.java$/i.test(normalized)) {
+    const marker = /(?:^|\/)src\/(?:main|test)\/java\//.exec(normalized);
+    if (marker) {
+      const end = marker.index + marker[0].length;
+      const prefix = normalized.slice(0, end).replace(/\/$/, "");
+      const packageDirs = normalized.slice(end).split("/").filter(Boolean).slice(0, -1);
+      if (packageDirs.length) return `${prefix}/${packageDirs.slice(0, 5).join("/")}`;
+      return prefix;
+    }
+  }
+  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 */ }
+    }
+}