dsh-plugin-codegraph-tree-sitter 0.1.1 → 0.1.5

package/lib/extract.js

@@ -7,6 +7,7 @@
  * real workspace are of exactly this shape.
  * @module dsh-plugin-codegraph-tree-sitter/extract
  */
+import { DART_FIELD_NAME_FIELD, DECLARATOR_NAME_FIELD, FIRST_CHILD_NAME_FIELD, KOTLIN_NAME_FIELD, PHP_ELEMENT_NAME_FIELD, SELF_NAME_FIELD, SWIFT_FUNCTION_NAME_FIELD, SWIFT_PROPERTY_NAME_FIELD } from "./languages.js";
 /** A node's named children, with the `null` slots `web-tree-sitter` reserves for missing nodes dropped. */
 function namedChildren(node) {
     return node.namedChildren.filter(child => child !== null);
@@ -36,16 +37,707 @@ function hasKeywordChild(node, keyword) {
     }
     return false;
 }
+/**
+ * Java's `modifiers` node for a declaration, wherever it sits. Unlike every other grammar this
+ * package extracts from, Java never places a modifier keyword (`public`, `static`, `final`, …) as a
+ * direct child of the declaration node itself — it wraps them all in one named `modifiers` child. A
+ * captured `variable_declarator` (the `field`/`variable` rules in `languages.ts`) carries no
+ * `modifiers` of its own at all; its modifiers sit one level up, on the enclosing
+ * `field_declaration`/`local_variable_declaration` this function falls back to. Verified against a
+ * real parse, not guessed.
+ */
+function javaModifiersNode(node) {
+    const own = namedChildren(node).find(child => child.type === 'modifiers');
+    if (own !== undefined)
+        return own;
+    // Every node this is called on is a definition the walk captured below the tree's root, so it
+    // always has a parent; the null case only satisfies `.parent`'s general `SyntaxNode | null` type.
+    /* v8 ignore next */
+    if (node.parent === null)
+        return undefined;
+    return namedChildren(node.parent).find(child => child.type === 'modifiers');
+}
+/** Whether a Java declaration carries `keyword` among its modifiers — see {@link javaModifiersNode}. */
+function javaHasModifier(node, keyword) {
+    const modifiers = javaModifiersNode(node);
+    return modifiers !== undefined && hasKeywordChild(modifiers, keyword);
+}
+/**
+ * Whether a C/C++ declaration carries `keyword` (`static`, `virtual`, …) among its own named children.
+ * Unlike every other grammar this package extracts from, C/C++ wraps a storage-class keyword like
+ * `static` in its own named `storage_class_specifier` node rather than leaving it as a bare anonymous
+ * token on the declaration itself — `hasKeywordChild` alone would never see it. `virtual`, by contrast,
+ * is already its own bare named node with no wrapper, so checking each named child's own text (not just
+ * `storage_class_specifier`'s) covers both in one pass. Verified against a real parse, not guessed.
+ */
+function cHasStorageClassKeyword(node, keyword) {
+    return namedChildren(node).some(child => child.text === keyword);
+}
+/**
+ * Whether a C# declaration carries `keyword` (`public`, `static`, …) among its own named children. C#
+ * wraps each modifier keyword in its own flat, individually-named `modifier` node directly on the
+ * declaration — unlike Java's single wrapping `modifiers` collection (see {@link javaModifiersNode}) or
+ * C/C++'s `storage_class_specifier`, there is no group to look inside; each keyword is its own sibling.
+ * Verified against a real parse, not guessed.
+ */
+function csharpHasModifier(node, keyword) {
+    return namedChildren(node).some(child => child.type === 'modifier' && child.text === keyword);
+}
+/** C/C++ node types wrapping another `declarator` field one level further down — see {@link declaratorName}. */
+const DECLARATOR_WRAPPER_TYPES = new Set([
+    'pointer_declarator',
+    'init_declarator',
+    'array_declarator',
+    'reference_declarator',
+]);
+/**
+ * `parenthesized_declarator`'s inner declarator — unlike every wrapper in {@link DECLARATOR_WRAPPER_TYPES}
+ * plus `function_declarator`, its sole child is purely positional, bound to no field at all
+ * (`int (*fp)(void);`'s `parenthesized_declarator` wraps a `pointer_declarator` with no `declarator`
+ * field to find it through). Verified against a real parse, not guessed.
+ */
+function parenthesizedDeclaratorInner(node) {
+    // The grammar never produces an empty `parenthesized_declarator` (`()` alone does not parse as one);
+    // the fallback only satisfies `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    return namedChildren(node)[0] ?? null;
+}
+/**
+ * The terminal name behind a C/C++ declaration's `declarator` field, however many wrapper layers deep —
+ * `int *make(int a)`'s `function_definition.declarator` is a `pointer_declarator` wrapping a
+ * `function_declarator` wrapping the `identifier` "make"; a plain `int g = 1;` global's `declaration.declarator`
+ * is an `init_declarator` wrapping the `identifier` "g" directly; `int (*fp)(void);`'s is a
+ * `function_declarator` wrapping a `parenthesized_declarator` wrapping a `pointer_declarator` wrapping
+ * the `identifier` "fp". Every wrapper in {@link DECLARATOR_WRAPPER_TYPES}, plus `function_declarator`,
+ * exposes the same `declarator` field down to the next layer; `parenthesized_declarator` alone is
+ * unwrapped through {@link parenthesizedDeclaratorInner} instead — see there. Stops at an
+ * `identifier`/`field_identifier` (the common case), or at a C++ `destructor_name` (`~C`) kept whole
+ * rather than unwrapped to its inner `identifier` — unwrapping would make a destructor's name collide
+ * with its constructor's plain class name. A shape this doesn't recognize (a C++ operator-overload
+ * declarator's `operator_name`, or a function-pointer typedef) returns `undefined` rather than guess a
+ * name from it, the same "don't guess" precedent this file already follows for shapes it does not fully
+ * resolve.
+ * @param node - the declaration node (`function_definition`, `declaration`, `field_declaration`, …).
+ * @returns the terminal name node, or `undefined`.
+ */
+function declaratorName(node) {
+    // `declaration`/`field_declaration` allow a comma-separated multi-declarator list (`int a, b;`) that
+    // shares the same repeated `declarator` field on one node — the same ambiguity Go's `const a, b = 1, 2`
+    // has on one `const_spec`; `childForFieldName` below would otherwise silently return only the first.
+    // `function_definition`'s `declarator` is never repeated, so this is a no-op there.
+    if (soleNamedField(node, 'declarator') === undefined)
+        return undefined;
+    let current = node.childForFieldName('declarator');
+    while (current !== null) {
+        if (current.type === 'identifier' || current.type === 'field_identifier' || current.type === 'destructor_name')
+            return current;
+        if (current.type === 'parenthesized_declarator') {
+            current = parenthesizedDeclaratorInner(current);
+            continue;
+        }
+        if (current.type !== 'function_declarator' && !DECLARATOR_WRAPPER_TYPES.has(current.type))
+            return undefined;
+        current = current.childForFieldName('declarator');
+    }
+    // Every wrapper type reaching this point (`function_declarator` or a `DECLARATOR_WRAPPER_TYPES`
+    // member) is required by the grammar to carry its own nested `declarator`; the loop always returns
+    // from inside before `current` could become null.
+    /* v8 ignore next */
+    return undefined;
+}
+/**
+ * The matched node's first named child, when it is an `identifier` — see {@link FIRST_CHILD_NAME_FIELD}.
+ * Rejects anything else (e.g. a tuple-deconstructing pattern) rather than name a declaration after a
+ * shape this package does not attempt to resolve, the same "don't guess" precedent every other
+ * unresolved shape in this file already follows.
+ */
+function firstChildName(node) {
+    const first = namedChildren(node)[0];
+    return first?.type === 'identifier' ? first : undefined;
+}
+/**
+ * PHP's bare `name` node — either directly (`const_element`'s first named child) or one level deeper
+ * inside a `variable_name` wrapper (`property_element`'s and a closure-binding `assignment_expression`'s
+ * first named child) — see {@link PHP_ELEMENT_NAME_FIELD}. Rejects anything else (a destructuring
+ * `list_literal` target, a member/subscript assignment target) rather than name a declaration after a
+ * shape this package does not attempt to resolve, the same "don't guess" precedent every other
+ * unresolved shape in this file already follows. Verified against a real parse, not guessed.
+ */
+function phpElementName(node) {
+    const first = namedChildren(node)[0];
+    // Every node this is called on (`const_element`, `property_element`, a value-guarded
+    // `assignment_expression`) is required by the grammar to carry at least one named child; the
+    // undefined case only satisfies `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    if (first === undefined)
+        return undefined;
+    if (first.type === 'name')
+        return first;
+    if (first.type !== 'variable_name')
+        return undefined;
+    const inner = namedChildren(first)[0];
+    // The grammar's `variable_name` rule always wraps exactly one bare `name`; the fallback only satisfies
+    // `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    return inner?.type === 'name' ? inner : undefined;
+}
+/**
+ * PHP's own modifier host for `keyword`: a class/method/interface/trait/enum declaration carries its
+ * `visibility_modifier`/`static_modifier` directly, but a captured `const_element`/`property_element`
+ * carries neither — like Java's `variable_declarator` (see {@link javaModifiersNode}), its modifiers sit
+ * one level up, on the enclosing `const_declaration`/`property_declaration` this falls back to.
+ */
+function phpModifierHost(node) {
+    // Every `const_element`/`property_element` the walk visits sits inside a `const_declaration`/
+    // `property_declaration`, never at the tree's root; the `?? node` fallback only satisfies `.parent`'s
+    // general `SyntaxNode | null` type.
+    /* v8 ignore next */
+    if (node.type === 'const_element' || node.type === 'property_element')
+        return node.parent ?? node;
+    return node;
+}
+/** Whether a PHP declaration carries an explicit `public` (or other) `visibility_modifier` — see
+ * {@link phpModifierHost}. Verified against a real parse, not guessed. */
+function phpHasVisibility(node, keyword) {
+    return namedChildren(phpModifierHost(node)).some(child => child.type === 'visibility_modifier' && child.text === keyword);
+}
+/** Whether a PHP declaration carries a `static_modifier` — see {@link phpModifierHost}. Verified against
+ * a real parse, not guessed. */
+function phpHasStaticModifier(node) {
+    return namedChildren(phpModifierHost(node)).some(child => child.type === 'static_modifier');
+}
+/**
+ * Whether a Rust declaration carries a bare `pub` `visibility_modifier` among its own named children.
+ * Every Rust item this package captures places its visibility keyword there directly, unlike Java's
+ * wrapping `modifiers` node or C's `storage_class_specifier` — but `pub(crate)`/`pub(super)`/`pub(self)`
+ * restrict visibility to inside the crate rather than truly exporting it, so only the bare, unrestricted
+ * keyword counts, mirroring Java's/C#'s explicit-`public`-only convention. Verified against a real parse,
+ * not guessed.
+ */
+function rustIsPublic(node) {
+    return namedChildren(node).some(child => child.type === 'visibility_modifier' && child.text === 'pub');
+}
+/**
+ * The lone named child bound to `field`, or `undefined` when zero or more than one is bound. A field
+ * ordinarily binds exactly one child (a declaration's name); Go's `const a, b = 1, 2` is the exception
+ * — both identifiers share the `name` field on one `const_spec` node — and this package extracts a
+ * single declared name per definition, never a silently partial pick from an ambiguous group.
+ */
+function soleNamedField(node, field) {
+    const named = node.childrenForFieldName(field).filter((child) => child !== null && child.isNamed);
+    return named.length === 1 ? named[0] : undefined;
+}
+/**
+ * A Zig `variable_declaration`'s initializer value — its last named child, when one is present. Neither
+ * the declared name nor its value binds to a field of its own (both are purely positional), but an
+ * explicit type annotation (`var counter: i32 = 0;`) does bind to a `type` field — when present, the
+ * value always follows it, so comparing the last named child against that field tells an initializer
+ * apart from a type-only forward declaration with no value at all (`extern var x: i32;`, which this
+ * package never sees paired with a captured name in practice, but which `matchDefinition`'s general
+ * "don't guess" precedent still guards against misreading as its own type). Verified against a real
+ * parse, not guessed.
+ */
+function zigDeclarationValue(node) {
+    const typeNode = node.childForFieldName('type');
+    const last = namedChildren(node).at(-1);
+    // The grammar's `variable_declaration` always wraps at least its own declared name as a named child;
+    // the undefined case only satisfies `Array.prototype.at`'s general return type.
+    /* v8 ignore next */
+    if (last === undefined)
+        return undefined;
+    if (typeNode !== null && last.equals(typeNode))
+        return undefined;
+    return last;
+}
+/**
+ * The seam kind a Zig `variable_declaration` actually reports — `DefinitionRule.kind` is fixed per rule,
+ * with no way to vary by a value's shape, so this is computed here instead of in `LANGUAGE_TABLE`. A
+ * `struct_declaration`/`union_declaration` value reports `struct` (matching this file's existing
+ * union→`struct` precedent for C/C++/Rust); an `enum_declaration` value reports `enum`; anything else
+ * falls back to `constant`/`variable` by whether the declaration's own keyword is `const` or `var`.
+ * Verified against a real parse, not guessed.
+ */
+function zigDeclarationKind(node) {
+    const value = zigDeclarationValue(node);
+    if (value?.type === 'struct_declaration' || value?.type === 'union_declaration')
+        return 'struct';
+    if (value?.type === 'enum_declaration')
+        return 'enum';
+    return hasKeywordChild(node, 'var') ? 'variable' : 'constant';
+}
+/**
+ * A Zig `const name = @import("...")` recognized as an import binding — the only way Zig brings in
+ * another file or the standard library, spelled as an ordinary builtin-function call bound through the
+ * same `variable_declaration` shape `zigDeclarationKind` already classifies as an unremarkable constant
+ * (both are recorded — the same "also captured as an ordinary variable" precedent CommonJS's
+ * `require()`-bound `const` already sets). Neither `builtin_function` nor its own `arguments` wrapper
+ * binds a field of its own; both are purely positional, verified against a real parse, not guessed.
+ * @param node - the `variable_declaration` node.
+ * @param localName - the declaration's own bound name, already resolved by the caller.
+ * @returns the import binding, or `undefined` when `node`'s value is not an `@import(...)` call.
+ */
+function zigImportBinding(node, localName) {
+    const value = zigDeclarationValue(node);
+    if (value?.type !== 'builtin_function')
+        return undefined;
+    const [builtinIdentifier, argsNode] = namedChildren(value);
+    if (builtinIdentifier?.type !== 'builtin_identifier' || builtinIdentifier.text !== '@import')
+        return undefined;
+    // The grammar's builtin-call syntax always pairs a `builtin_identifier` with an `arguments` node right
+    // after it, even when the call has zero arguments (`@import()`); the undefined-return case only
+    // satisfies `childForFieldName`'s general return type, verified against a real parse, not guessed.
+    /* v8 ignore next */
+    if (argsNode?.type !== 'arguments')
+        return undefined;
+    const args = namedChildren(argsNode);
+    const specifierNode = args.length === 1 ? args[0] : undefined;
+    if (specifierNode?.type !== 'string')
+        return undefined;
+    const specifier = namedChildren(specifierNode)[0]?.text ?? specifierNode.text.slice(1, -1);
+    return { localName, importedName: '*', specifier };
+}
+/**
+ * A Kotlin `class_declaration`/`function_declaration`/`enum_entry`'s declared name — see
+ * {@link KOTLIN_NAME_FIELD}. Found by node type among direct named children rather than by position,
+ * since an optional leading `modifiers` node (`private fun foo()`'s own wrapping `modifiers` node,
+ * itself containing a `visibility_modifier`) would otherwise occupy index 0 ahead of the real name.
+ * Verified against a real parse, not guessed.
+ */
+function kotlinDeclaredName(node) {
+    return namedChildren(node).find(child => child.type === 'simple_identifier' || child.type === 'type_identifier');
+}
+/**
+ * The Kotlin `modifiers` node wrapping a declaration's `private`/`internal`/`protected`/`public`
+ * keyword (and any annotations), if present — unlike a bare keyword token directly on the declaration
+ * itself (see `hasKeywordChild`), Kotlin always wraps its visibility keyword one level down inside a
+ * `visibility_modifier` child of this node. Verified against a real parse, not guessed.
+ */
+function kotlinModifiersNode(node) {
+    return namedChildren(node).find(child => child.type === 'modifiers');
+}
+/** Whether a Kotlin declaration's `modifiers` node (see {@link kotlinModifiersNode}) carries a
+ * `visibility_modifier` with the given keyword text. Verified against a real parse, not guessed. */
+function kotlinHasVisibility(node, keyword) {
+    const modifiers = kotlinModifiersNode(node);
+    if (modifiers === undefined)
+        return false;
+    return namedChildren(modifiers).some(child => child.type === 'visibility_modifier' && hasKeywordChild(child, keyword));
+}
+/**
+ * Whether a Scala declaration's `modifiers` node carries `keyword` (`private`/`protected`) as a bare
+ * anonymous child directly — unlike Kotlin's/Swift's own `modifiers` node, Scala's wraps the keyword
+ * with no further `visibility_modifier` layer in between. Verified against a real parse, not guessed.
+ */
+function scalaHasModifier(node, keyword) {
+    const modifiers = namedChildren(node).find(child => child.type === 'modifiers');
+    return modifiers !== undefined && hasKeywordChild(modifiers, keyword);
+}
+/**
+ * The seam kind a Kotlin `class_declaration` actually reports — `class`, `interface`, and `enum class`
+ * all share this one node type, distinguished only by a bare `interface`/`enum` keyword among the
+ * declaration's own children (never wrapped, unlike a visibility keyword — see
+ * {@link kotlinModifiersNode}); `DefinitionRule.kind` has no way to vary by a keyword the way this
+ * needs, so this is computed here instead of in `LANGUAGE_TABLE`, the same "kind computed per node"
+ * precedent `zigDeclarationKind` already establishes. Verified against a real parse, not guessed.
+ */
+function kotlinClassKind(node) {
+    if (hasKeywordChild(node, 'interface'))
+        return 'interface';
+    if (hasKeywordChild(node, 'enum'))
+        return 'enum';
+    return 'class';
+}
+/**
+ * One Kotlin `delegation_specifier`'s target name, from a `class Foo : Base(), Shape` list — a
+ * superclass with an explicit constructor call wraps a `constructor_invocation` around its `user_type`;
+ * a bare interface (or an abstract base with no call) is a `user_type` directly. Either way, the target
+ * name itself sits one level deeper still, inside the `user_type`'s own `type_identifier`. Kotlin's
+ * grammar draws no distinction here between extending a class and implementing an interface — the same
+ * ambiguity `pythonClassHeritage`/`baseListHeritage` already document for a comparable shape — so every
+ * entry reports `extends`. Verified against a real parse, not guessed.
+ * @param delegationSpecifier - the `delegation_specifier` node.
+ * @returns the target's simple name, or `undefined` when its shape is not one of the two above.
+ */
+function kotlinHeritageTargetName(delegationSpecifier) {
+    const first = namedChildren(delegationSpecifier)[0];
+    const userType = first?.type === 'constructor_invocation' ? namedChildren(first)[0] : first;
+    const typeIdentifier = userType?.type === 'user_type' ? namedChildren(userType)[0] : undefined;
+    return typeIdentifier?.type === 'type_identifier' ? typeIdentifier.text : undefined;
+}
+/**
+ * Kotlin `class_declaration`/interface heritage extraction from every `delegation_specifier` child —
+ * verified against a real parse, not guessed.
+ * @param node - the declaring `class_declaration` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the declaration declares.
+ */
+function kotlinHeritage(node, sourceKey) {
+    return namedChildren(node)
+        .filter(child => child.type === 'delegation_specifier')
+        .map(child => kotlinHeritageTargetName(child))
+        .filter((name) => name !== undefined)
+        .map(targetName => ({ sourceKey, targetName, relation: 'extends' }));
+}
+/**
+ * A Kotlin `call_expression`'s callee, resolved down to the trailing simple name — `call_expression`
+ * binds no field of its own for this grammar (see {@link KOTLIN_NAME_FIELD}'s doc comment), so this is
+ * consulted directly by `extractFile` instead of through `LanguageSpec.callFunctionField`, which can
+ * never resolve anything here. A bare call (`add(1, 2)`)'s first child is the callee `simple_identifier`
+ * directly; a member call (`p.greet()`, `kotlin.math.abs(-1)`)'s first child is a `navigation_expression`
+ * instead — its own direct `navigation_suffix` child (never itself nested, even when the receiver chain
+ * is: `a.b.c()`'s outer `navigation_expression` wraps an inner `navigation_expression` as one child and
+ * this same node's own trailing `navigation_suffix` as the other, so reading only the outermost level
+ * always reaches the correct final segment regardless of chain depth) wraps the trailing
+ * `simple_identifier` this resolves to. Verified against a real parse, not guessed.
+ * @param node - the `call_expression` node.
+ * @returns the callee's simple-name node, or `undefined` when its shape is not one of the two above.
+ */
+function kotlinCallee(node) {
+    const first = namedChildren(node)[0];
+    // The grammar's `call_expression` always wraps a callee expression as its first named child; the
+    // undefined case only satisfies `Array.prototype.at`-style general array-access return type.
+    /* v8 ignore next */
+    if (first === undefined)
+        return undefined;
+    if (first.type !== 'navigation_expression')
+        return first;
+    const suffix = namedChildren(first).find(child => child.type === 'navigation_suffix');
+    // A `navigation_expression` always wraps a trailing `navigation_suffix` naming the accessed member
+    // (`.foo`, `?.foo`, even off `super`) — verified against a real parse across a plain member access, a
+    // safe-nav access, and a `super` receiver; the undefined case only satisfies `Array.prototype.find`'s
+    // general return type.
+    /* v8 ignore next */
+    return suffix === undefined ? undefined : namedChildren(suffix).find(child => child.type === 'simple_identifier');
+}
+/**
+ * Kotlin `import_header` extraction — a plain import (`import kotlin.math.abs`) wraps its dotted path
+ * in a bare `identifier`, whose own last `simple_identifier` segment is the imported symbol; a wildcard
+ * import (`import kotlin.collections.*`) pairs that same `identifier` prefix with a sibling
+ * `wildcard_import` marker instead; an aliased import (`import java.util.List as JList`) adds a sibling
+ * `import_alias` wrapping the alias `type_identifier`. Neither `identifier` nor `import_alias` binds a
+ * field of its own. Verified against a real parse, not guessed.
+ * @param node - the `import_header` node.
+ * @returns the single import binding this statement introduces.
+ */
+function kotlinImports(node) {
+    const children = namedChildren(node);
+    const path = children.find(child => child.type === 'identifier');
+    // `import_header` always wraps a dotted path per the grammar (a bare `import;` does not parse); the
+    // empty-array case only satisfies `Array.prototype.find`'s general return type.
+    /* v8 ignore next */
+    if (path === undefined)
+        return [];
+    const specifier = path.text;
+    if (children.some(child => child.type === 'wildcard_import'))
+        return [{ localName: '', importedName: '*', specifier }];
+    const segments = namedChildren(path).filter(child => child.type === 'simple_identifier');
+    const importedName = segments.at(-1)?.text;
+    // The grammar's `identifier` rule always wraps at least one `simple_identifier` segment; the
+    // empty-array case only satisfies `Array.prototype.at`'s general return type.
+    /* v8 ignore next */
+    if (importedName === undefined)
+        return [];
+    const alias = children.find(child => child.type === 'import_alias');
+    // The grammar's `import_alias` rule always wraps exactly one `type_identifier`; the fallback only
+    // satisfies `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    const localName = alias === undefined ? importedName : (namedChildren(alias)[0]?.text ?? importedName);
+    return [{ localName, importedName, specifier }];
+}
+/**
+ * A Swift `property_declaration`'s declared name — see {@link SWIFT_PROPERTY_NAME_FIELD}. Its own
+ * `name` field points to a `pattern` node, not the identifier itself; the identifier is one level
+ * deeper, bound to that `pattern`'s own `bound_identifier` field. Verified against a real parse, not
+ * guessed.
+ */
+function swiftPropertyName(node) {
+    const pattern = node.childForFieldName('name');
+    // The grammar's `property_declaration` always binds its `name` field, even for a destructuring pattern
+    // (`let (a, b) = ...`, whose `pattern` still binds the field, just with no `bound_identifier` of its
+    // own — see the fallback below); the undefined case only satisfies `childForFieldName`'s general
+    // return type, verified against a real parse, not guessed.
+    /* v8 ignore next */
+    if (pattern === null)
+        return undefined;
+    const bound = pattern.childForFieldName('bound_identifier');
+    return bound?.type === 'simple_identifier' ? bound : undefined;
+}
+/**
+ * A Swift `function_declaration`/`protocol_function_declaration`'s declared name — see
+ * {@link SWIFT_FUNCTION_NAME_FIELD}. Uses `childForFieldName` (first match, document order) rather than
+ * `soleNamedField` (all matches, requiring exactly one): a return-typed function binds both its name
+ * and its `return_type` node to this same `name` field in this grammar build, and the name always comes
+ * first syntactically (`func f() -> Int` never writes the return type before the identifier), so the
+ * first match is always correct. Verified against a real parse, not guessed.
+ */
+function swiftFunctionName(node) {
+    const name = node.childForFieldName('name');
+    return name?.type === 'simple_identifier' ? name : undefined;
+}
+/** Whether a Swift `property_declaration` was declared with `var` (mutable) rather than `let` —
+ * the keyword sits as a bare anonymous token on the declaration's own `value_binding_pattern` child,
+ * itself one level down from `property_declaration` directly. Verified against a real parse, not
+ * guessed. */
+function swiftIsVar(node) {
+    const binding = namedChildren(node).find(child => child.type === 'value_binding_pattern');
+    return binding !== undefined && hasKeywordChild(binding, 'var');
+}
+/**
+ * The seam kind a Swift `class_declaration`/`property_declaration` actually reports —
+ * `DefinitionRule.kind` has no way to vary by a field's value or a keyword the way either needs, so
+ * this is computed here instead of in `LANGUAGE_TABLE`, the same "kind computed per node" precedent
+ * Zig's `variable_declaration`/Kotlin's `class_declaration` entries already establish. A
+ * `class_declaration`'s own `declaration_kind` field value node's type is directly `struct`/`class`/
+ * `enum` — an unusual shape (most grammars this package extracts from leave a keyword as a bare
+ * anonymous token, but this one promotes it to its own field value) verified against a real parse, not
+ * guessed. A `property_declaration` reports `field` when it is a class/struct member (inspecting the
+ * node's actual parent, not which of the two Swift `property_declaration` rules fired, so this gives
+ * the right answer regardless), or `constant`/`variable` by {@link swiftIsVar} otherwise.
+ */
+function swiftDeclarationKind(node) {
+    if (node.type === 'class_declaration') {
+        const kind = node.childForFieldName('declaration_kind')?.type;
+        return kind === 'struct' || kind === 'class' || kind === 'enum' ? kind : 'class';
+    }
+    if (node.parent?.type === 'class_body')
+        return 'field';
+    return swiftIsVar(node) ? 'variable' : 'constant';
+}
+/**
+ * Swift `class_declaration`/`protocol_declaration` heritage extraction from every `inheritance_specifier`
+ * child's `inherits_from` field — Swift draws no distinction between extending a class and conforming to
+ * a protocol in this same colon-separated list, the same ambiguity `pythonClassHeritage`/
+ * `baseListHeritage`/`kotlinHeritage` already document for a comparable shape, so every entry reports
+ * `extends`. Verified against a real parse, not guessed.
+ * @param node - the declaring `class_declaration`/`protocol_declaration` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the declaration declares.
+ */
+function swiftHeritage(node, sourceKey) {
+    return namedChildren(node)
+        .filter(child => child.type === 'inheritance_specifier')
+        .map((child) => {
+        const userType = child.childForFieldName('inherits_from');
+        // `inherits_from` always resolves to a `user_type` whose first child is a `type_identifier` for
+        // every shape this has been checked against — a plain base, a `&`-composed protocol list (each
+        // conjunct its own `inheritance_specifier`), and a module-qualified name (`Swift.Equatable`, whose
+        // `user_type` still starts with a `type_identifier`, just the qualifier segment rather than the
+        // one this package would ideally resolve to — a known, accepted imprecision, not a crash). Neither
+        // fallback is known to be reachable; both exist only to satisfy the general return type of
+        // `childForFieldName`/array access rather than guess a name for a shape not yet seen.
+        /* v8 ignore next */
+        const typeIdentifier = userType?.type === 'user_type' ? namedChildren(userType)[0] : undefined;
+        /* v8 ignore next */
+        return typeIdentifier?.type === 'type_identifier' ? typeIdentifier.text : undefined;
+    })
+        .filter((name) => name !== undefined)
+        .map(targetName => ({ sourceKey, targetName, relation: 'extends' }));
+}
+/**
+ * A Swift `call_expression`'s callee, resolved down to the trailing simple name — `call_expression`
+ * binds no field of its own for its callee (see `LANGUAGE_TABLE`'s `swift` entry), so this is consulted
+ * directly by `extractFile` instead of through `LanguageSpec.callFunctionField`. A bare call
+ * (`add(1, 2)`)'s first child is the callee `simple_identifier` directly; a member call (`p.length()`)'s
+ * first child is a `navigation_expression` instead, whose own `suffix` field gives a `navigation_suffix`
+ * node, itself carrying the trailing identifier through its own `suffix` field in turn — reading only
+ * this outermost level reaches the correct final segment regardless of a longer dotted chain, the same
+ * "outermost level is enough" shape `kotlinCallee` already documents. Verified against a real parse, not
+ * guessed.
+ * @param node - the `call_expression` node.
+ * @returns the callee's simple-name node, or `undefined` when its shape is not one of the two above.
+ */
+function swiftCallee(node) {
+    const first = namedChildren(node)[0];
+    // The grammar's `call_expression` always wraps a callee expression as its first named child; the
+    // undefined case only satisfies `Array.prototype.at`-style general array-access return type.
+    /* v8 ignore next */
+    if (first === undefined)
+        return undefined;
+    if (first.type !== 'navigation_expression')
+        return first;
+    const navigationSuffix = first.childForFieldName('suffix');
+    const trailing = navigationSuffix?.childForFieldName('suffix');
+    // A `navigation_expression`'s own `suffix` field always resolves to a `navigation_suffix` carrying a
+    // trailing `suffix` of its own in turn (`.foo`, `?.foo`, even off `super`) — verified against a real
+    // parse across a plain member access, a safe-nav access, and a `super` receiver; the undefined case
+    // only satisfies `childForFieldName`'s general return type.
+    /* v8 ignore next */
+    return trailing === null ? undefined : trailing;
+}
+/**
+ * Swift `import_declaration` extraction — a whole-module import (`import Foundation`) wraps its dotted
+ * path in a bare `identifier`, whose own last `simple_identifier` segment is the module's own simple
+ * name; like a Go package import, it binds no individual symbol this package tracks by name, so the
+ * local name recorded is that same trailing segment (matching `goImports`'s own convention for a
+ * whole-package binding) rather than the empty-string, side-effect-only marker a `#include`/`require`
+ * binding uses elsewhere in this file. Verified against a real parse, not guessed.
+ * @param node - the `import_declaration` node.
+ * @returns the single import binding this statement introduces.
+ */
+function swiftImports(node) {
+    const path = namedChildren(node).find(child => child.type === 'identifier');
+    // `import_declaration` always wraps a dotted path per the grammar; the empty-array case only
+    // satisfies `Array.prototype.find`'s general return type.
+    /* v8 ignore next */
+    if (path === undefined)
+        return [];
+    const specifier = path.text;
+    const segments = namedChildren(path).filter(child => child.type === 'simple_identifier');
+    const localName = segments.at(-1)?.text;
+    // The grammar's `identifier` rule always wraps at least one `simple_identifier` segment; the
+    // empty-array case only satisfies `Array.prototype.at`'s general return type.
+    /* v8 ignore next */
+    if (localName === undefined)
+        return [];
+    return [{ localName, importedName: '*', specifier }];
+}
+/**
+ * A Dart `declaration`'s field name — see {@link DART_FIELD_NAME_FIELD}. Only the single-identifier
+ * `initialized_identifier_list` shape is named; a constructor-wrapping `declaration` (no
+ * `initialized_identifier_list` child at all) and a multi-declare `int x, y;` (more than one
+ * `initialized_identifier`) both return `undefined` rather than guess a name for a shape this package
+ * does not attempt to resolve. Verified against a real parse, not guessed.
+ */
+function dartFieldName(node) {
+    const list = namedChildren(node).find(child => child.type === 'initialized_identifier_list');
+    if (list === undefined)
+        return undefined;
+    const items = namedChildren(list).filter(child => child.type === 'initialized_identifier');
+    const sole = items.length === 1 ? items[0] : undefined;
+    if (sole === undefined)
+        return undefined;
+    const name = namedChildren(sole)[0];
+    // The grammar's `initialized_identifier` always wraps its own name as an `identifier` first child,
+    // with an optional initializer expression only ever following it (`int x = 5;` still binds `x` first)
+    // — verified against a real parse, not guessed; the undefined case only satisfies
+    // `Array.prototype.at`-style general array-access return type.
+    /* v8 ignore next */
+    return name?.type === 'identifier' ? name : undefined;
+}
+/**
+ * Dart `class_definition` heritage extraction from its `superclass` field (`extends Base`, wrapping the
+ * base type directly) and `interfaces` field (`implements Shape, Other` — a single wrapper node holding
+ * one `type_identifier` per implemented interface as its own direct children, verified against a real
+ * parse). Dart draws no distinction here that this package resolves beyond `extends`/`implements`
+ * themselves, so a `superclass` entry reports `extends` and each `interfaces` entry reports
+ * `implements`.
+ * @param node - the declaring `class_definition` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the class declares.
+ */
+function dartHeritage(node, sourceKey) {
+    const refs = [];
+    const superclass = node.childForFieldName('superclass');
+    const base = superclass === null ? undefined : namedChildren(superclass)[0];
+    // Every `superclass` shape checked against a real parse — a plain base, a module-qualified one
+    // (`lib.Base`), and a generic one (`Generic<int>`) — puts a heritage-name-shaped node first; the false
+    // case exists only as this file's usual "don't guess" guard for a shape not yet seen, matching
+    // `isHeritageName`'s other call sites.
+    /* v8 ignore next */
+    if (base !== undefined && isHeritageName(base))
+        refs.push({ sourceKey, targetName: base.text, relation: 'extends' });
+    const interfaces = node.childForFieldName('interfaces');
+    if (interfaces !== null) {
+        // An `implements` clause always lists at least one target per the grammar (`implements` with an
+        // empty list does not parse); the zero-iteration case only satisfies the general shape of iterating
+        // an array that could in principle be empty.
+        /* v8 ignore next */
+        for (const target of namedChildren(interfaces)) {
+            if (isHeritageName(target))
+                refs.push({ sourceKey, targetName: target.text, relation: 'implements' });
+        }
+    }
+    return refs;
+}
+/**
+ * Dart `import_specification` extraction — the URI sits three levels down, in a `configurable_uri` →
+ * `uri` → `string_literal` chain, none of them bound to a field of their own; an `as` alias adds a
+ * sibling `identifier`. This grammar's `string_literal` carries no separate content child (unlike
+ * ECMAScript's `string_fragment`/PHP's escaped content) — its text is read directly off the quoted node
+ * itself, stripping the surrounding quote characters. Verified against a real parse, not guessed.
+ * @param node - the `import_specification` node.
+ * @returns the single import binding this statement introduces.
+ */
+function dartImports(node) {
+    // Every `import_specification` shape checked against a real parse — a plain import, an aliased one,
+    // and a conditional import (`if (dart.library.html) '...'`, whose primary `uri` sits alongside rather
+    // than inside the conditional part) — resolves this same `configurable_uri` → `uri` → `string_literal`
+    // chain; each undefined/type-mismatch fallback below only satisfies `Array.prototype.find`'s and
+    // `childForFieldName`'s general return types, not a shape actually seen.
+    /* v8 ignore next */
+    const configurableUri = namedChildren(node).find(child => child.type === 'configurable_uri');
+    /* v8 ignore next */
+    const uri = configurableUri === undefined ? undefined : namedChildren(configurableUri).find(child => child.type === 'uri');
+    /* v8 ignore next */
+    const stringLiteral = uri === undefined ? undefined : namedChildren(uri)[0];
+    /* v8 ignore next */
+    if (stringLiteral?.type !== 'string_literal')
+        return [];
+    const specifier = stringLiteral.text.slice(1, -1);
+    const alias = namedChildren(node).find(child => child.type === 'identifier');
+    return [{ localName: alias?.text ?? '', importedName: '*', specifier }];
+}
+/**
+ * Scala `import_declaration` extraction, covering both its shapes: a plain dotted path (`import
+ * scala.math.abs`, whose `path` field's own trailing `identifier` descendant is the imported symbol),
+ * and a selector list (`import scala.collection.{List, Map}`, whose sibling `import_selectors` node
+ * binds each imported name directly). An `import_selectors` entry renamed with `=>` or a wildcard `_`
+ * import is not named here — the same "don't guess" precedent this file already follows for a shape it
+ * does not fully resolve; every `import_selectors` child this does not recognize is simply filtered out
+ * rather than mis-read. Verified against a real parse, not guessed.
+ * @param node - the `import_declaration` node.
+ * @returns every import binding this statement introduces.
+ */
+function scalaImports(node) {
+    const path = node.childForFieldName('path');
+    // `import_declaration` always binds a `path` field — verified against a real parse for a single
+    // bare-name import, a dotted one, and a comma-separated multi-import (each still binds its own `path`);
+    // the empty-array case only satisfies `childForFieldName`'s general return type.
+    /* v8 ignore next */
+    if (path === null)
+        return [];
+    const prefix = path.text;
+    const selectors = namedChildren(node).find(child => child.type === 'import_selectors');
+    if (selectors === undefined) {
+        const last = descendantsOfType(path, ['identifier']).at(-1);
+        // The grammar's `stable_identifier`/`identifier` path always wraps at least one `identifier`
+        // segment; the empty-array case only satisfies `Array.prototype.at`'s general return type.
+        /* v8 ignore next */
+        if (last === undefined)
+            return [];
+        return [{ localName: last.text, importedName: last.text, specifier: prefix }];
+    }
+    return namedChildren(selectors)
+        .filter(child => child.type === 'identifier')
+        .map(name => ({ localName: name.text, importedName: name.text, specifier: `${prefix}.${name.text}` }));
+}
 /** The definition rule matching `node`, or `undefined` when it introduces no declaration. */
 function matchDefinition(node, definitions) {
     for (const rule of definitions) {
         if (node.type !== rule.nodeType)
             continue;
+        if (rule.parentType !== undefined && node.parent?.type !== rule.parentType)
+            continue;
+        if (rule.grandparentType !== undefined && node.parent?.parent?.type !== rule.grandparentType)
+            continue;
         if (rule.value !== undefined) {
             const value = node.childForFieldName(rule.value.field);
             if (value === null || !rule.value.types.includes(value.type))
                 continue;
         }
+        const nameNode = rule.nameField === SELF_NAME_FIELD ? node
+            : rule.nameField === DECLARATOR_NAME_FIELD ? declaratorName(node)
+                : rule.nameField === FIRST_CHILD_NAME_FIELD ? firstChildName(node)
+                    : rule.nameField === PHP_ELEMENT_NAME_FIELD ? phpElementName(node)
+                        : rule.nameField === KOTLIN_NAME_FIELD ? kotlinDeclaredName(node)
+                            : rule.nameField === SWIFT_PROPERTY_NAME_FIELD ? swiftPropertyName(node)
+                                : rule.nameField === SWIFT_FUNCTION_NAME_FIELD ? swiftFunctionName(node)
+                                    : rule.nameField === DART_FIELD_NAME_FIELD ? dartFieldName(node)
+                                        : soleNamedField(node, rule.nameField);
+        if (nameNode === undefined)
+            continue;
+        if (rule.nameNodeTypes !== undefined && !rule.nameNodeTypes.includes(nameNode.type))
+            continue;
         return rule;
     }
     return undefined;
@@ -60,15 +752,136 @@ function matchDefinition(node, definitions) {
  * computed or parenthesized callee, for instance).
  */
 function calleeName(callee) {
+    // Rust's turbofish call (`collect::<Vec<_>>()`) wraps the real callee expression in its own
+    // `generic_function` node, pairing a `function` field with a sibling `type_arguments` field for the
+    // explicit generics — unwrap to the inner expression and resolve it the same way as any other call.
+    // Verified against a real parse, not guessed.
+    if (callee.type === 'generic_function') {
+        const inner = callee.childForFieldName('function');
+        // `generic_function` always binds a `function` field per the grammar; the undefined case only
+        // satisfies `childForFieldName`'s general return type.
+        /* v8 ignore next */
+        return inner === null ? undefined : calleeName(inner);
+    }
     if (callee.type === 'identifier')
         return callee.text;
+    // Kotlin's bare-name node type — `kotlinCallee` already resolves a call's callee (bare or member) down
+    // to this node type directly before `calleeName` ever sees it. Verified against a real parse.
+    if (callee.type === 'simple_identifier')
+        return callee.text;
+    // PHP's bare-name node type — the resolved `callFunctionFieldByType` field value for all three of its
+    // call shapes (`function_call_expression`'s simple case, `member_call_expression`'s and
+    // `scoped_call_expression`'s method name) is this node type directly, never wrapped in a further
+    // field. Verified against a real parse, not guessed.
+    if (callee.type === 'name')
+        return callee.text;
+    // PHP's namespaced free-function call (`Foo\bar()`) — `qualified_name` binds neither its namespace
+    // prefix nor its final segment to a field of its own (unlike C++'s `qualified_identifier`, below); the
+    // final segment is always its last named child. Verified against a real parse, not guessed.
+    if (callee.type === 'qualified_name') {
+        const last = namedChildren(callee).at(-1);
+        // The grammar's `qualified_name` rule always wraps at least one final segment of this type; the
+        // fallback only satisfies `Array.prototype.at`'s general return type.
+        /* v8 ignore next */
+        return last?.type === 'name' ? last.text : undefined;
+    }
+    // `name` covers C++'s `qualified_identifier` (`ns::func`), C#'s `member_access_expression`
+    // (`obj.Method()`), and Rust's `scoped_identifier` (`Type::method()`, `std::mem::swap()`) — no other
+    // call-callee shape in this file's language tables binds a field called `name` for anything else,
+    // and Rust's `field_expression` (`obj.method()`) binds `field` instead, already covered below.
+    // `member` covers Zig's own `field_expression` (`obj.method()`, `Point.init()`) instead — Zig's
+    // grammar names this field `member`, not `field`, the only grammar in this file's tables to do so.
+    // Verified against a real parse, not guessed.
     const property = callee.childForFieldName('property')
         ?? callee.childForFieldName('field')
-        ?? callee.childForFieldName('attribute');
+        ?? callee.childForFieldName('member')
+        ?? callee.childForFieldName('attribute')
+        ?? callee.childForFieldName('name');
     if (property !== null && property.type !== 'computed_property_name')
         return property.text;
     return undefined;
 }
+/** Seam language labels using the ECMAScript-family grammars, for CommonJS `require`/export detection. */
+const ECMASCRIPT_LANGUAGES = new Set(['typescript', 'tsx', 'javascript', 'jsx']);
+/** Shared empty set for a non-ECMAScript file, which never has CommonJS export assignments to find. */
+const EMPTY_NAME_SET = new Set();
+/**
+ * A CommonJS `require('./foo')` call recognized as an import binding: `const foo = require('./foo')`
+ * binds `foo`; a bare `require('./foo')` statement imports for its side effect only. Any other
+ * position (a sub-expression, immediate member access on the call result) is not a binding this
+ * package attempts to name — the same "don't guess a name" precedent `ecmascriptImports`/
+ * `pythonBinding` already follow for shapes they do not fully resolve. Without this, CommonJS code
+ * (still common outside pure-ESM projects) parses `require` as an ordinary, always-unresolved call
+ * and the workspace gets no `imports` edge for it at all.
+ * @param node - a `call_expression` node.
+ * @returns the import binding, or `undefined` when `node` is not a bare top-level `require(...)` call.
+ */
+function commonJsRequireImport(node) {
+    const callee = node.childForFieldName('function');
+    // A call node's `function` field is required by the grammar; the null case only satisfies
+    // `childForFieldName`'s general return type.
+    /* v8 ignore next */
+    if (callee === null)
+        return undefined;
+    if (callee.type !== 'identifier' || callee.text !== 'require')
+        return undefined;
+    const argsNode = node.childForFieldName('arguments');
+    // Likewise required by the grammar, present (empty) even for a zero-argument call.
+    /* v8 ignore next */
+    if (argsNode === null)
+        return undefined;
+    const args = namedChildren(argsNode);
+    const specifierNode = args.length === 1 ? args[0] : undefined;
+    if (specifierNode?.type !== 'string')
+        return undefined;
+    const specifier = namedChildren(specifierNode)[0]?.text ?? specifierNode.text.slice(1, -1);
+    const parent = node.parent;
+    if (parent?.type === 'variable_declarator') {
+        const name = parent.childForFieldName('name');
+        if (name?.type !== 'identifier')
+            return undefined;
+        return { localName: name.text, importedName: '*', specifier };
+    }
+    if (parent?.type === 'expression_statement')
+        return { localName: '', importedName: '*', specifier };
+    return undefined;
+}
+/**
+ * A Ruby `require '...'`/`require_relative '...'` call recognized as an import binding — Ruby's
+ * grammar has no dedicated import-statement node type at all (see `LANGUAGE_TABLE`'s `ruby` entry),
+ * so this dispatches off an ordinary `call` node the same way `commonJsRequireImport` does for
+ * CommonJS. Binds no local name — like a C `#include` or a Go whole-package import, `require` pulls
+ * in a file for its side effects, not a single symbol this package tracks by name. Verified against a
+ * real parse, not guessed.
+ * @param node - a `call` node.
+ * @returns the import binding, or `undefined` when `node` is not a bare top-level `require`/
+ * `require_relative` call.
+ */
+function rubyRequireImport(node) {
+    const method = node.childForFieldName('method');
+    // A `call` node's `method` field always resolves to a plain `identifier` regardless of receiver shape
+    // — verified against a real parse for a bare call, a receiver call (`obj.require(...)`), a scope-
+    // resolution call (`Foo::require(...)`), and a safe-nav call (`obj&.require(...)`), every one still
+    // binding `method` to the same `identifier` node type; neither fallback below is known to be reachable.
+    /* v8 ignore next */
+    if (method === null || method.type !== 'identifier')
+        return undefined;
+    if (method.text !== 'require' && method.text !== 'require_relative')
+        return undefined;
+    const argsNode = node.childForFieldName('arguments');
+    // A `call` node always binds an `arguments` field, even to an empty `argument_list` for a call with no
+    // arguments at all — verified against a real parse; a bare `require` with neither parentheses nor
+    // arguments parses as a plain `identifier`, never reaching a `call` node in the first place.
+    /* v8 ignore next */
+    if (argsNode === null)
+        return undefined;
+    const args = namedChildren(argsNode);
+    const specifierNode = args.length === 1 ? args[0] : undefined;
+    if (specifierNode?.type !== 'string')
+        return undefined;
+    const specifier = namedChildren(specifierNode)[0]?.text ?? specifierNode.text.slice(1, -1);
+    return { localName: '', importedName: '*', specifier };
+}
 /** ECMAScript-family import extraction: `import_statement` with a `import_clause` and a `source`. */
 function ecmascriptImports(node) {
     // `source` is required by the grammar; the null case only satisfies `childForFieldName`'s general
@@ -116,6 +929,60 @@ function ecmascriptImports(node) {
     }
     return imports;
 }
+/**
+ * One Python `decorator` node's name — a bare `@staticmethod` names its own `identifier`; `@app.route`
+ * names its dotted `attribute` verbatim (not just the rightmost segment, unlike `calleeName`'s call-site
+ * ambiguity — a decorator name is metadata, not something this package resolves, so there is no reason
+ * to throw away the qualifying prefix); `@app.route('/x')` first unwraps the `call` to its `function`
+ * field, then applies the same rule. Any other shape (e.g. a subscript, `@decorators[0]`) is not named —
+ * the "don't guess" precedent this file already follows elsewhere.
+ * @param decorator - the `decorator` node.
+ * @returns the decorator's name, or `undefined` when its expression is not identifier/attribute-shaped.
+ */
+function pythonDecoratorName(decorator) {
+    let expr = namedChildren(decorator)[0];
+    // A decorator's expression is required by the grammar (`@` alone does not parse); the undefined case
+    // only satisfies `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    if (expr === undefined)
+        return undefined;
+    if (expr.type === 'call') {
+        // A call node's `function` field is required by the grammar; the null case only satisfies
+        // `childForFieldName`'s general return type.
+        const callee = expr.childForFieldName('function');
+        /* v8 ignore next */
+        if (callee === null)
+            return undefined;
+        expr = callee;
+    }
+    if (expr.type === 'identifier' || expr.type === 'attribute')
+        return expr.text;
+    return undefined;
+}
+/**
+ * Every decorator name applied to a Python `function_definition`/`class_definition`, from its enclosing
+ * `decorated_definition`'s `decorator` children (a decorated declaration is wrapped one level up by the
+ * grammar, not marked on the declaration node itself — verified against a real parse, not guessed).
+ * Empty when the language is not Python or the declaration is undecorated.
+ * @param node - the `function_definition`/`class_definition` node.
+ * @param language - the seam language label the file was parsed as.
+ * @returns every decorator name applied, outermost first.
+ */
+function pythonDecorators(node, language) {
+    if (language !== 'python')
+        return [];
+    if (node.parent?.type !== 'decorated_definition')
+        return [];
+    const names = [];
+    for (const child of namedChildren(node.parent)) {
+        if (child.type !== 'decorator')
+            continue;
+        const name = pythonDecoratorName(child);
+        if (name !== undefined)
+            names.push(name);
+    }
+    return names;
+}
 /**
  * One `dotted_name` or `aliased_import` child of a Python import statement, resolved to a binding.
  * @param child - the `dotted_name` or `aliased_import` node.
@@ -151,10 +1018,14 @@ function pythonImports(node) {
         // by type from an imported symbol written the same way (`from x import y`).
         .filter(child => !(moduleNode !== null && child.equals(moduleNode)))
         .filter(child => child.type === 'dotted_name' || child.type === 'aliased_import' || child.type === 'wildcard_import')
-        .flatMap((child) => {
+        .map((child) => {
+        // `from x import *` binds no individual symbol this package tracks by name, but the module
+        // itself is still imported — recording it (with no `localName`, `importedName: '*'`, matching
+        // the namespace-import convention `pythonBinding` already uses) keeps the `imports` edge to
+        // `specifier` instead of silently dropping the statement.
         if (child.type === 'wildcard_import')
-            return [];
-        return [pythonBinding(child, true, specifier)];
+            return { localName: '', importedName: '*', specifier };
+        return pythonBinding(child, true, specifier);
     });
 }
 /** Go import extraction: `import_declaration` wraps one or more `import_spec` nodes, each requiring a `path`. */
@@ -174,6 +1045,571 @@ function goImports(node) {
         return { localName: local, importedName: '*', specifier: raw };
     });
 }
