weavatrix 0.1.3 → 0.1.4

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-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,17 @@
+// 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)";
+}

package/src/graph/internal-builder.build.js

@@ -8,6 +8,8 @@ import { specToPkg } from "./builder/spec-pkg.js";
 import { analyzeSyntaxComplexity } from "../analysis/source-complexity.js";
 import { Parser, Query, GRAMMARS, LANGS, EXT_LANG, FAMILY, isDataFile, isDocFile, MAX_PARSE_BYTES, ensureParser, walk } from "./internal-builder.langs.js";
 import { buildResolvers } from "./internal-builder.resolvers.js";
+import { addJavaReferences } from "./internal-builder.java.js";
+import { communityTerritoryOf } from "./community.js";
 
 // Parse a repo directory into a graph-builder-compatible { nodes, links } graph.
 export async function buildInternalGraph(repoDir, opts = {}) {
@@ -56,7 +58,8 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     const syms = []; const nameToId = new Map(); const moduleNameToId = new Map();
     const addSym = (name, line, callable, extra) => {
       if (!name || !/^[A-Za-z_$][\w$]*$/.test(name)) return;
-      const id = `${fileRel}#${name}@${line}`; if (nodeIds.has(id)) return;
+      const suffix = /^:[A-Za-z0-9_-]+$/.test(extra?.idSuffix || "") ? extra.idSuffix : "";
+      const id = `${fileRel}#${name}@${line}${suffix}`; if (nodeIds.has(id)) return;
       const sourceNode = extra && extra.sourceNode;
       const endLine = sourceNode?.endPosition ? sourceNode.endPosition.row + 1 : 0;
       let complexity = null;
@@ -82,6 +85,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       syms.push({ id, name, start: line, end: endLine >= line ? endLine : 0 });
       if (!nameToId.has(name)) nameToId.set(name, id);
       if (extra?.moduleDeclaration && !moduleNameToId.has(name)) moduleNameToId.set(name, id);
+      return id;
     };
     const imports = new Map(); importedLocals.set(fileRel, imports);
     const addImportEdge = (tgt, meta = {}) => {
@@ -92,6 +96,7 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         relation: meta.relation || "imports",
         confidence: "EXTRACTED",
         ...(typeof meta.typeOnly === "boolean" ? { typeOnly: meta.typeOnly } : {}),
+        ...(meta.compileOnly === true ? { compileOnly: true } : {}),
         ...(meta.line ? { line: meta.line } : {}),
         ...(meta.specifier ? { specifier: meta.specifier } : {}),
       });
@@ -152,6 +157,17 @@ export async function buildInternalGraph(repoDir, opts = {}) {
     if (imp && imp.targetFile) { const tf = symByFileName.get(imp.targetFile); if (tf && tf.has(imp.imported)) return tf.get(imp.imported); }
     return null;
   };
+  const javaTypeKinds = new Set(["class", "interface", "enum", "record", "annotation"]);
+  const resolveJavaType = (name, fileRel) => {
+    const imp = importedLocals.get(fileRel)?.get(name);
+    if (imp?.targetFile) {
+      const symbols = symByFileName.get(imp.targetFile);
+      const target = symbols?.get(imp.imported) || symbols?.get(name);
+      if (target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind)) return target;
+    }
+    const target = symByFileName.get(fileRel)?.get(name);
+    return target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind) ? target : null;
+  };
   for (const abs of files) {
     const fileRel = rel(abs); const grammar = EXT_LANG[extname(abs)]; if (!grammar) continue;
     const lang = LANGS[FAMILY[grammar]]; if (!lang || lang.isWeb || !langs[grammar]) continue;
@@ -175,10 +191,14 @@ export async function buildInternalGraph(repoDir, opts = {}) {
       const target = dm && dm.get(fld.text);
       if (target && target !== caller.id) links.push({ source: caller.id, target, relation: "calls", confidence: "INFERRED" });
     }
-    for (const heritageSrc of lang.heritage || []) for (const cap of caps(grammar, heritageSrc, tree.rootNode)) {
-      const cls = enclosing(fileRel, cap.node.startPosition.row + 1); if (!cls) continue;
-      const target = resolveCall(cap.node.text, fileRel);
-      if (target && target !== cls.id) links.push({ source: cls.id, target, relation: "inherits", confidence: "INFERRED" });
+    for (const heritageSpec of lang.heritage || []) {
+      const query = typeof heritageSpec === "string" ? heritageSpec : heritageSpec.query;
+      const relation = typeof heritageSpec === "string" ? "inherits" : (heritageSpec.relation || "inherits");
+      for (const cap of caps(grammar, query, tree.rootNode)) {
+        const cls = enclosing(fileRel, cap.node.startPosition.row + 1); if (!cls) continue;
+        const target = FAMILY[grammar] === "java" ? resolveJavaType(cap.node.text, fileRel) : resolveCall(cap.node.text, fileRel);
+        if (target && target !== cls.id) links.push({ source: cls.id, target, relation, confidence: "INFERRED" });
+      }
     }
     // JSX is a real symbol use even though it is not a call_expression. Resolve imported components to their
     // declaration so component fan-in and unused-export checks do not claim `<SettingsView />` is unreferenced.
@@ -222,6 +242,9 @@ export async function buildInternalGraph(repoDir, opts = {}) {
         const caller = enclosing(fileRel, sel.startPosition.row + 1); emitRef(caller ? caller.id : fileRel, target);
       }
     }
+    if (FAMILY[grammar] === "java") {
+      addJavaReferences({ grammar, tree, fileRel, caps, resolveJavaType, enclosing, links });
+    }
     tree.delete();
   }
 
