weavatrix 0.3.14 → 1.1.0

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

@@ -1,299 +0,0 @@
-// 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).
-// 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.
-import { rustScopedCalls } from "./lang-rust-calls.js";
-
-const SYMS_CORE = `
-  (function_item name: (identifier) @function)
-  (struct_item name: (type_identifier) @struct)
-  (enum_item name: (type_identifier) @enum)
-  (trait_item name: (type_identifier) @trait)
-  (type_item name: (type_identifier) @type)
-  (mod_item name: (identifier) @module)
-  (const_item name: (identifier) @constant)
-  (static_item name: (identifier) @static)`;
-// Grammar-version-dependent node types, compiled SEPARATELY (one unknown type voids its whole query).
-const SYMS_OPTIONAL = [
-  `(function_signature_item name: (identifier) @function)`,
-  `(macro_definition name: (identifier) @macro)`,
-  `(union_item name: (type_identifier) @union)`,
-];
-
-const cleanSegment = (part) => String(part || "").trim().replace(/^r#/, "");
-// Rust primitive types are language builtins, never crate dependencies: `f64::from(..)`, `u8::MAX`,
-// `str::len` and friends must not be recorded as external crate imports.
-const RUST_PRIMITIVES = new Set(["bool", "char", "str", "f32", "f64", "i8", "i16", "i32", "i64", "i128", "isize", "u8", "u16", "u32", "u64", "u128", "usize"]);
-const RUST_NON_CRATE_HEADS = ["crate", "self", "super", "std", "core", "alloc"];
-// A path head is an external crate only when it is not an anchor keyword, a std root, a primitive type,
-// or a name already bound into local scope by a `use` (a module alias or imported item).
-const isExternalCrate = (head, localBindings) => Boolean(head) && !RUST_NON_CRATE_HEADS.includes(head) && !RUST_PRIMITIVES.has(head) && !localBindings.has(head) && /^[a-z_][\w]*$/.test(head);
-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; };
-const ancestor = (node, types) => {
-  for (let parent = node?.parent; parent; parent = parent.parent) if (types.has(parent.type)) return parent;
-  return null;
-};
-const memberOwners = new Set(["impl_item", "trait_item"]);
-const publicVisibility = (declaration, owner) => {
-  if (owner?.type === "trait_item") return "public";
-  const source = String(declaration?.text || "").trimStart();
-  if (/^pub\s/.test(source)) return "public";
-  if (/^pub\s*\(/.test(source)) return "protected";
-  return "private";
-};
-const ownerName = (owner, field) => {
-  if (!owner) return "";
-  if (owner.type === "trait_item") return field(owner, "name")?.text || "";
-  const type = field(owner, "type")?.text || "";
-  const withoutGenerics = type.replace(/<[^<>]*>/g, "");
-  return (withoutGenerics.match(/[A-Za-z_]\w*/g) || []).at(-1) || "";
-};
-
-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 "";
-}
-
-// Test-only classification must mean "compiled exclusively under `cargo test`": #[cfg(test)] and
-// #[cfg(all(test, ...))] guarantee that; #[cfg(any(test, ...))] also compiles into production builds
-// and deliberately stays unclassified. #[test]/#[bench] (incl. #[tokio::test]-style harness paths)
-// mark the annotated function itself.
-const CFG_TEST_RE = /#\s*!?\s*\[\s*cfg\s*\(\s*(?:test\s*\)|all\s*\(\s*test\b)/;
-const TEST_FN_ATTR_RE = /#\s*\[\s*(?:[\w]+(?:\s*::\s*[\w]+)*\s*::\s*)?(?:test|bench)\s*(?:\]|\()/;
-const CFG_TEST_CARRIERS = new Set(["mod_item", "impl_item", "trait_item", "function_item"]);
-const COMMENT_TYPES = new Set(["line_comment", "block_comment"]);
-const itemAttributeText = (item) => {
-  // Comments are NAMED siblings in tree-sitter-rust — `#[test]` + `// note` + `fn` must still classify.
-  let text = "";
-  for (let prev = item?.previousNamedSibling; prev; prev = prev.previousNamedSibling) {
-    if (COMMENT_TYPES.has(prev.type)) continue;
-    if (prev.type !== "attribute_item") break;
-    text += prev.text + "\n";
-  }
-  return text;
-};
-// `#![cfg(test)]` at the top of a file or module body gates everything below it. tree-sitter-rust
-// tokenizes a file-leading `#!...` as `shebang`; a real shebang line never matches CFG_TEST_RE.
-const innerCfgTest = (body) => (body?.namedChildren || [])
-  .some((child) => (child.type === "inner_attribute_item" || child.type === "shebang") && CFG_TEST_RE.test(child.text));
-const underCfgTest = (node) => {
-  for (let parent = node?.parent; parent; parent = parent.parent) {
-    if (parent.type === "declaration_list" && innerCfgTest(parent)) return true;
-    if (CFG_TEST_CARRIERS.has(parent.type) && CFG_TEST_RE.test(itemAttributeText(parent))) return true;
-    if (!parent.parent && innerCfgTest(parent)) return true; // source_file root
-  }
-  return false;
-};
-
-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"],
-  exts: { ".rs": "rust" },
-  isWeb: false,
-  // Bare `foo()` and method `x.foo()` calls resolve by name in the generic pass-2 loop. Scoped
-  // `Path::foo()` calls are handled in pass2() below with the full qualifier in hand, so an external
-  // `OpenOptions::new()` cannot bind its bare `new` to an unrelated same-named function in the folder.
-  calls: `
-    (call_expression function: (identifier) @callee)
-    (call_expression function: (field_expression field: (field_identifier) @callee))`,
-  heritage: [
-    `(impl_item trait: (type_identifier) @super)`,
-    `(impl_item trait: (generic_type type: (type_identifier) @super))`,
-  ],
-
-  pass1(ctx) {
-    const { grammar, tree, fileRel, caps, field, addSym, addImportEdge, addExternalImport, imports, resolveRustMod, resolveRustPath, resolveRustCratePath, links, nameToId } = ctx;
-    const owned = [];
-    for (const src of [SYMS_CORE, ...SYMS_OPTIONAL]) {
-      for (const cap of caps(grammar, src, tree.rootNode)) {
-        const declaration = cap.node.parent;
-        const owner = cap.name === "function" ? ancestor(cap.node, memberOwners) : null;
-        const memberOf = ownerName(owner, field);
-        const symbolKind = cap.name === "function" ? (memberOf ? "method" : "function") : cap.name;
-        const visibility = publicVisibility(declaration, owner);
-        const attrs = itemAttributeText(declaration);
-        const testSurface = CFG_TEST_RE.test(attrs)
-          || (cap.name === "function" && TEST_FN_ATTR_RE.test(attrs))
-          || underCfgTest(declaration);
-        const id = addSym(cap.node.text, cap.node.startPosition.row + 1, cap.name === "function", {
-          sourceNode: declaration,
-          selectionNode: cap.node,
-          symbolKind,
-          ...(testSurface ? { testSurface: true } : {}),
-          ...(memberOf ? { memberOf, visibility } : { moduleDeclaration: true }),
-          ...(!memberOf && visibility === "public" ? { exported: true } : {}),
-        });
-        if (id && memberOf) owned.push({owner: memberOf, id});
-      }
-    }
-    for (const member of owned) {
-      const ownerId = nameToId.get(member.owner);
-      if (ownerId && ownerId !== member.id) links.push({source: ownerId, target: member.id, relation: "method", confidence: "EXTRACTED"});
-    }
-
-    // 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();
-    // Names bound into this file's scope by `use` (module aliases and imported items), tracked even when the
-    // used path did not resolve to a repo file, so later `alias::item` paths are not re-read as external crates.
-    const localBindings = 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;
-      const name = mod.namedChildren.find((child) => child.type === "identifier")?.text;
-      if (name) localBindings.add(cleanSegment(name)); // a declared child module shadows any same-named crate
-      if (mod.namedChildren.some((child) => child.type === "declaration_list")) continue;
-      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)) {
-        // A `use` alias or imported item name shadows any same-named crate for the rest of this file. The
-        // crate's OWN root name (e.g. `use anyhow::{self}`) is excluded so it still counts as a dependency.
-        if (leaf.local && leaf.local !== "_" && cleanSegment(leaf.local) !== cleanSegment(leaf.segments[0])) localBindings.add(cleanSegment(leaf.local));
-        const crate = cleanSegment(leaf.segments[0]);
-        let resolved = resolveRustPath(fileRel, leaf.segments, { inlineModules: ancestors, unqualified: true });
-        // A head that is not a local module may be a sibling workspace crate (`use radiochron::wlan`):
-        // resolve it INTO that crate so its items bind here and cross-crate calls resolve in pass 2. It is
-        // still recorded as a dependency import so the sibling crate is not flagged an unused Cargo dep.
-        if (!resolved && resolveRustCratePath && isExternalCrate(crate, localBindings)) {
-          resolved = resolveRustCratePath(crate, leaf.segments.slice(1));
-          if (resolved) addExternalImport({ spec: leaf.segments.join("::"), pkg: crate.replace(/_/g, "-"), builtin: false, ecosystem: "crates.io", kind: "rust-use", line: use.startPosition.row + 1 });
-        }
-        if (!resolved) {
-          if (isExternalCrate(crate, localBindings)) {
-            addExternalImport({ spec: leaf.segments.join("::"), pkg: crate.replace(/_/g, "-"), builtin: false, ecosystem: "crates.io", kind: "rust-use", line: use.startPosition.row + 1 });
-          }
-          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])) {
-        const crate = cleanSegment(segments[0]);
-        // A fully-qualified sibling-crate path (`radiochron::events::recent`) is a real cross-crate
-        // dependency: emit the file edge AND record the dependency import so the sibling crate still
-        // counts as used, rather than being logged as an external crates.io crate.
-        const crateResolved = resolveRustCratePath && isExternalCrate(crate, localBindings)
-          ? resolveRustCratePath(crate, segments.slice(1))
-          : null;
-        if (crateResolved) {
-          emit(crateResolved.targetFile, { line: node.startPosition.row + 1, specifier: node.text });
-          addExternalImport({ spec: segments.join("::"), pkg: crate.replace(/_/g, "-"), builtin: false, ecosystem: "crates.io", kind: "rust-path", line: node.startPosition.row + 1 });
-        } else if (isExternalCrate(crate, localBindings)) {
-          addExternalImport({ spec: segments.join("::"), pkg: crate.replace(/_/g, "-"), builtin: false, ecosystem: "crates.io", kind: "rust-path", line: node.startPosition.row + 1 });
-        }
-        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 });
-      }
-    }
-
-    for (const cap of caps(grammar, `(extern_crate_declaration name: (identifier) @crate)`, tree.rootNode)) {
-      const crate = cleanSegment(cap.node.text);
-      if (crate && !["std", "core", "alloc"].includes(crate)) {
-        addExternalImport({ spec: crate, pkg: crate.replace(/_/g, "-"), builtin: false, ecosystem: "crates.io", kind: "rust-extern-crate", line: cap.node.startPosition.row + 1 });
-      }
-    }
-  },
-
-  // Scoped `Path::method()` calls are resolved in lang-rust-calls.js with the full qualifier in hand.
-  pass2(ctx) {
-    rustScopedCalls(ctx, { pathParts, inlineAncestors });
-  },
-};

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