+/**
+ * Java import extraction: `import_declaration` wraps a `scoped_identifier` (a dotted path,
+ * `java.util.List`) or, for a single-segment specifier, a bare `identifier`, plus an optional
+ * trailing `asterisk` child for a wildcard import (`import java.util.*;`). The `static` keyword
+ * (`import static java.lang.Math.max;`) is an unnamed token the grammar tacks onto the same shape, so
+ * no separate handling is needed — the specifier and local name below are extracted identically
+ * either way. Verified against a real parse, not guessed.
+ * @param node - the `import_declaration` node.
+ * @returns the single import binding this statement introduces.
+ */
+function javaImports(node) {
+    const children = namedChildren(node);
+    const path = children.find(child => child.type === 'scoped_identifier' || child.type === 'identifier');
+    // `import_declaration` always wraps one of these two node types per the grammar; the undefined case
+    // only satisfies `Array.prototype.find`'s general return type.
+    /* v8 ignore next */
+    if (path === undefined)
+        return [];
+    const specifier = path.text;
+    // A package import binds no individual symbol; resolution never matches on `importedName: '*'`,
+    // matching `goImports`'s same precedent for a whole-package/wildcard binding.
+    if (children.some(child => child.type === 'asterisk'))
+        return [{ localName: '', importedName: '*', specifier }];
+    const localName = path.type === 'scoped_identifier' ? fieldText(path, 'name', specifier) : specifier;
+    return [{ localName, importedName: '*', specifier }];
+}
+/**
+ * C/C++ `#include` extraction. A system include (`#include <stdio.h>`) parses as a `system_lib_string`
+ * token holding the whole `<...>` text; a local include (`#include "local.h"`) wraps a `string_literal`
+ * around a `string_content` child holding the bare path. Neither binds an individual symbol this
+ * package tracks by name — like a Go whole-package import, it is recorded for completeness with no
+ * `localName`, matching that same side-effect-only convention. Verified against a real parse, not guessed.
+ * @param node - the `preproc_include` node.
+ * @returns the single import binding this directive introduces.
+ */
+function cIncludeImports(node) {
+    const path = namedChildren(node)[0];
+    // `preproc_include` always wraps exactly one of `system_lib_string`/`string_literal`/an
+    // expanded-macro path per the grammar; the undefined case only satisfies `namedChildren`'s general
+    // array-access return type.
+    /* v8 ignore next */
+    if (path === undefined)
+        return [];
+    const specifier = path.type === 'system_lib_string' ? path.text.slice(1, -1) : (namedChildren(path)[0]?.text ?? path.text.slice(1, -1));
+    return [{ localName: '', importedName: '*', specifier }];
+}
+/**
+ * C# `using_directive` extraction. A plain directive (`using System;`) wraps its dotted path
+ * (`identifier`/`qualified_name`) directly; an aliased one (`using Alias = System.Text;`) wraps a
+ * `name_equals` (the alias) alongside the same dotted-path shape for the target. Neither form binds an
+ * individual symbol the way an ECMAScript named import does — a C# `using` imports a whole namespace —
+ * so the aliased form's `localName` is the alias itself, matching the namespace-import convention
+ * `pythonBinding`/`goImports` already use elsewhere in this file. Verified against a real parse, not
+ * guessed.
+ * @param node - the `using_directive` node.
+ * @returns the single import binding this directive introduces.
+ */
+function csharpUsingImports(node) {
+    const children = namedChildren(node);
+    const alias = children.find(child => child.type === 'name_equals');
+    const path = children.find(child => child.type === 'identifier' || child.type === 'qualified_name');
+    // `using_directive` always wraps a dotted path per the grammar (a bare `using;` does not parse); the
+    // undefined case only satisfies `Array.prototype.find`'s general return type.
+    /* v8 ignore next */
+    if (path === undefined)
+        return [];
+    const specifier = path.text;
+    // The grammar's `name_equals` rule always wraps exactly one `identifier`; the fallback only satisfies
+    // `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    const localName = alias === undefined ? '' : (namedChildren(alias)[0]?.text ?? '');
+    return [{ localName, importedName: '*', specifier }];
+}
+/**
+ * One `namespace_use_clause`'s bound name and optional alias — `use App\Contracts\Cacheable;` binds a
+ * `qualified_name` (its final segment is always the last named child, with no field of its own, matching
+ * `calleeName`'s same `qualified_name` handling); a single-segment `use Foo;` binds a bare `name`
+ * directly instead. An `as` rename wraps a `namespace_aliasing_clause` sibling. Verified against a real
+ * parse, not guessed.
+ * @param clause - the `namespace_use_clause` node.
+ * @returns the imported name and its local binding, or `undefined` when the clause's target is a shape
+ * this package does not name (never observed in practice, but `qualified_name`'s grammar rule allows no
+ * other target).
+ */
+function phpUseClauseBinding(clause) {
+    // `namespace_use_clause` always wraps exactly one of these two node types per the grammar; the
+    // fallback (`clause` itself) only satisfies `Array.prototype.find`'s general return type.
+    /* v8 ignore next */
+    const target = namedChildren(clause).find(child => child.type === 'qualified_name' || child.type === 'name') ?? clause;
+    const specifier = target.text;
+    // The grammar's `qualified_name` rule always wraps at least one final segment; the fallback only
+    // satisfies `Array.prototype.at`'s general return type.
+    /* v8 ignore next */
+    const importedName = target.type === 'qualified_name' ? (namedChildren(target).at(-1)?.text ?? specifier) : specifier;
+    const alias = namedChildren(clause).find(child => child.type === 'namespace_aliasing_clause');
+    // The grammar's `namespace_aliasing_clause` rule always wraps exactly one `name`; the fallback only
+    // satisfies `namedChildren`'s general array-access return type.
+    /* v8 ignore next */
+    const localName = alias === undefined ? importedName : (namedChildren(alias)[0]?.text ?? importedName);
+    return { importedName, localName, specifier };
+}
+/**
+ * PHP `namespace_use_declaration` extraction, covering both its shapes: a comma-separated list of
+ * `namespace_use_clause` siblings (`use A\B, C\D as E;`), and a group `use App\{Foo, Bar as Baz};` — the
+ * group form's shared prefix sits in a bare `namespace_name` sibling of the `namespace_use_group`, and
+ * each `namespace_use_group_clause` inside it repeats the same name-plus-optional-alias shape as a plain
+ * clause. The `function`/`const` keyword a `use function …`/`use const …` statement adds is an anonymous
+ * token the grammar tacks onto the same shape either way, so no separate handling is needed. Verified
+ * against a real parse, not guessed.
+ * @param node - the `namespace_use_declaration` node.
+ * @returns every import binding this statement introduces.
+ */
+function phpImports(node) {
+    const group = namedChildren(node).find(child => child.type === 'namespace_use_group');
+    if (group !== undefined) {
+        // The grammar always pairs a `namespace_use_group` with a preceding `namespace_name` prefix; the
+        // undefined case only satisfies `Array.prototype.find`'s general return type.
+        const prefix = namedChildren(node).find(child => child.type === 'namespace_name');
+        /* v8 ignore next */
+        const prefixText = prefix?.text ?? '';
+        return namedChildren(group)
+            .filter(child => child.type === 'namespace_use_group_clause')
+            .map((clause) => {
+            // A group clause's own name is always a bare `namespace_name` (itself wrapping a single `name`
+            // token, even for a single-segment clause) — never a `qualified_name`, since the shared prefix
+            // already carries every segment before it. Verified against a real parse, not guessed.
+            const nameNode = namedChildren(clause).find(child => child.type === 'namespace_name');
+            // The grammar always binds one per `namespace_use_group_clause`; the undefined case only
+            // satisfies `Array.prototype.find`'s general return type.
+            /* v8 ignore next */
+            const segment = nameNode?.text ?? '';
+            const alias = namedChildren(clause).find(child => child.type === 'namespace_aliasing_clause');
+            // The grammar's `namespace_aliasing_clause` rule always wraps exactly one `name`; the fallback
+            // only satisfies `namedChildren`'s general array-access return type.
+            /* v8 ignore next */
+            const localName = alias === undefined ? segment : (namedChildren(alias)[0]?.text ?? segment);
+            return { localName, importedName: segment, specifier: `${prefixText}\\${segment}` };
+        });
+    }
+    return namedChildren(node)
+        .filter(child => child.type === 'namespace_use_clause')
+        .map(clause => phpUseClauseBinding(clause));
+}
+/** A path's final `::`-separated segment, or the whole text when it has none. */
+function rustLastSegment(path) {
+    const index = path.lastIndexOf('::');
+    return index === -1 ? path : path.slice(index + 2);
+}
+/** `prefix::segment`, or just `segment` when there is no enclosing prefix yet. */
+function combineRustPrefix(prefix, segment) {
+    return prefix === '' ? segment : `${prefix}::${segment}`;
+}
+/**
+ * One Rust `use` clause target, resolved to zero or more import bindings — recursive because a
+ * `scoped_use_list`/`use_list` can nest arbitrarily (`use std::{fmt::{self, Display}, io};`).
+ * @param node - a `_use_clause` node: `identifier`, `self`, `scoped_identifier`, `use_wildcard`,
+ * `use_as_clause`, `scoped_use_list`, or `use_list`. `crate`/`super` never reach this function on their
+ * own — the grammar only ever produces them as a `scoped_identifier`'s `path` field, never as a
+ * standalone use target.
+ * @param prefix - the module path text accumulated from enclosing `scoped_use_list` wrappers, or `''`
+ * at the top of a `use_declaration`.
+ * @returns every import binding this clause (and any it nests) introduces.
+ */
+function rustUseTarget(node, prefix) {
+    if (node.type === 'identifier') {
+        return [{ localName: node.text, importedName: node.text, specifier: combineRustPrefix(prefix, node.text) }];
+    }
+    if (node.type === 'self') {
+        // `self` inside a `use_list` (`use std::fmt::{self, Display};`) imports the enclosing module path
+        // itself, bound to its own last segment rather than a member of it. Verified against a real parse.
+        const name = rustLastSegment(prefix);
+        return [{ localName: name, importedName: name, specifier: prefix }];
+    }
+    if (node.type === 'scoped_identifier') {
+        // `name` is required by the grammar; the fallback only satisfies `childForFieldName`'s general
+        // return type.
+        const name = node.childForFieldName('name');
+        /* v8 ignore next */
+        const localName = name?.text ?? node.text;
+        return [{ localName, importedName: localName, specifier: combineRustPrefix(prefix, node.text) }];
+    }
+    if (node.type === 'use_wildcard') {
+        // The grammar's `use_wildcard` rule always wraps exactly one path node before the `*`; the
+        // undefined case only satisfies `namedChildren`'s general array-access return type.
+        const path = namedChildren(node)[0];
+        /* v8 ignore next */
+        const specifier = path === undefined ? prefix : combineRustPrefix(prefix, path.text);
+        // A glob import binds no individual symbol this package tracks by name, matching Go's
+        // whole-package-import convention.
+        return [{ localName: '', importedName: '*', specifier }];
+    }
+    if (node.type === 'use_as_clause') {
+        const path = node.childForFieldName('path');
+        const alias = node.childForFieldName('alias');
+        // Both fields are required by the grammar's `use_as_clause` rule; the empty-array case only
+        // satisfies `childForFieldName`'s general return type.
+        /* v8 ignore next */
+        if (path === null || alias === null)
+            return [];
+        const [binding] = rustUseTarget(path, prefix);
+        // `rustUseTarget` always returns exactly one binding for the node types `path` can hold here
+        // (`identifier`, `self`, `scoped_identifier`); the undefined case only satisfies the general
+        // array-destructuring return type.
+        /* v8 ignore next */
+        return binding === undefined ? [] : [{ ...binding, localName: alias.text }];
+    }
+    if (node.type === 'scoped_use_list') {
+        const path = node.childForFieldName('path');
+        const list = node.childForFieldName('list');
+        // `list` is required by the grammar's `scoped_use_list` rule; the empty-array case only satisfies
+        // `childForFieldName`'s general return type.
+        /* v8 ignore next */
+        if (list === null)
+            return [];
+        // A `scoped_use_list` is exactly what distinguishes a path-prefixed braced group (`foo::{bar}`) from
+        // a bare one (`use {foo, bar};`, which parses as a plain `use_list` instead, never reaching this
+        // branch at all) — its `path` field is therefore always present whenever this node type is matched;
+        // the fallback only satisfies `childForFieldName`'s general return type.
+        /* v8 ignore next */
+        const newPrefix = path === null ? prefix : combineRustPrefix(prefix, path.text);
+        return namedChildren(list).flatMap(child => rustUseTarget(child, newPrefix));
+    }
+    // Every node type a `_use_clause` alternative can hold is handled by an earlier branch above; falling
+    // through to here would require some other node type, which the grammar never produces in this
+    // position.
+    /* v8 ignore next */
+    if (node.type === 'use_list') {
+        return namedChildren(node).flatMap(child => rustUseTarget(child, prefix));
+    }
+    // No other node type is a valid `_use_clause` alternative per the grammar.
+    /* v8 ignore next */
+    return [];
+}
+/** Rust `use_declaration` extraction, dispatching to {@link rustUseTarget} on its `argument` field. */
+function rustImports(node) {
+    const argument = node.childForFieldName('argument');
+    // `argument` is required by the grammar's `use_declaration` rule; the empty-array case only satisfies
+    // `childForFieldName`'s general return type.
+    /* v8 ignore next */
+    if (argument === null)
+        return [];
+    return rustUseTarget(argument, '');
+}
+/** Whether `node` is a bare name this package resolves heritage references against — a member
+ * expression (`ns.Base`) or a call (a mixin, `f(Base)`) is not, matching the "don't guess" precedent
+ * `calleeName`/`ecmascriptImports` already follow for shapes they do not fully resolve. `constant` is
+ * Ruby's own bare-name node type (see `rubyClassHeritage`), verified against a real parse. */
+function isHeritageName(node) {
+    return node.type === 'identifier' || node.type === 'type_identifier' || node.type === 'name' || node.type === 'constant';
+}
+/**
+ * ECMAScript-family `extends`/`implements` extraction from a `class_declaration`'s `class_heritage`
+ * child. Plain JavaScript's `class_heritage` wraps the extended expression directly (`extends Base` has
+ * no further wrapper — JavaScript has no `implements`); TypeScript's wraps an `extends_clause` and an
+ * optional `implements_clause` instead, verified against a real parse, not guessed.
+ * @param node - the `class_declaration` node.
+ * @param sourceKey - the declaring class's own {@link RawDefinition.key}.
+ * @returns every heritage reference the class declares.
+ */
+function ecmascriptClassHeritage(node, sourceKey) {
+    const heritage = namedChildren(node).find(child => child.type === 'class_heritage');
+    if (heritage === undefined)
+        return [];
+    const refs = [];
+    for (const child of namedChildren(heritage)) {
+        if (child.type === 'extends_clause') {
+            const target = namedChildren(child)[0];
+            if (target !== undefined && isHeritageName(target))
+                refs.push({ sourceKey, targetName: target.text, relation: 'extends' });
+            continue;
+        }
+        if (child.type === 'implements_clause') {
+            for (const impl of namedChildren(child)) {
+                if (isHeritageName(impl))
+                    refs.push({ sourceKey, targetName: impl.text, relation: 'implements' });
+            }
+            continue;
+        }
+        // Plain JavaScript: `child` is the extended expression itself.
+        if (isHeritageName(child))
+            refs.push({ sourceKey, targetName: child.text, relation: 'extends' });
+    }
+    return refs;
+}
+/**
+ * TypeScript `interface_declaration` `extends` extraction from its `extends_type_clause` child — an
+ * interface can extend more than one other interface (`interface C extends A, B {}`).
+ * @param node - the `interface_declaration` node.
+ * @param sourceKey - the declaring interface's own {@link RawDefinition.key}.
+ * @returns every heritage reference the interface declares.
+ */
+function tsInterfaceHeritage(node, sourceKey) {
+    const clause = namedChildren(node).find(child => child.type === 'extends_type_clause');
+    if (clause === undefined)
+        return [];
+    return namedChildren(clause)
+        .filter(isHeritageName)
+        .map(target => ({ sourceKey, targetName: target.text, relation: 'extends' }));
+}
+/**
+ * Python `class_definition` base-class extraction from its `argument_list` child — shared with call
+ * argument syntax, so a `keyword_argument` (`metaclass=Meta`) is filtered out rather than treated as a
+ * base; Python draws no distinction between a base class and an interface, so every entry is `extends`.
+ * @param node - the `class_definition` node.
+ * @param sourceKey - the declaring class's own {@link RawDefinition.key}.
+ * @returns every heritage reference the class declares.
+ */
+function pythonClassHeritage(node, sourceKey) {
+    const args = namedChildren(node).find(child => child.type === 'argument_list');
+    if (args === undefined)
+        return [];
+    return namedChildren(args)
+        .filter(isHeritageName)
+        .map(target => ({ sourceKey, targetName: target.text, relation: 'extends' }));
+}
+/**
+ * Java `class_declaration`/`record_declaration` heritage extraction from their `superclass` (a record
+ * has none — a record can never extend another class, so the field is simply absent) and `interfaces`
+ * fields — both hold the clause node (`superclass`/`super_interfaces`) directly, one level above the
+ * `type_identifier`(s) themselves, verified against a real parse, not guessed.
+ * @param node - the `class_declaration`/`record_declaration` node.
+ * @param sourceKey - the declaring type's own {@link RawDefinition.key}.
+ * @returns every heritage reference the type declares.
+ */
+function javaClassHeritage(node, sourceKey) {
+    const refs = [];
+    const superclass = node.childForFieldName('superclass');
+    const target = superclass === null ? undefined : namedChildren(superclass)[0];
+    if (target !== undefined && isHeritageName(target))
+        refs.push({ sourceKey, targetName: target.text, relation: 'extends' });
+    const interfaces = node.childForFieldName('interfaces');
+    const typeList = interfaces === null ? undefined : namedChildren(interfaces)[0];
+    if (typeList !== undefined) {
+        for (const impl of namedChildren(typeList)) {
+            if (isHeritageName(impl))
+                refs.push({ sourceKey, targetName: impl.text, relation: 'implements' });
+        }
+    }
+    return refs;
+}
+/**
+ * Java `interface_declaration` `extends` extraction — an interface can extend more than one other
+ * interface (`interface C extends A, B {}`), from its `extends_interfaces` child; unlike
+ * `class_declaration`'s `superclass`/`interfaces` fields, `interface_declaration` binds no field name
+ * of its own to this clause, so it is found by node type instead, matching `ecmascriptClassHeritage`'s
+ * same fallback for plain JavaScript. Verified against a real parse, not guessed.
+ * @param node - the `interface_declaration` node.
+ * @param sourceKey - the declaring interface's own {@link RawDefinition.key}.
+ * @returns every heritage reference the interface declares.
+ */
+function javaInterfaceHeritage(node, sourceKey) {
+    const clause = namedChildren(node).find(child => child.type === 'extends_interfaces');
+    if (clause === undefined)
+        return [];
+    const typeList = namedChildren(clause)[0];
+    // `extends_interfaces` always wraps exactly one `type_list` per the grammar (an interface can never
+    // write a bare `extends` with nothing after it); the undefined case only satisfies the general
+    // array-access return type.
+    /* v8 ignore next */
+    if (typeList === undefined)
+        return [];
+    return namedChildren(typeList)
+        .filter(isHeritageName)
+        .map(target => ({ sourceKey, targetName: target.text, relation: 'extends' }));
+}
+/**
+ * C++/C# base-list heritage extraction, shared by both: neither C++'s `class_specifier`/`struct_specifier`
+ * nor C#'s `class_declaration`/`struct_declaration`/`record_declaration`/`interface_declaration` bind
+ * their base list to a dedicated field name — both are found by node type instead, matching
+ * `ecmascriptClassHeritage`'s same fallback for plain JavaScript. Neither grammar syntactically
+ * distinguishes an extended base class from an implemented interface in this list — the same ambiguity
+ * `pythonClassHeritage` already documents for Python's `argument_list` bases — so every entry reports
+ * `extends`, including when the declaring node is itself an interface extending another interface (C#'s
+ * `interface IBar : IFoo`), matching `javaInterfaceHeritage`/`tsInterfaceHeritage`'s existing convention
+ * for that shape. Verified against a real parse, not guessed.
+ * @param node - the declaring class/struct/interface/record node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @param clauseType - the base-list node's own type (`base_class_clause` for C++, `base_list` for C#).
+ * @returns every heritage reference the definition declares.
+ */
+function baseListHeritage(node, sourceKey, clauseType) {
+    const clause = namedChildren(node).find(child => child.type === clauseType);
+    if (clause === undefined)
+        return [];
+    return namedChildren(clause)
+        .filter(isHeritageName)
+        .map(target => ({ sourceKey, targetName: target.text, relation: 'extends' }));
+}
+/**
+ * PHP `class_declaration`/`interface_declaration`/`enum_declaration` heritage extraction. A class's
+ * single `extends` base sits in its own `base_clause` (PHP classes have no multiple inheritance); an
+ * interface's possibly-multiple `extends` bases reuse that same `base_clause` node type; a class's or
+ * enum's `implements` list sits in a `class_interface_clause` — neither clause binds to a field of its
+ * own, found by node type instead, matching `ecmascriptClassHeritage`'s same fallback for plain
+ * JavaScript. One function covers all three kinds since neither clause is exclusive to one of them (an
+ * interface never has a `class_interface_clause`, an enum never has a `base_clause`), so there is no
+ * ambiguity in reporting the relation `base_clause` → `extends` and `class_interface_clause` →
+ * `implements` regardless of which kind is declaring. A trait's `use` of another trait is not
+ * `extends`/`implements` shaped and is not reported here — see `extractHeritage`'s call site. Verified
+ * against a real parse, not guessed.
+ * @param node - the declaring class/interface/enum node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the definition declares.
+ */
+function phpHeritage(node, sourceKey) {
+    const refs = [];
+    const base = namedChildren(node).find(child => child.type === 'base_clause');
+    if (base !== undefined) {
+        for (const target of namedChildren(base)) {
+            if (isHeritageName(target))
+                refs.push({ sourceKey, targetName: target.text, relation: 'extends' });
+        }
+    }
+    const iface = namedChildren(node).find(child => child.type === 'class_interface_clause');
+    if (iface !== undefined) {
+        for (const target of namedChildren(iface)) {
+            if (isHeritageName(target))
+                refs.push({ sourceKey, targetName: target.text, relation: 'implements' });
+        }
+    }
+    return refs;
+}
+/**
+ * Ruby `class` superclass extraction from its `superclass` field (`class Dog < Animal`) — the field
+ * wraps the extended name directly, one level above the bare `constant`, the same shape C's
+ * `type_definition`'s `declarator` field wraps its target one level down. Ruby draws no
+ * `implements`-shaped distinction of its own (a mixin `include Module` is an ordinary method call,
+ * structurally indistinguishable from any other, so it is not extracted — the "don't guess" precedent
+ * `pythonClassHeritage` already documents for a comparable ambiguity), so every entry reports `extends`.
+ * Verified against a real parse, not guessed.
+ * @param node - the `class` node.
+ * @param sourceKey - the declaring class's own {@link RawDefinition.key}.
+ * @returns every heritage reference the class declares.
+ */
+function rubyClassHeritage(node, sourceKey) {
+    const superclass = node.childForFieldName('superclass');
+    const target = superclass === null ? undefined : namedChildren(superclass)[0];
+    if (target !== undefined && isHeritageName(target))
+        return [{ sourceKey, targetName: target.text, relation: 'extends' }];
+    return [];
+}
+/**
+ * Rust `trait_item` supertrait extraction from its `bounds` field (`trait Shape: Debug + Display {}`).
+ * Every supertrait requirement is reported as `extends`, matching `tsInterfaceHeritage`'s and
+ * `javaInterfaceHeritage`'s convention for a multi-base interface declaration; a `impl Trait for Type`
+ * block's own trait relationship is not extracted here or anywhere else in this package — unlike a
+ * class/struct/trait declaration, an `impl` block is never itself captured as a `RawDefinition` (it
+ * introduces no name of its own the seam's `container`/qualified-name scheme could attach to), so it has
+ * no {@link RawDefinition.key} to source a heritage reference from. Verified against a real parse, not
+ * guessed.
+ * @param node - the `trait_item` node.
+ * @param sourceKey - the declaring trait's own {@link RawDefinition.key}.
+ * @returns every heritage reference the trait declares.
+ */
+function rustTraitHeritage(node, sourceKey) {
+    const bounds = node.childForFieldName('bounds');
+    if (bounds === null)
+        return [];
+    return namedChildren(bounds)
+        .filter(isHeritageName)
+        .map(target => ({ sourceKey, targetName: target.text, relation: 'extends' }));
+}
+/**
+ * Scala `class_definition`/`object_definition`/`trait_definition` heritage extraction from an
+ * `extends_clause`'s `type` field — a single base (`extends Base`) is a bare `type_identifier`; one or
+ * more `with` mixins added to it (`extends Base with Shape with Other`) wrap all of them together in one
+ * `compound_type`, whose own `base` field names the first (the real superclass, reported `extends`) with
+ * every other named child being an additional mixin (reported `implements`, matching this package's
+ * class/interface-conflating-list precedent already documented for `pythonClassHeritage`/
+ * `baseListHeritage`). Verified against a real parse, not guessed.
+ * @param node - the declaring `class_definition`/`object_definition`/`trait_definition` node.
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @returns every heritage reference the declaration declares.
+ */
+function scalaHeritage(node, sourceKey) {
+    const extendsClause = node.childForFieldName('extend');
+    const type = extendsClause === null ? null : extendsClause.childForFieldName('type');
+    if (type === null)
+        return [];
+    if (type.type !== 'compound_type') {
+        return isHeritageName(type) ? [{ sourceKey, targetName: type.text, relation: 'extends' }] : [];
+    }
+    const base = type.childForFieldName('base');
+    const refs = [];
+    if (base !== null && isHeritageName(base))
+        refs.push({ sourceKey, targetName: base.text, relation: 'extends' });
+    for (const mixin of namedChildren(type)) {
+        if (base !== null && mixin.equals(base))
+            continue;
+        if (isHeritageName(mixin))
+            refs.push({ sourceKey, targetName: mixin.text, relation: 'implements' });
+    }
+    return refs;
+}
+/**
+ * Dispatch heritage extraction to the language family that owns a captured class, struct, or interface
+ * node's syntax. Go is absent: its interfaces are satisfied structurally, never declared at the
+ * implementing type, so there is no static reference here to extract.
+ * @param node - the captured `class`-, `struct`-, `interface`-, or `trait`-kind definition node.
+ * @param kind - the captured definition's seam kind (`'class'`, `'struct'`, `'interface'`, or `'trait'`).
+ * @param sourceKey - the declaring definition's own {@link RawDefinition.key}.
+ * @param language - the seam language label the file was parsed as.
+ * @returns every heritage reference the definition declares.
+ */
+function extractHeritage(node, kind, sourceKey, language) {
+    // `kind === 'trait'` only ever comes from Rust's `trait_item` rule or Scala's `trait_definition` rule
+    // — no other language in LANGUAGE_TABLE produces it.
+    if (kind === 'trait')
+        return language === 'scala' ? scalaHeritage(node, sourceKey) : rustTraitHeritage(node, sourceKey);
+    // `kind === 'interface'` only ever comes from TYPESCRIPT_DEFINITIONS's, Java's, or C#'s
+    // `interface_declaration` rule — no other language in LANGUAGE_TABLE produces it.
+    if (kind === 'interface') {
+        if (language === 'java')
+            return javaInterfaceHeritage(node, sourceKey);
+        if (language === 'csharp')
+            return baseListHeritage(node, sourceKey, 'base_list');
+        if (language === 'php')
+            return phpHeritage(node, sourceKey);
+        if (language === 'kotlin')
+            return kotlinHeritage(node, sourceKey);
+        if (language === 'swift')
+            return swiftHeritage(node, sourceKey);
+        return tsInterfaceHeritage(node, sourceKey);
+    }
+    // `kind === 'struct'` only ever comes from C/C++'s `struct_specifier`/`union_specifier`, C#'s
+    // `struct_declaration`, or Swift's own `class_declaration` (`declaration_kind` field `struct`) rule —
+    // a plain C struct/union has no base-list syntax at all, so `baseListHeritage` simply finds nothing to
+    // report for it.
+    if (kind === 'struct') {
+        if (language === 'swift')
+            return swiftHeritage(node, sourceKey);
+        return baseListHeritage(node, sourceKey, language === 'csharp' ? 'base_list' : 'base_class_clause');
+    }
+    // `kind === 'enum'` only ever comes from PHP's `enum_declaration` rule today — no other language's
+    // enum rule reaches this dispatch (TypeScript's/Java's/C#'s enum kinds carry no heritage syntax of
+    // their own this package extracts elsewhere), so every other language reports nothing here.
+    if (kind === 'enum')
+        return language === 'php' ? phpHeritage(node, sourceKey) : [];
+    if (kind !== 'class')
+        return [];
+    if (language === 'python')
+        return pythonClassHeritage(node, sourceKey);
+    // `kind === 'class'` from Java's `class_declaration`/`record_declaration` rules — see `javaClassHeritage`.
+    if (language === 'java')
+        return javaClassHeritage(node, sourceKey);
+    if (language === 'cpp')
+        return baseListHeritage(node, sourceKey, 'base_class_clause');
+    if (language === 'csharp')
+        return baseListHeritage(node, sourceKey, 'base_list');
+    if (language === 'php')
+        return phpHeritage(node, sourceKey);
+    if (language === 'ruby')
+        return rubyClassHeritage(node, sourceKey);
+    if (language === 'kotlin')
+        return kotlinHeritage(node, sourceKey);
+    if (language === 'swift')
+        return swiftHeritage(node, sourceKey);
+    if (language === 'dart')
+        return dartHeritage(node, sourceKey);
+    if (language === 'scala')
+        return scalaHeritage(node, sourceKey);
+    // Otherwise only comes from ECMASCRIPT_DEFINITIONS's `class_declaration` rule — Go has no class
+    // concept, so this is never reached with `language === 'go'`.
+    return ecmascriptClassHeritage(node, sourceKey);
+}
 /**
  * Extract every definition, call, and import from one parsed file.
  * @param tree - the file's parsed syntax tree.
@@ -184,12 +1620,34 @@ export function extractFile(tree, spec) {
     const definitions = [];
     const calls = [];
     const imports = [];
+    const heritage = [];
     const containerNames = [];
     const containerKeys = [null];
+    const commonJsExports = ECMASCRIPT_LANGUAGES.has(spec.language) ? commonJsExportedNames(tree.rootNode) : EMPTY_NAME_SET;
+    // Tracks whether the node currently being visited sits at module top level, directly inside a class
+    // body, or inside a function/method body — see `DefinitionRule.scopeRestricted` and
+    // `LanguageSpec.bareFunctionScopeTypes`.
+    const scopeKinds = ['module'];
     function visit(node) {
         const rule = matchDefinition(node, spec.definitions);
-        if (rule !== undefined) {
-            const nameNode = node.childForFieldName(rule.nameField);
+        // A `scopeRestricted` rule matched inside a function/method body is treated as no match at all —
+        // the node still gets visited below, just without becoming a definition or a container.
+        const captured = rule !== undefined
+            && (rule.scopeRestricted !== true || scopeKinds[scopeKinds.length - 1] !== 'other');
+        if (captured) {
+            // `matchDefinition` already confirmed `declaratorName`/`firstChildName` return non-`undefined` for
+            // this same node when `rule` matched; the assertions below only satisfy the ternary's
+            // `SyntaxNode | null` type, mirroring `node.childForFieldName`'s own return type — not a runtime
+            // branch, so nothing here needs a test of its own.
+            const nameNode = rule.nameField === SELF_NAME_FIELD ? node
+                : rule.nameField === DECLARATOR_NAME_FIELD ? declaratorName(node)
+                    : rule.nameField === FIRST_CHILD_NAME_FIELD ? firstChildName(node)
+                        : rule.nameField === PHP_ELEMENT_NAME_FIELD ? phpElementName(node)
+                            : rule.nameField === KOTLIN_NAME_FIELD ? kotlinDeclaredName(node)
+                                : rule.nameField === SWIFT_PROPERTY_NAME_FIELD ? swiftPropertyName(node)
+                                    : rule.nameField === SWIFT_FUNCTION_NAME_FIELD ? swiftFunctionName(node)
+                                        : rule.nameField === DART_FIELD_NAME_FIELD ? dartFieldName(node)
+                                            : node.childForFieldName(rule.nameField);
             // A matched rule's node type is always the NAMED-declaration form the grammar mandates a name
             // for; the anonymous form (`function_expression`, `class` as an expression, both produced by an
             // anonymous default export) parses as a different node type this rule never matches.
@@ -197,56 +1655,140 @@ export function extractFile(tree, spec) {
             if (nameNode !== null) {
                 const key = `${node.startPosition.row}:${node.startPosition.column}`;
                 const parentKey = containerKeys[containerKeys.length - 1] ?? null;
+                // Zig's own `variable_declaration` rule, Kotlin's own `class_declaration` rule, and Swift's own
+                // `class_declaration`/`property_declaration` rules each report one fixed placeholder kind in
+                // `LANGUAGE_TABLE` (no rule can vary `kind` by a value's shape or a keyword the way any of them
+                // needs) — the real kind is computed here instead, see
+                // `zigDeclarationKind`/`kotlinClassKind`/`swiftDeclarationKind`. Every other language's rule
+                // already carries the right kind.
+                const kind = spec.language === 'zig' && node.type === 'variable_declaration' ? zigDeclarationKind(node)
+                    : spec.language === 'kotlin' && node.type === 'class_declaration' ? kotlinClassKind(node)
+                        : spec.language === 'swift' && (node.type === 'class_declaration' || node.type === 'property_declaration') ? swiftDeclarationKind(node)
+                            : rule.kind;
+                if (spec.language === 'zig' && node.type === 'variable_declaration') {
+                    const zigImport = zigImportBinding(node, nameNode.text);
+                    if (zigImport !== undefined)
+                        imports.push(zigImport);
+                }
                 definitions.push({
                     key,
                     parentKey,
-                    kind: rule.kind,
+                    kind,
                     name: nameNode.text,
                     container: [...containerNames],
                     startLine: node.startPosition.row + 1,
                     endLine: node.endPosition.row + 1,
                     startColumn: node.startPosition.column,
                     endColumn: node.endPosition.column,
-                    isExported: isExported(node, spec.language, nameNode.text),
+                    isExported: isExported(node, spec.language, nameNode.text, commonJsExports),
                     isAsync: hasKeywordChild(node, 'async'),
-                    isStatic: hasKeywordChild(node, 'static'),
+                    // Java nests every modifier keyword one level down inside a `modifiers` node rather than as
+                    // a direct child of the declaration itself — see `javaHasModifier`. C/C++ wrap `static` in a
+                    // `storage_class_specifier` — see `cHasStorageClassKeyword`. C# gives each modifier its own
+                    // flat `modifier` node — see `csharpHasModifier`.
+                    isStatic: spec.language === 'java' ? javaHasModifier(node, 'static')
+                        : spec.language === 'c' || spec.language === 'cpp' ? cHasStorageClassKeyword(node, 'static')
+                            : spec.language === 'csharp' ? csharpHasModifier(node, 'static')
+                                : spec.language === 'php' ? phpHasStaticModifier(node)
+                                    : hasKeywordChild(node, 'static'),
+                    decorators: pythonDecorators(node, spec.language),
                 });
+                heritage.push(...extractHeritage(node, kind, key, spec.language));
                 containerNames.push(nameNode.text);
                 containerKeys.push(key);
+                // A C/C++/C# `struct` is scoped exactly like a `class` for this purpose — a `scopeRestricted`
+                // field rule must fire directly inside either body, not just a `class` one. Rust's `mod`
+                // (`namespace`) is scoped like the module top level it nests, not like a function body — a
+                // `scopeRestricted` `const`/`static` rule must still fire directly inside one.
+                scopeKinds.push(kind === 'class' || kind === 'struct' ? 'class' : kind === 'namespace' ? 'module' : 'other');
                 for (const child of namedChildren(node))
                     visit(child);
+                scopeKinds.pop();
                 containerKeys.pop();
                 containerNames.pop();
                 return;
             }
         }
         if (spec.callTypes.includes(node.type)) {
-            // Every call-shaped node type in every language table entry requires its callee field; the null
-            // case only satisfies `childForFieldName`'s general return type.
-            const callee = node.childForFieldName(spec.callFunctionField);
+            // Kotlin's and Swift's `call_expression` bind no field of their own at all — see `kotlinCallee`'s/
+            // `swiftCallee`'s doc comments — so this consults one of them directly instead of
+            // `node.childForFieldName`, which could never resolve anything for either grammar regardless of
+            // which field name `LanguageSpec.callFunctionField` names. Every call-shaped node type in every
+            // OTHER language table entry requires its callee field; the null case only satisfies
+            // `childForFieldName`'s general return type.
+            const calleeField = spec.callFunctionFieldByType?.[node.type] ?? spec.callFunctionField;
+            // `kotlinCallee`/`swiftCallee` are not known to return `undefined` for any real `call_expression`
+            // — every shape checked against a real parse (a bare call, a member call, a chained member call, a
+            // `super` receiver, a safe-nav/optional-chaining receiver, a call on a parenthesized or indexing
+            // expression) resolves to a node; the `?? null` fallback exists only to match
+            // `childForFieldName`'s `Node | null` shape for the other languages' branch below, not a case seen.
+            /* v8 ignore next 2 */
+            const callee = spec.language === 'kotlin' ? kotlinCallee(node) ?? null
+                : spec.language === 'swift' ? swiftCallee(node) ?? null
+                    : node.childForFieldName(calleeField);
             /* v8 ignore next */
             const name = callee === null ? undefined : calleeName(callee);
             if (name !== undefined) {
+                // `callee` is non-null whenever `name` is: the optional chaining only satisfies the type
+                // system's view of the field lookup above, not a real possibility here.
+                /* v8 ignore next */
+                // Kotlin's `kotlinCallee`/Swift's `swiftCallee` already unwrap a member call's receiver chain
+                // down to the same `simple_identifier` node type a bare call's callee is, so its own type alone
+                // can no longer distinguish the two for either language — a bare call's `call_expression` has
+                // that `simple_identifier` as its own first child directly, while a member call's has a
+                // `navigation_expression` there instead (see `kotlinCallee`/`swiftCallee`). Verified against a
+                // real parse, not guessed.
+                const isBareCallee = callee?.type === 'identifier' || callee?.type === 'name'
+                    || ((spec.language === 'kotlin' || spec.language === 'swift') && namedChildren(node)[0]?.type === 'simple_identifier');
                 calls.push({
                     callerKey: containerKeys[containerKeys.length - 1] ?? null,
                     calleeName: name,
                     line: node.startPosition.row + 1,
                     column: node.startPosition.column,
-                    // `callee` is non-null whenever `name` is: the optional chaining only satisfies the type
-                    // system's view of the field lookup above, not a real possibility here.
-                    /* v8 ignore next */
-                    isMemberCall: callee?.type !== 'identifier',
+                    // The `object` check covers Java's `method_invocation` and PHP's `member_call_expression`,
+                    // whose `name` field is always a bare identifier — the receiver, if any, sits in a separate
+                    // sibling field instead of wrapping the callee the way every other grammar's member expression
+                    // does. The `scope` check covers PHP's `scoped_call_expression` (`Class::method()`), whose
+                    // receiver sits in a sibling `scope` field instead of `object`; no other call-type node in
+                    // LANGUAGE_TABLE binds either field, so both are a no-op for every other language. Without
+                    // `isBareCallee` also accepting PHP's `'name'` type alongside `'identifier'`, every PHP call —
+                    // including an ordinary global `function_call_expression` — would be misclassified as
+                    // member-like, since PHP's bare-name node type is `name`, never `identifier`. The `receiver`
+                    // check covers Ruby's `call` node (`obj.method_name(x)`), whose callee is always a bare
+                    // `identifier` in its own `method` field regardless of receiver — unlike every other grammar's
+                    // member expression, the receiver sits in a distinct sibling field instead of wrapping the
+                    // callee; no other call-type node in LANGUAGE_TABLE binds a field named `receiver`. Verified
+                    // against a real parse, not guessed.
+                    isMemberCall: !isBareCallee || node.childForFieldName('object') !== null || node.childForFieldName('scope') !== null || node.childForFieldName('receiver') !== null,
                 });
             }
         }
         if (spec.importTypes.includes(node.type)) {
             imports.push(...extractImports(node, spec.language));
         }