@@ -238,13 +261,14 @@ export async function buildInternalGraph(repoDir, opts = {}) {
 
   // community = folder bucket (top 2 path parts) — deterministic, mirrors the folder-based module grouping the
   // app already uses (graph-builder-analysis.js). Populates Modules/community cards without a heavy clustering pass.
-  const folderOf = (f) => { const d = String(f || "").split("/").filter(Boolean).slice(0, -1); return d.length ? d.slice(0, 2).join("/") : "(root)"; };
   const commOf = new Map(); let commSeq = 0;
-  for (const n of nodes) { const fo = folderOf(n.source_file); if (!commOf.has(fo)) commOf.set(fo, commSeq++); n.community = commOf.get(fo); }
+  for (const n of nodes) { const territory = communityTerritoryOf(n.source_file); if (!commOf.has(territory)) commOf.set(territory, commSeq++); n.community = commOf.get(territory); }
 
   // extImportsV: bump when the externalImports schema/coverage changes (v2 = go/python ecosystems) —
   // deps-engine rebuilds in memory when a saved graph is older than this.
-  return { nodes, links, externalImports, extImportsV: 2, edgeTypesV: 1, complexityV: 1, repoBoundaryV: 1 };
+  // edgeTypesV 2 adds language-neutral compile-only edges (currently Rust mod/use/re-export) on top
+  // of v1's TypeScript typeOnly classification.
+  return { nodes, links, externalImports, extImportsV: 2, edgeTypesV: 2, complexityV: 1, repoBoundaryV: 1 };
 }
 
 // Build + write graph.json to outPath (creating the dir). Returns { ok, nodes, links, graphJson }.

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

@@ -0,0 +1,33 @@
+// Resolve Java type usages only when they land on declarations that exist in the graph. Synthetic nodes for
+// String/List/annotations inflate metrics without adding navigation value, so unresolved/external types vanish.
+export function addJavaReferences({ grammar, tree, fileRel, caps, resolveJavaType, enclosing, links }) {
+  const refSeen = new Set();
+  const isHeritage = (node) => {
+    let current = node?.parent;
+    for (let hops = 0; current && hops < 8; hops++, current = current.parent) {
+      if (["superclass", "super_interfaces", "extends_interfaces"].includes(current.type)) return true;
+      if (["class_declaration", "interface_declaration", "enum_declaration", "record_declaration"].includes(current.type)) return false;
+    }
+    return false;
+  };
+  const emitTypeRef = (name, node) => {
+    if (!name || isHeritage(node)) return;
+    const target = resolveJavaType(name, fileRel);
+    if (!target) return;
+    const owner = enclosing(fileRel, node.startPosition.row + 1);
+    const source = owner?.id || fileRel;
+    if (source === target) return;
+    const key = `${source}>${target}`;
+    if (refSeen.has(key)) return;
+    refSeen.add(key);
+    links.push({ source, target, relation: "references", confidence: "INFERRED", usage: "type", line: node.startPosition.row + 1 });
+  };
+  for (const cap of caps(grammar, `(type_identifier) @type`, tree.rootNode)) {
+    // A qualified type is handled once by its outer scoped_type_identifier. Inner package segments could
+    // otherwise bind to unrelated same-named project types.
+    if (cap.node.parent?.type !== "scoped_type_identifier") emitTypeRef(cap.node.text, cap.node);
+  }
+  for (const cap of caps(grammar, `(scoped_type_identifier) @type`, tree.rootNode)) {
+    if (cap.node.parent?.type !== "scoped_type_identifier") emitTypeRef(cap.node.text.split(".").pop(), cap.node);
+  }
+}