@@ -1,126 +0,0 @@
-// Solidity extractor. Symbols: contract/interface/library (space "both" so `is Base` heritage and
-// `new Vault()` both resolve through the value-space resolver), functions/constructors/modifiers/
-// events/errors/structs/enums/state vars (members carry memberOf + visibility). Imports: relative
-// paths, Foundry remappings (remappings.txt / foundry.toml), and root-anchored specs resolve to repo
-// files; everything else (npm-style @openzeppelin/…, absent lib/ submodules) is RECORDED as an
-// external import for dependency analysis. Calls: bare `f()`, modifier invocations, `emit Event(…)`,
-// `new Contract(…)`, and `using Lib for T` all feed the calls resolver. Same-dir symbols share scope
-// (see sharesDirScope): Solidity's flat project namespace makes plain `import "./Base.sol"` — which
-// names no symbols — resolvable for siblings without guessing; cross-dir plain imports still produce
-// the file-level import edge, so blast radius stays correct even where symbol edges are unknowable.
-import { specToPkg } from "./spec-pkg.js";
-
-const CONTAINERS = new Set(["contract_declaration", "interface_declaration", "library_declaration"]);
-const KIND_BY_CONTAINER = {
-  contract_declaration: "contract",
-  interface_declaration: "interface",
-  library_declaration: "library",
-};
-// external/public functions are the deployed ABI — callable by any transaction, not just repo code.
-const VISIBILITY = { external: "public", public: "public", internal: "protected", private: "private" };
-
-function enclosingContainer(node) {
-  for (let parent = node?.parent; parent; parent = parent.parent) {
-    if (CONTAINERS.has(parent.type)) return parent;
-  }
-  return null;
-}
-
-const identifierOf = (node) => node?.namedChildren?.find((child) => child.type === "identifier") || null;
-const childOfType = (node, type) => node?.namedChildren?.find((child) => child.type === type) || null;
-const parameterCount = (node) => (node?.namedChildren || []).filter((child) => child.type === "parameter").length;
-
-export default {
-  family: "solidity",
-  grammars: ["solidity"],
-  exts: { ".sol": "solidity" },
-  isWeb: false,
-  calls: `[(call_expression (identifier) @callee) (modifier_invocation (identifier) @callee) (emit_statement (identifier) @callee) (new_expression (type_name (user_defined_type (identifier) @callee))) (using_directive (type_alias (identifier) @callee))]`,
-  heritage: [`(inheritance_specifier (user_defined_type (identifier) @base))`],
-
-  pass1(ctx) {
-    const { grammar, tree, fileRel, caps, addSym, addImportEdge, addExternalImport, imports, links, nameToId, resolveSolidityImport } = ctx;
-
-    // ---- containers (contract/interface/library) ----
-    for (const cap of caps(grammar, `[(contract_declaration (identifier) @c) (interface_declaration (identifier) @c) (library_declaration (identifier) @c)]`, tree.rootNode)) {
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
-        sourceNode: cap.node.parent,
-        selectionNode: cap.node,
-        symbolKind: KIND_BY_CONTAINER[cap.node.parent.type],
-        symbolSpace: "both",
-        exported: true,
-        moduleDeclaration: true,
-      });
-    }
-
-    // ---- functions (free + members), constructors, modifiers ----
-    const ownedMembers = [];
-    const addMember = (name, node, selection, extra) => {
-      const container = enclosingContainer(node);
-      const ownerName = container ? identifierOf(container)?.text || null : null;
-      const id = addSym(name, (selection || node).startPosition.row + 1, extra.callable !== false, {
-        sourceNode: node,
-        selectionNode: selection || undefined,
-        ...(ownerName ? { memberOf: ownerName } : { exported: true, moduleDeclaration: true }),
-        ...extra,
-      });
-      if (ownerName && id) ownedMembers.push({ ownerName, id });
-      return id;
-    };
-    for (const cap of caps(grammar, `(function_definition (identifier) @fn)`, tree.rootNode)) {
-      const definition = cap.node.parent;
-      const visibility = VISIBILITY[childOfType(definition, "visibility")?.text || ""];
-      addMember(cap.node.text, definition, cap.node, {
-        symbolKind: enclosingContainer(definition) ? "method" : "function",
-        ...(visibility ? { visibility } : {}),
-        parameterCount: parameterCount(definition),
-      });
-    }
-    for (const cap of caps(grammar, `(constructor_definition) @ctor`, tree.rootNode))
-      addMember("constructor", cap.node, null, { symbolKind: "constructor", parameterCount: parameterCount(cap.node) });
-    for (const cap of caps(grammar, `(modifier_definition (identifier) @m)`, tree.rootNode))
-      addMember(cap.node.text, cap.node.parent, cap.node, { symbolKind: "modifier", parameterCount: parameterCount(cap.node.parent) });
-
-    // ---- data/type declarations ----
-    for (const cap of caps(grammar, `[(event_definition (identifier) @n) (error_declaration (identifier) @n)]`, tree.rootNode))
-      addMember(cap.node.text, cap.node.parent, cap.node, { callable: false, symbolKind: cap.node.parent.type === "event_definition" ? "event" : "error" });
-    for (const cap of caps(grammar, `[(struct_declaration (identifier) @n) (enum_declaration (identifier) @n)]`, tree.rootNode))
-      addMember(cap.node.text, cap.node.parent, cap.node, { callable: false, symbolKind: cap.node.parent.type === "struct_declaration" ? "struct" : "enum", symbolSpace: "both" });
-    // capture the DECLARATION and take its first identifier child (the name): an initializer such as
-    // `uint x = OTHER_CONST;` can place a second bare identifier under the same declaration node.
-    for (const cap of caps(grammar, `(constant_variable_declaration) @d`, tree.rootNode)) {
-      const name = identifierOf(cap.node);
-      if (name) addMember(name.text, cap.node, name, { callable: false, symbolKind: "constant" });
-    }
-    for (const cap of caps(grammar, `(state_variable_declaration) @d`, tree.rootNode)) {
-      const name = identifierOf(cap.node);
-      const visibility = VISIBILITY[childOfType(cap.node, "visibility")?.text || ""] || "protected"; // Solidity default: internal
-      if (name) addMember(name.text, cap.node, name, { callable: false, symbolKind: "variable", visibility });
-    }
-    for (const member of ownedMembers) {
-      const ownerId = nameToId.get(member.ownerName);
-      if (ownerId) links.push({ source: ownerId, target: member.id, relation: "contains", confidence: "EXTRACTED" });
-    }
-
-    // ---- imports ----
-    for (const cap of caps(grammar, `(import_directive) @imp`, tree.rootNode)) {
-      const specNode = childOfType(cap.node, "string");
-      if (!specNode) continue;
-      const spec = specNode.text.replace(/^["']|["']$/g, "");
-      const line = specNode.startPosition.row + 1;
-      const target = resolveSolidityImport(fileRel, spec);
-      if (target) {
-        addImportEdge(target, { specifier: spec, line });
-        // `import {A, B} from "./x.sol"` — bind each named symbol. A lone identifier may instead be a
-        // `* as Alias` namespace name; binding it the same way is harmless (no same-named symbol → no edge).
-        for (const named of cap.node.namedChildren.filter((child) => child.type === "identifier"))
-          imports.set(named.text, { imported: named.text, targetFile: target });
-        continue;
-      }
-      if (spec.startsWith(".")) { addExternalImport({ spec, kind: "sol-import", line, unresolved: true }); continue; }
-      const r = specToPkg(spec);
-      if (r) addExternalImport({ spec, pkg: r.pkg, builtin: false, kind: "sol-import", line });
-      else addExternalImport({ spec, kind: "sol-import", line, unresolved: true });
-    }
-  },
-};