+        if (node.type === 'call_expression' && ECMASCRIPT_LANGUAGES.has(spec.language)) {
+            const requireImport = commonJsRequireImport(node);
+            if (requireImport !== undefined)
+                imports.push(requireImport);
+        }
+        if (node.type === 'call' && spec.language === 'ruby') {
+            const requireImport = rubyRequireImport(node);
+            if (requireImport !== undefined)
+                imports.push(requireImport);
+        }
+        // A callback or IIFE's function value is never itself captured as a definition (only a *named*
+        // declaration, or one assigned through a captured `variable_declarator`, is) — but a `const`/`var`
+        // in its body is still function-local, so its scope must flip to `'other'` here regardless.
+        const entersBareFunctionScope = spec.bareFunctionScopeTypes.includes(node.type);
+        if (entersBareFunctionScope)
+            scopeKinds.push('other');
         for (const child of namedChildren(node))
             visit(child);
+        if (entersBareFunctionScope)
+            scopeKinds.pop();
     }
     visit(tree.rootNode);
-    return { definitions, calls, imports };
+    return { definitions, calls, imports, heritage };
 }
 /** Dispatch import extraction to the language family that owns `node`'s syntax. */
 function extractImports(node, language) {
@@ -260,27 +1802,172 @@ function extractImports(node, language) {
             return pythonImports(node);
         case 'go':
             return goImports(node);
+        case 'java':
+            return javaImports(node);
+        case 'c':
+        case 'cpp':
+            return cIncludeImports(node);
+        case 'csharp':
+            return csharpUsingImports(node);
+        case 'php':
+            return phpImports(node);
+        case 'rust':
+            return rustImports(node);
+        case 'kotlin':
+            return kotlinImports(node);
+        case 'swift':
+            return swiftImports(node);
+        case 'dart':
+            return dartImports(node);
+        case 'scala':
+            return scalaImports(node);
         /* v8 ignore next 2 -- exhaustive over LANGUAGE_TABLE's current language labels; unreachable. */
         default:
             return [];
     }
 }