package/src/graph/internal-builder.resolvers.js

@@ -1,5 +1,6 @@
 // Per-repo resolution context shared by the language modules: JS/TS path-aliases + relative imports, Python
-// dotted/relative modules, Go package dirs, Java class files, and web hrefs / the CSS selector index.
+// dotted/relative modules, Go package dirs, Rust crate/module paths, Java class files, and web hrefs /
+// the CSS selector index.
 // (Split from internal-builder.js — see its doc comment for the overall architecture.)
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -47,6 +48,112 @@ export function buildResolvers(repoDir, fileSet) {
     return cands.find((f) => f === full || f.endsWith("/" + full)) || cands[0] || null;
   };
 
+  // Rust modules are files, but their paths are logical rather than simple source-relative imports:
+  // `foo.rs` owns children below `foo/`, while lib.rs/main.rs/mod.rs own siblings. Keep the resolver
+  // filesystem-only and crate-local: Cargo/external dependencies belong to dependency analysis, not to
+  // the internal module graph.
+  const cleanRustRel = (p) => String(p || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/$/, "").replace(/^\.$/, "");
+  const rustDir = (p) => { p = cleanRustRel(p); const i = p.lastIndexOf("/"); return i < 0 ? "" : p.slice(0, i); };
+  const rustBase = (p) => { p = cleanRustRel(p); const i = p.lastIndexOf("/"); return i < 0 ? p : p.slice(i + 1); };
+  const rustJoin = (...parts) => cleanRustRel(join(...parts.filter((x) => x != null && x !== "")));
+  const rustFiles = new Set([...fileSet].filter((fr) => fr.endsWith(".rs")));
+  const rustRoots = new Map();
+  for (const fr of rustFiles) {
+    const base = rustBase(fr);
+    if (base !== "lib.rs" && base !== "main.rs") continue;
+    const dir = rustDir(fr);
+    let root = rustRoots.get(dir);
+    if (!root) rustRoots.set(dir, (root = { base: dir, lib: null, main: null }));
+    root[base === "lib.rs" ? "lib" : "main"] = fr;
+  }
+  const rustRootList = [...rustRoots.values()].sort((a, b) => b.base.length - a.base.length);
+  const rustContext = (fromRel) => {
+    fromRel = cleanRustRel(fromRel);
+    const base = rustBase(fromRel);
+    const dir = rustDir(fromRel);
+    if (base === "lib.rs" || base === "main.rs") return { base: dir, rootFile: fromRel };
+
+    // Cargo treats direct files in these conventional folders as independent crate roots. This only
+    // affects paths originating in the root file itself; nested module ownership still comes from mod/use.
+    if (/^(?:bin|examples|tests|benches)$/.test(rustBase(dir))) return { base: dir, rootFile: fromRel };
+    for (const root of rustRootList) {
+      if (!root.base || fromRel.startsWith(root.base + "/")) return { base: root.base, rootFile: root.lib || root.main };
+    }
+    return { base: dir, rootFile: fromRel };
+  };
+  const rustModuleBase = (fromRel) => {
+    const ctx = rustContext(fromRel);
+    if (ctx.rootFile === cleanRustRel(fromRel)) return rustDir(fromRel);
+    const name = rustBase(fromRel);
+    if (name === "lib.rs" || name === "main.rs" || name === "mod.rs") return rustDir(fromRel);
+    return rustJoin(rustDir(fromRel), name.replace(/\.rs$/, ""));
+  };
+  const rustInlineBase = (fromRel, inlineModules = []) => {
+    let base = rustModuleBase(fromRel);
+    for (let i = 0; i < inlineModules.length; i++) {
+      const mod = inlineModules[i] || {};
+      if (mod.path) {
+        // Rust Reference: a path attribute on the first inline module is relative to the source file's
+        // directory; nested attributes are relative to their containing module's search directory.
+        const parent = i === 0 ? rustDir(fromRel) : base;
+        base = rustJoin(parent, mod.path);
+      } else base = rustJoin(base, mod.name);
+    }
+    return base;
+  };
+  const rustModuleFile = (moduleBase, ctx) => {
+    moduleBase = cleanRustRel(moduleBase);
+    if (moduleBase === cleanRustRel(ctx.base) && ctx.rootFile && rustFiles.has(ctx.rootFile)) return ctx.rootFile;
+    const flat = moduleBase + ".rs";
+    if (rustFiles.has(flat)) return flat;
+    const legacy = rustJoin(moduleBase, "mod.rs");
+    return rustFiles.has(legacy) ? legacy : null;
+  };
+  const resolveRustMod = (fromRel, name, { inlineModules = [], explicitPath = "" } = {}) => {
+    fromRel = cleanRustRel(fromRel);
+    if (explicitPath) {
+      const parent = inlineModules.length ? rustInlineBase(fromRel, inlineModules) : rustDir(fromRel);
+      const target = rustJoin(parent, explicitPath);
+      return rustFiles.has(target) ? target : null;
+    }
+    const targetBase = rustJoin(rustInlineBase(fromRel, inlineModules), String(name || "").replace(/^r#/, ""));
+    return rustModuleFile(targetBase, rustContext(fromRel));
+  };
+  const resolveRustPath = (fromRel, rawSegments, { inlineModules = [], unqualified = true } = {}) => {
+    fromRel = cleanRustRel(fromRel);
+    const segments = (Array.isArray(rawSegments) ? rawSegments : String(rawSegments || "").split("::"))
+      .map((s) => String(s).trim().replace(/^r#/, "")).filter(Boolean);
+    if (!segments.length) return null;
+    const ctx = rustContext(fromRel);
+    const current = rustInlineBase(fromRel, inlineModules);
+    let rest = [...segments];
+    const starts = [];
+    let anchored = false;
+    if (rest[0] === "crate") { anchored = true; rest.shift(); starts.push(ctx.base); }
+    else if (rest[0] === "self") { anchored = true; rest.shift(); starts.push(current); }
+    else if (rest[0] === "super") {
+      anchored = true;
+      let base = current;
+      while (rest[0] === "super") { rest.shift(); base = rustDir(base); }
+      if (ctx.base && base !== ctx.base && !base.startsWith(ctx.base + "/")) return null;
+      starts.push(base);
+    } else if (unqualified) {
+      // Rust 2018 resolves a bare use path from the crate root/external prelude. Prefer an internal root
+      // module, then allow a lexically-local module for qualified expressions in nested modules.
+      starts.push(ctx.base);
+      if (current !== ctx.base) starts.push(current);
+    } else return null;
+
+    for (const start of starts) {
+      const min = anchored ? 0 : 1; // never reinterpret an unresolved external `serde::X` as the crate root
+      for (let used = rest.length; used >= min; used--) {
+        const target = rustModuleFile(rustJoin(start, ...rest.slice(0, used)), ctx);
+        if (target) return { targetFile: target, consumed: segments.length - rest.length + used, remaining: rest.slice(used), anchored };
+      }
+    }
+    return null;
+  };
+
   // Path aliases (tsconfig compilerOptions.paths + vite/webpack alias) are scoped to their config folder.
   // Without nearest-config resolution, a monorepo's root `@/*` can hijack the same alias in web/.
   const aliasContexts = new Map();
@@ -188,5 +295,5 @@ export function buildResolvers(repoDir, fileSet) {
     return fileSet.has(cand) ? cand : null;
   };
 
-  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveJavaImport, resolveHref, selectorIndex, htmlUsages, goModule, goRequires };
+  return { resolveJsImport, resolveAlias, resolvePyPath, pyBaseDir, pyTopDirs, resolveGoImport, dirFiles, resolveRustMod, resolveRustPath, resolveJavaImport, resolveHref, selectorIndex, htmlUsages, goModule, goRequires };
 }

package/src/graph/relations.js

@@ -0,0 +1,4 @@
+// Ownership/nesting edges are useful for navigation, but are not evidence of code usage.
+const STRUCTURAL_RELATIONS = new Set(["contains", "method"]);
+
+export const isStructuralRelation = (relation) => STRUCTURAL_RELATIONS.has(String(relation || ""));