+/** Whether `node` is the two-level `module.exports` member expression itself (not `module.exports.x`). */
+function isModuleExportsExpression(node) {
+    return node?.type === 'member_expression'
+        && node.childForFieldName('object')?.type === 'identifier'
+        && node.childForFieldName('object')?.text === 'module'
+        && node.childForFieldName('property')?.text === 'exports';
+}
+/**
+ * Every name a top-level CommonJS export assignment marks exported: `module.exports.NAME = ...` /
+ * `exports.NAME = ...` (named export), and `module.exports = NAME` (whole-module reassignment to a
+ * single local declaration). `module.exports = { a, b }` (object-literal reassignment) is not handled
+ * — distinguishing a shorthand property from a computed or renamed one adds a second layer of "don't
+ * guess" cases this pass does not need yet; only the two unambiguous forms above are recognized.
+ * Restricted to true top-level statements, matching this file's existing module/class-only scope
+ * restriction for a `scopeRestricted` `DefinitionRule` — a conditional or function-body export
+ * assignment is not a module's public surface in the same unconditional sense.
+ * @param root - the file's parsed root (`program`) node.
+ * @returns every name a CommonJS export assignment binds.
+ */
+function commonJsExportedNames(root) {
+    const names = new Set();
+    for (const statement of namedChildren(root)) {
+        if (statement.type !== 'expression_statement')
+            continue;
+        const expr = namedChildren(statement)[0];
+        if (expr?.type !== 'assignment_expression')
+            continue;
+        const left = expr.childForFieldName('left');
+        if (left?.type !== 'member_expression')
+            continue;
+        const object = left.childForFieldName('object');
+        const property = left.childForFieldName('property');
+        if (isModuleExportsExpression(object) || (object?.type === 'identifier' && object.text === 'exports')) {
+            // `property` is required by the grammar's `member_expression` rule; the null case only
+            // satisfies `childForFieldName`'s general return type.
+            /* v8 ignore next */
+            if (property !== null)
+                names.add(property.text);
+            continue;
+        }
+        if (isModuleExportsExpression(left)) {
+            const right = expr.childForFieldName('right');
+            if (right?.type === 'identifier')
+                names.add(right.text);
+        }
+    }
+    return names;
+}
 /**
  * Whether a declaration is exported from its module, by the export construct its own language
- * defines: ECMAScript wraps an exported statement in `export_statement`; Go's spec defines an
- * exported identifier as one starting with an uppercase letter, with no separate keyword; Python
- * defines no export construct at all, so every Python declaration reports `false` rather than guess
- * one from a naming convention or an `__all__` list the extractor does not read.
+ * defines: ECMAScript wraps an exported statement in `export_statement`, or — for CommonJS code, still
+ * common outside pure-ESM projects — is named by a top-level `module.exports`/`exports` assignment (see
+ * {@link commonJsExportedNames}); Go's spec defines an exported identifier as one starting with an
+ * uppercase letter, with no separate keyword; Java marks a declaration exported by an explicit
+ * `public` modifier (see {@link javaHasModifier}) — an interface member's implicit `public` with no
+ * keyword at all is not detected, matching this function's existing refusal to infer visibility from
+ * anything but an explicit language construct; C's is external vs. internal *linkage* — a top-level
+ * function or variable without `static` has external linkage (visible to other translation units), the
+ * same real-rule precedent Go's capitalization check follows rather than a guess; C++ inherits that same
+ * rule for its own free (non-member) functions and variables, but reports `false` for a class/struct
+ * member — a method or field has no comparable linkage concept of its own, and neither does any other
+ * kind (`struct`, `enum`, `type_alias`); C# marks a declaration exported by an explicit `public` modifier
+ * (see {@link csharpHasModifier}), mirroring Java; Python defines no export construct at all, so every
+ * Python declaration reports `false` rather than guess one from a naming convention or an `__all__` list
+ * the extractor does not read; Rust marks a declaration exported by an explicit bare `pub`
+ * `visibility_modifier` (see {@link rustIsPublic}) — a restricted `pub(crate)`/`pub(super)`/`pub(self)`
+ * does not count, mirroring Java's/C#'s explicit-`public`-only convention.
  * @param node - the definition node.
  * @param language - the seam language label the file was parsed as.
  * @param name - the declaration's simple name.
+ * @param commonJsExports - every name a CommonJS export assignment in this file binds.
  * @returns whether the language's own export rule marks this declaration exported.
  */
-function isExported(node, language, name) {
+function isExported(node, language, name, commonJsExports) {
     if (language === 'go')
         return /^\p{Lu}/u.test(name);
+    if (language === 'java')
+        return javaHasModifier(node, 'public');
+    if (language === 'csharp')
+        return csharpHasModifier(node, 'public');
+    if (language === 'c' || language === 'cpp') {
+        // A C++ method is a `function_definition` directly inside a class/struct's `field_declaration_list`
+        // — the same node type a free function uses, but with no linkage concept of its own to report.
+        if (node.type === 'function_definition')
+            return node.parent?.type !== 'field_declaration_list' && !cHasStorageClassKeyword(node, 'static');
+        // A top-level `declaration` (kind `variable`) is always module-scope — `scopeRestricted` already
+        // excludes the function-local case, so no further scope check is needed here.
+        if (node.type === 'declaration')
+            return !cHasStorageClassKeyword(node, 'static');
+        return false;
+    }
     if (language === 'python')
         return false;
+    // Ruby's `private`/`protected`/`public` are ordinary method calls that toggle visibility for
+    // subsequently defined methods, not a keyword on the declaration itself, and there is no separate
+    // module-level export construct at all — matching Python's precedent, every Ruby declaration reports
+    // `false` rather than guess one from tracking those calls' effect through the file.
+    if (language === 'ruby')
+        return false;
+    // Zig marks a declaration exported by an explicit bare `pub` keyword — a plain, always-anonymous
+    // token directly on the declaration itself, the same shape Rust's bare `pub` `visibility_modifier`
+    // has (see `rustIsPublic`), except Zig's grammar gives this token no named-child wrapper of its own
+    // to check `hasKeywordChild` still finds it. Verified against a real parse, not guessed.
+    if (language === 'zig')
+        return hasKeywordChild(node, 'pub');
+    // Kotlin's default visibility (no keyword at all) is already public — the inverse of every other
+    // language's "not exported unless an explicit keyword says so" convention — so this reports `true`
+    // unless an explicit `private`/`internal`/`protected` keyword (wrapped in the declaration's own
+    // `modifiers` node — see `kotlinHasVisibility`) narrows it. `protected` is treated as not exported:
+    // visible only to subclasses, not to an arbitrary importer, the same bar `internal`'s
+    // module-restricted visibility already fails to clear.
+    if (language === 'kotlin') {
+        return !kotlinHasVisibility(node, 'private') && !kotlinHasVisibility(node, 'internal') && !kotlinHasVisibility(node, 'protected');
+    }
+    // Swift's default visibility (no keyword at all) is `internal` — visible within the same module, but
+    // not to another module's importer — so unlike Kotlin's default-public convention, this reports `true`
+    // only for an explicit `public`/`open` keyword. Swift wraps its visibility keyword in the very same
+    // `modifiers` → `visibility_modifier` shape Kotlin's grammar does (verified against a real parse), so
+    // `kotlinHasVisibility` is reused directly rather than duplicated under a new name.
+    if (language === 'swift')
+        return kotlinHasVisibility(node, 'public') || kotlinHasVisibility(node, 'open');
+    // Dart has no visibility keyword at all — the language's own convention is a leading underscore
+    // marking a name library-private, matching Go's capitalization-based convention but spelled with a
+    // naming convention instead of a keyword.
+    if (language === 'dart')
+        return !name.startsWith('_');
+    // Scala's default visibility (no keyword at all) is already public, matching Kotlin's convention —
+    // this reports `true` unless an explicit `private`/`protected` keyword narrows it.
+    if (language === 'scala')
+        return !scalaHasModifier(node, 'private') && !scalaHasModifier(node, 'protected');
+    // A PHP top-level function/class/interface/trait/enum carries no visibility keyword of its own — the
+    // language has no export construct for them, matching Python's precedent, and this reports `false`
+    // for all of them since `phpHasVisibility` finds no `visibility_modifier` to check. A class/enum
+    // member (`const`/property/method) does carry one, mirroring Java's/C#'s explicit-`public`-only
+    // convention: an interface member's implicit `public` with no keyword at all is not detected either,
+    // the same refusal to infer visibility from anything but an explicit language construct.
+    if (language === 'php')
+        return phpHasVisibility(node, 'public');
+    if (language === 'rust')
+        return rustIsPublic(node);
+    if (commonJsExports.has(name))
+        return true;
     let current = node.parent;
     while (current !== null) {
         if (current.type === 'export_statement')