gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -3,6 +3,31 @@ import type { Capture, NodeLabel, Range } from '../../../_shared/index.js';
 import type { LanguageProvider } from '../language-provider.js';
 /** Tree-sitter AST node. Re-exported for use across ingestion modules. */
 export type SyntaxNode = Parser.SyntaxNode;
+/**
+ * Qualify a Rust inherent-impl target (`impl Inner { ... }`) by its enclosing
+ * `mod_item` scope, so a bare same-tail target nested under different modules
+ * resolves to a DISTINCT path (`outer.Inner` vs `other.Inner`) — the #1982
+ * follow-up to #1975. Walks `mod_item` ancestors (outermost → innermost) and
+ * joins them with the normalized raw target via the shared `splitQualifiedName`.
+ * A top-level `impl Inner` (no enclosing mod) returns the bare target unchanged.
+ * Keyed purely on tree-sitter node types (no language name), matching the
+ * inherent-impl branch in `findEnclosingClassInfo`; the caller restricts this to
+ * UNSCOPED targets (`type_identifier`) so a SCOPED `impl a::Inner` keeps its full
+ * raw text (#1975). The Impl-node materialization in parsing-processor /
+ * parse-worker mirrors this so the owner edge and node id agree byte-for-byte.
+ */
+export declare const qualifyRustImplTargetByModScope: (implNode: SyntaxNode, rawTargetText: string) => string;
+/**
+ * #1991: scope-label predicate that single-sources the `nodeLabel === 'Trait'`
+ * checks in parsing-processor.ts / parse-worker.ts. A Ruby `module` maps to the
+ * `Trait` registry label but is NOT a typeDeclaration, so `extractQualifiedName`
+ * bails on it; these node labels are instead qualified via the scope walk
+ * (`qualifyScopeName`) so same-tail nested modules get distinct ids. Keeping the
+ * literal in one place stops the four hand-maintained copies (two each in the
+ * sequential and worker definition paths) from drifting apart. Pure predicate —
+ * value-identical to the inlined `nodeLabel === 'Trait'`.
+ */
+export declare const isQualifiableScopeLabel: (nodeLabel: string) => boolean;
 /**
  * Ordered list of definition capture keys for tree-sitter query matches.
  * Used to extract the definition node from a capture map.
@@ -10,6 +35,14 @@ export type SyntaxNode = Parser.SyntaxNode;
 export declare const DEFINITION_CAPTURE_KEYS: readonly ["definition.function", "definition.class", "definition.interface", "definition.method", "definition.struct", "definition.enum", "definition.namespace", "definition.module", "definition.trait", "definition.impl", "definition.type", "definition.const", "definition.static", "definition.variable", "definition.typedef", "definition.macro", "definition.union", "definition.property", "definition.record", "definition.delegate", "definition.annotation", "definition.constructor", "definition.template"];
 /** Extract the definition node from a tree-sitter query capture map. */
 export declare const getDefinitionNodeFromCaptures: (captureMap: Record<string, SyntaxNode>) => SyntaxNode | null;
+type QueryMatchLike = {
+    captures: Array<{
+        name: string;
+        node: SyntaxNode;
+    }>;
+};
+export declare const buildConcreteTypedefDefinitionRanges: (matches: readonly QueryMatchLike[]) => Set<string>;
+export declare const isSuppressedConcreteTypedefDuplicate: (captureMap: Record<string, SyntaxNode>, concreteTypedefRanges: ReadonlySet<string>) => boolean;
 /**
  * Node types that represent function/method definitions across languages.
  * Used by parent-walk in call-processor, parse-worker, and type-env to detect
@@ -31,6 +64,21 @@ export declare const FUNCTION_NODE_TYPES: Set<string>;
  */
 export declare const CLASS_CONTAINER_TYPES: Set<string>;
 export declare const CONTAINER_TYPE_TO_LABEL: Record<string, string>;
+/**
+ * Pre-order walk over a node and all its named descendants, invoking `cb` on
+ * each. Replaces the per-language `visit`/`visitGo`/`visitRust`/`visitSwift`
+ * clones that every language's capture-synthesis walker re-implemented (#1956
+ * tri-review U6).
+ *
+ * Iterates by index with a null guard: `node.namedChild(i)` is typed
+ * `SyntaxNode | null`, and most callers already guarded it. The Go and C#
+ * callers previously iterated `node.namedChildren`; the Go one had no null
+ * guard, so this standardizes them onto the guarded indexed form — a deliberate,
+ * strictly-safer behavior addition (the traversal *sequence* is identical, so
+ * capture output stays byte-identical on well-formed trees; the guard only
+ * matters for a null named child, which the fixture corpus never produces).
+ */
+export declare function walkNamedTree(node: SyntaxNode, cb: (node: SyntaxNode) => void): void;
 /** Return the first matching ancestor unless a boundary ancestor is reached first. */
 export declare function findAncestorBeforeBoundary(node: SyntaxNode, targetTypes: ReadonlySet<string>, boundaryTypes: ReadonlySet<string>): SyntaxNode | null;
 /**
@@ -44,8 +92,27 @@ export declare function getLabelFromCaptures(captureMap: Record<string, SyntaxNo
 export interface EnclosingClassInfo {
     classId: string;
     className: string;
+    /**
+     * The owner node id keyed by the enclosing type's FULLY-QUALIFIED path
+     * (e.g. "Class:file:Outer.Inner"), present only when the language opts into
+     * `qualifiedNodeId` AND the enclosing type is actually nested (#1978).
+     * Consumers building HAS_METHOD/HAS_PROPERTY owner edges use this in
+     * preference to `classId` so the edge source matches the qualified class
+     * node id. When absent, `classId` (the simple-tail key) is unchanged.
+     */
+    qualifiedClassId?: string;
 }
-export declare const findEnclosingClassInfo: (node: SyntaxNode, filePath: string, resolveEnclosingOwner?: (node: SyntaxNode) => SyntaxNode | null) => EnclosingClassInfo | null;
+export declare const findEnclosingClassInfo: (node: SyntaxNode, filePath: string, resolveEnclosingOwner?: (node: SyntaxNode) => SyntaxNode | null, 
+/**
+ * Optional (#1978): returns the enclosing type's fully-qualified name
+ * (e.g. "Outer.Inner") for a type-declaration container, or null. Callers
+ * pass `classExtractor.extractQualifiedName` ONLY when the language's
+ * `qualifiedNodeId` flag is on — so when omitted, behavior is byte-identical
+ * to before (qualifiedClassId stays undefined). Used by the standard
+ * class-container branch to compute `qualifiedClassId` from the SAME function
+ * the node-id is built from, guaranteeing owner-id == node-id by construction.
+ */
+getQualifiedOwnerName?: (node: SyntaxNode, simpleName: string) => string | null) => EnclosingClassInfo | null;
 /** Object literal binding info for TS/JS shorthand methods. */
 export interface ObjectLiteralBindingInfo {
     ownerId: string;
@@ -106,6 +173,42 @@ export declare const CONSTRUCTOR_LABEL_NODE_TYPES: Set<string>;
 export declare const inferFunctionLabel: (nodeType: string) => NodeLabel;
 /** Argument list node types shared between countCallArguments and call-resolution helpers. */
 export declare const CALL_ARGUMENT_LIST_TYPES: Set<string>;
+/**
+ * Function/method parameter-list node types across grammars. Used to tell a
+ * PARAMETER-property (a constructor parameter that is also a class field, e.g.
+ * TypeScript `constructor(public name: string)`) apart from a function-BODY
+ * local: a property reached through one of these — rather than through the
+ * function's executable body — is a genuine class member, so the
+ * function-local-property guard must NOT strip its owner edge.
+ */
+export declare const PARAMETER_LIST_NODE_TYPES: Set<string>;
+/**
+ * Executable local-scope boundaries for the property-ownership guard
+ * (`isFunctionLocalProperty` in parse-worker.ts). A `Property` capture whose
+ * nearest enclosing scope — walking up before any class container — is one of
+ * these executable bodies is a function-local binding, NOT a class member, so it
+ * must not receive a class `HAS_PROPERTY` owner edge.
+ *
+ * Derived from FUNCTION_NODE_TYPES, with two deliberate adjustments found by the
+ * #1919 review of the original guard:
+ *  - EXCLUDES Dart's bare signature wrappers (`function_signature` /
+ *    `method_signature`). A Dart getter/setter NAME lives under `method_signature`,
+ *    yet it is a class-member declaration, not a local inside an executable body;
+ *    treating the signature as a scope boundary OVER-stripped every Dart class
+ *    accessor's owner edge. (Signatures are Dart-only; no language emits a
+ *    legitimately-function-local Property under one.)
+ *  - INCLUDES accessor + initializer bodies (Kotlin `anonymous_initializer` /
+ *    `getter` / `setter`, Swift `computed_property` / `computed_getter` /
+ *    `computed_setter` / `computed_modify`). Destructuring/locals inside these ARE
+ *    function-local, yet they are absent from FUNCTION_NODE_TYPES; omitting them
+ *    UNDER-stripped and emitted spurious class `HAS_PROPERTY` edges for
+ *    `init {}` / accessor-body destructuring bindings.
+ *
+ * Kept separate from FUNCTION_NODE_TYPES because that set has many other consumers
+ * (e.g. enclosing-callable resolution) where signatures must remain function nodes
+ * and accessor bodies must not.
+ */
+export declare const LOCAL_SCOPE_BODY_NODE_TYPES: ReadonlySet<string>;
 /** Walk an AST node depth-first, returning the first descendant with the given type. */
 export declare function findDescendant(root: SyntaxNode, type: string): SyntaxNode | null;
 /** Extract the text content from a string or encapsed_string AST node. */
@@ -130,3 +233,18 @@ export declare function syntheticCapture(name: string, atNode: SyntaxNode, text:
  *  row bounds — same optimization the prior recursive form used, minus
  *  the early-break since stack-push is cheap. */
 export declare function findNodeAtRange(root: SyntaxNode, range: Range, expectedType?: string): SyntaxNode | null;
+/**
+ * Return the captured node if its type is one of `types`, else null.
+ *
+ * The threaded-node equivalent of `findNodeAtRange(root, capture.range, type)`
+ * for the common case where a tree-sitter query already hands you the matched
+ * node (`c.node`): the captured node IS the node at that range, so a type check
+ * is exact and there is no need to re-walk from the tree root (the
+ * O(matches × rootChildren) hot path #1848 hit). Unlike `findNodeAtRange`, this
+ * does NOT traverse — the caller must already hold the node; for a multi-type
+ * call the node must literally be one of `types` (no fallback search).
+ *
+ * Used by every language's scope-capture path (go/python/ruby/php/rust/csharp).
+ */
+export declare function nodeIfType<T extends SyntaxNode>(node: T | undefined, ...types: readonly string[]): T | null;
+export {};

package/dist/core/ingestion/utils/ast-helpers.js

@@ -1,5 +1,44 @@
 import { generateId } from '../../../lib/utils.js';
 import { extractTemplateArguments, stripTemplateArguments, templateArgumentsIdTag, } from './template-arguments.js';
+import { splitQualifiedName } from './qualified-name.js';
+/**
+ * Qualify a Rust inherent-impl target (`impl Inner { ... }`) by its enclosing
+ * `mod_item` scope, so a bare same-tail target nested under different modules
+ * resolves to a DISTINCT path (`outer.Inner` vs `other.Inner`) — the #1982
+ * follow-up to #1975. Walks `mod_item` ancestors (outermost → innermost) and
+ * joins them with the normalized raw target via the shared `splitQualifiedName`.
+ * A top-level `impl Inner` (no enclosing mod) returns the bare target unchanged.
+ * Keyed purely on tree-sitter node types (no language name), matching the
+ * inherent-impl branch in `findEnclosingClassInfo`; the caller restricts this to
+ * UNSCOPED targets (`type_identifier`) so a SCOPED `impl a::Inner` keeps its full
+ * raw text (#1975). The Impl-node materialization in parsing-processor /
+ * parse-worker mirrors this so the owner edge and node id agree byte-for-byte.
+ */
+export const qualifyRustImplTargetByModScope = (implNode, rawTargetText) => {
+    const modSegments = [];
+    let current = implNode.parent;
+    while (current) {
+        if (current.type === 'mod_item') {
+            const nameNode = current.childForFieldName?.('name') ??
+                current.children?.find((c) => c.type === 'identifier');
+            if (nameNode)
+                modSegments.unshift(nameNode.text);
+        }
+        current = current.parent;
+    }
+    return [...modSegments, ...splitQualifiedName(rawTargetText)].filter(Boolean).join('.');
+};
+/**
+ * #1991: scope-label predicate that single-sources the `nodeLabel === 'Trait'`
+ * checks in parsing-processor.ts / parse-worker.ts. A Ruby `module` maps to the
+ * `Trait` registry label but is NOT a typeDeclaration, so `extractQualifiedName`
+ * bails on it; these node labels are instead qualified via the scope walk
+ * (`qualifyScopeName`) so same-tail nested modules get distinct ids. Keeping the
+ * literal in one place stops the four hand-maintained copies (two each in the
+ * sequential and worker definition paths) from drifting apart. Pure predicate —
+ * value-identical to the inlined `nodeLabel === 'Trait'`.
+ */
+export const isQualifiableScopeLabel = (nodeLabel) => nodeLabel === 'Trait';
 /**
  * Ordered list of definition capture keys for tree-sitter query matches.
  * Used to extract the definition node from a capture map.
@@ -37,6 +76,32 @@ export const getDefinitionNodeFromCaptures = (captureMap) => {
     }
     return null;
 };
+const nodeRangeKey = (node) => `${node.startPosition.row}:${node.startPosition.column}:${node.endPosition.row}:${node.endPosition.column}`;
+const isConcreteTypedefCapture = (captureMap) => {
+    const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+    return (definitionNode?.type === 'type_definition' &&
+        (captureMap['definition.struct'] !== undefined || captureMap['definition.enum'] !== undefined));
+};
+export const buildConcreteTypedefDefinitionRanges = (matches) => {
+    const ranges = new Set();
+    for (const match of matches) {
+        const captureMap = {};
+        for (const capture of match.captures) {
+            captureMap[capture.name] = capture.node;
+        }
+        const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+        if (definitionNode && isConcreteTypedefCapture(captureMap)) {
+            ranges.add(nodeRangeKey(definitionNode));
+        }
+    }
+    return ranges;
+};
+export const isSuppressedConcreteTypedefDuplicate = (captureMap, concreteTypedefRanges) => {
+    const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+    return (definitionNode?.type === 'type_definition' &&
+        captureMap['definition.typedef'] !== undefined &&
+        concreteTypedefRanges.has(nodeRangeKey(definitionNode)));
+};
 /**
  * Node types that represent function/method definitions across languages.
  * Used by parent-walk in call-processor, parse-worker, and type-env to detect
@@ -77,6 +142,7 @@ export const FUNCTION_NODE_TYPES = new Set([
     'anonymous_function',
     // Kotlin
     'lambda_literal',
+    'secondary_constructor', // F48: methodNodeTypes superset invariant
     // Swift
     'init_declaration',
     'deinit_declaration',
@@ -122,6 +188,9 @@ export const CLASS_CONTAINER_TYPES = new Set([
     // Kotlin
     'object_declaration',
     'companion_object',
+    // Go
+    'struct_type',
+    'interface_type',
 ]);
 export const CONTAINER_TYPE_TO_LABEL = {
     class_declaration: 'Class',
@@ -143,9 +212,9 @@ export const CONTAINER_TYPE_TO_LABEL = {
     extension_declaration: 'Extension',
     class: 'Class',
     // Ruby `module` declarations map to `Trait` so they participate in the
-    // class-like type registry used by `lookupClassByName` / `buildHeritageMap`.
-    // This lets `include` / `extend` / `prepend` mixin heritage resolve to
-    // the providing module. Safe for non-Ruby languages: the only supported
+    // class-like type registry used by `lookupClassByName` / inheritance
+    // resolution. This lets `include` / `extend` / `prepend` mixin heritage
+    // resolve to the providing module. Safe for non-Ruby languages: the only supported
     // grammar that uses the bare `module` AST node type as a container is
     // Ruby (Rust uses `mod_item`). Any new language adding a `module` node
     // type must explicitly reclassify here.
@@ -153,7 +222,31 @@ export const CONTAINER_TYPE_TO_LABEL = {
     singleton_class: 'Class', // Ruby: class << self inherits enclosing class name
     object_declaration: 'Class',
     companion_object: 'Class',
+    struct_type: 'Struct',
+    interface_type: 'Interface',
 };
+/**
+ * Pre-order walk over a node and all its named descendants, invoking `cb` on
+ * each. Replaces the per-language `visit`/`visitGo`/`visitRust`/`visitSwift`
+ * clones that every language's capture-synthesis walker re-implemented (#1956
+ * tri-review U6).
+ *
+ * Iterates by index with a null guard: `node.namedChild(i)` is typed
+ * `SyntaxNode | null`, and most callers already guarded it. The Go and C#
+ * callers previously iterated `node.namedChildren`; the Go one had no null
+ * guard, so this standardizes them onto the guarded indexed form — a deliberate,
+ * strictly-safer behavior addition (the traversal *sequence* is identical, so
+ * capture output stays byte-identical on well-formed trees; the guard only
+ * matters for a null named child, which the fixture corpus never produces).
+ */
+export function walkNamedTree(node, cb) {
+    cb(node);
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child !== null)
+            walkNamedTree(child, cb);
+    }
+}
 /** Return the first matching ancestor unless a boundary ancestor is reached first. */
 export function findAncestorBeforeBoundary(node, targetTypes, boundaryTypes) {
     let current = node.parent;
@@ -175,7 +268,9 @@ export function findAncestorBeforeBoundary(node, targetTypes, boundaryTypes) {
 export function getLabelFromCaptures(captureMap, provider) {
     if (captureMap['import'] || captureMap['call'])
         return null;
-    if (!captureMap['name'] && !captureMap['definition.constructor'])
+    const hasDefaultExportHocNameSeed = captureMap['definition.function'] !== undefined &&
+        (captureMap['hoc'] !== undefined || captureMap['callee'] !== undefined);
+    if (!captureMap['name'] && !captureMap['definition.constructor'] && !hasDefaultExportHocNameSeed)
         return null;
     if (captureMap['definition.function']) {
         if (provider.labelOverride) {
@@ -258,7 +353,17 @@ export function getLabelFromCaptures(captureMap, provider) {
  *    `MAX_ENCLOSING_WALK_ITERATIONS` defense-in-depth guard below prevents
  *    pathological hooks from creating an infinite loop. */
 const MAX_ENCLOSING_WALK_ITERATIONS = 4096;
-export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) => {
+export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, 
+/**
+ * Optional (#1978): returns the enclosing type's fully-qualified name
+ * (e.g. "Outer.Inner") for a type-declaration container, or null. Callers
+ * pass `classExtractor.extractQualifiedName` ONLY when the language's
+ * `qualifiedNodeId` flag is on — so when omitted, behavior is byte-identical
+ * to before (qualifiedClassId stays undefined). Used by the standard
+ * class-container branch to compute `qualifiedClassId` from the SAME function
+ * the node-id is built from, guaranteeing owner-id == node-id by construction.
+ */
+getQualifiedOwnerName) => {
     let current = node.parent;
     let iterations = 0;
     // Tracks container nodes already visited via the hook so a misbehaving hook
@@ -330,8 +435,8 @@ export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) =>
                 }
             }
             // Rust impl_item: for `impl Trait for Struct {}`, pick the type after `for`
-            // NOTE: This impl_item ownership logic is duplicated in rust.ts:extractOwnerName.
-            // If modifying this block, update the other location too.
+            // NOTE: This impl_item ownership logic is mirrored in
+            // method-extractors/configs/rust.ts (extractOwnerName, metadata only).
             if (current.type === 'impl_item') {
                 const children = current.children ?? [];
                 const forIdx = children.findIndex((c) => c.text === 'for');
@@ -342,18 +447,63 @@ export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) =>
                         c.type === 'scoped_type_identifier' ||
                         c.type === 'identifier');
                     if (nameNode) {
+                        // `for` target keeps its raw text. A scoped path (impl T for a::Inner)
+                        // therefore owns through `a::Inner`, which only resolves once the
+                        // referenced struct is keyed by its qualified path — deferred to #1978.
                         return {
                             classId: generateId('Struct', `${filePath}:${nameNode.text}`),
                             className: nameNode.text,
                         };
                     }
                 }
-                const firstType = children.find((c) => c.type === 'type_identifier');
-                if (firstType) {
-                    return {
-                        classId: generateId('Impl', `${filePath}:${firstType.text}`),
-                        className: firstType.text,
-                    };
+                // Inherent impl target.
+                //   - SCOPED (`impl a::Inner`, scoped_type_identifier): key by FULL text,
+                //     matching the @definition.impl scoped arm (#1975). UNCHANGED.
+                //   - UNSCOPED (`impl Inner`, type_identifier): qualify by the enclosing
+                //     `mod_item` scope (`outer.Inner`) so two same-tail bare impls under
+                //     different mods own through DISTINCT nodes. The Impl-node
+                //     materialization (parsing-processor / parse-worker) mirrors this, so
+                //     the owner id == the Impl node id byte-for-byte (#1982).
+                //   - GENERIC (`impl<T> Inner<T>`, generic_type): the @definition.impl
+                //     node is materialized only when the generic base is a bare
+                //     `type_identifier` (tree-sitter-queries.ts), qualified the same way —
+                //     so drill into the base and mirror that gate, keeping the owner id ==
+                //     the node id byte-for-byte (#1992). A generic over a SCOPED base
+                //     (`impl<T> a::Inner<T>`) materializes NO node, so it must produce NO
+                //     owner (the method orphans — scoped-generic deferred, #1992).
+                const implTarget = children.find((c) => c.type === 'type_identifier' ||
+                    c.type === 'scoped_type_identifier' ||
+                    c.type === 'generic_type');
+                if (implTarget) {
+                    const baseType = implTarget.type === 'generic_type'
+                        ? (implTarget.childForFieldName?.('type') ?? null)
+                        : implTarget;
+                    if (baseType?.type === 'type_identifier') {
+                        // Bare target (`impl Inner` or `impl<T> Inner<T>`): qualify by mod scope.
+                        // #1992 follow-up: qualify `className` too (not just `classId`). The
+                        // method node id is keyed `${className}.${name}`, so a bare tail collapses
+                        // two same-tail bare impls that ALSO share a method name (`a::Inner::m` +
+                        // `b::Inner::m` both → `Inner.m`) onto one Method node (graph addNode is
+                        // first-write-wins). Qualifying className → `a.Inner.m` / `b.Inner.m` keeps
+                        // them distinct. Symmetric: the call-resolution fallback rebuilds the same
+                        // `${className}.${name}` from the same enclosing-impl walk, so def and call
+                        // ids still agree. Owner edge anchors on `classId` (already qualified).
+                        const qualified = qualifyRustImplTargetByModScope(current, baseType.text);
+                        return {
+                            classId: generateId('Impl', `${filePath}:${qualified}`),
+                            className: qualified,
+                        };
+                    }
+                    if (baseType?.type === 'scoped_type_identifier' && implTarget.type !== 'generic_type') {
+                        // Top-level scoped `impl a::Inner`: key by full raw text (#1975).
+                        return {
+                            classId: generateId('Impl', `${filePath}:${baseType.text}`),
+                            className: baseType.text,
+                        };
+                    }
+                    // generic-over-scoped (`impl<T> a::Inner<T>`) and any other base: fall
+                    // through with no owner — no @definition.impl node exists, so attributing
+                    // a method to a synthesized id would orphan it against a phantom owner.
                 }
             }
             const nameNode = current.childForFieldName?.('name') ??
@@ -371,13 +521,42 @@ export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) =>
                     current.children?.some((c) => c.type === 'interface')) {
                     label = 'Interface';
                 }
+                // class_declaration with a `declaration_kind` field collapses several
+                // type kinds onto one node (tree-sitter-swift: class / struct / enum /
+                // extension / actor). The structure query labels struct → Struct and
+                // enum → Enum; refine the owner label to match so a member edge
+                // (HAS_METHOD / HAS_PROPERTY) anchors on the real Enum/Struct node id
+                // rather than a non-existent `Class:` id (F79). Gated on the field
+                // being present, so it is a no-op for grammars whose class_declaration
+                // has no `declaration_kind` field (e.g. Kotlin).
+                if (current.type === 'class_declaration' && label === 'Class') {
+                    const declKind = current.childForFieldName?.('declaration_kind')?.text;
+                    if (declKind === 'struct')
+                        label = 'Struct';
+                    else if (declKind === 'enum')
+                        label = 'Enum';
+                }
                 const templateArguments = extractTemplateArguments(nameNode.text);
                 const classIdName = templateArguments !== undefined
                     ? `${stripTemplateArguments(nameNode.text)}${templateArgumentsIdTag(templateArguments)}`
                     : nameNode.text;
+                // #1978: when the language opts into qualified node ids, key the owner
+                // edge by the enclosing type's qualified path (e.g. "Outer.Inner") so it
+                // matches the qualified class node id. Derived from the SAME
+                // extractQualifiedName the node-id uses → agree by construction. Only set
+                // when actually nested (qualified !== simple); top-level types are
+                // unchanged. (Go receiver / Rust impl branches return earlier and are
+                // intentionally untouched here.)
+                const qualifiedOwnerName = getQualifiedOwnerName?.(current, nameNode.text);
+                const qualifiedClassId = qualifiedOwnerName != null && qualifiedOwnerName !== nameNode.text
+                    ? generateId(label, `${filePath}:${templateArguments !== undefined
+                        ? `${stripTemplateArguments(qualifiedOwnerName)}${templateArgumentsIdTag(templateArguments)}`
+                        : qualifiedOwnerName}`)
+                    : undefined;
                 return {
                     classId: generateId(label, `${filePath}:${classIdName}`),
                     className: nameNode.text,
+                    ...(qualifiedClassId !== undefined ? { qualifiedClassId } : {}),
                 };
             }
         }
@@ -555,6 +734,58 @@ export const inferFunctionLabel = (nodeType) => METHOD_LABEL_NODE_TYPES.has(node
         : 'Function';
 /** Argument list node types shared between countCallArguments and call-resolution helpers. */
 export const CALL_ARGUMENT_LIST_TYPES = new Set(['arguments', 'argument_list', 'value_arguments']);
+/**
+ * Function/method parameter-list node types across grammars. Used to tell a
+ * PARAMETER-property (a constructor parameter that is also a class field, e.g.
+ * TypeScript `constructor(public name: string)`) apart from a function-BODY
+ * local: a property reached through one of these — rather than through the
+ * function's executable body — is a genuine class member, so the
+ * function-local-property guard must NOT strip its owner edge.
+ */
+export const PARAMETER_LIST_NODE_TYPES = new Set([
+    'formal_parameters', // TypeScript / JavaScript
+    'parameters', // Python / C#
+    'parameter_list', // Java / Go / C / Swift
+    'function_value_parameters', // Kotlin
+    'class_parameters', // Scala-like / future grammars
+]);
+/**
+ * Executable local-scope boundaries for the property-ownership guard
+ * (`isFunctionLocalProperty` in parse-worker.ts). A `Property` capture whose
+ * nearest enclosing scope — walking up before any class container — is one of
+ * these executable bodies is a function-local binding, NOT a class member, so it
+ * must not receive a class `HAS_PROPERTY` owner edge.
+ *
+ * Derived from FUNCTION_NODE_TYPES, with two deliberate adjustments found by the
+ * #1919 review of the original guard:
+ *  - EXCLUDES Dart's bare signature wrappers (`function_signature` /
+ *    `method_signature`). A Dart getter/setter NAME lives under `method_signature`,
+ *    yet it is a class-member declaration, not a local inside an executable body;
+ *    treating the signature as a scope boundary OVER-stripped every Dart class
+ *    accessor's owner edge. (Signatures are Dart-only; no language emits a
+ *    legitimately-function-local Property under one.)
+ *  - INCLUDES accessor + initializer bodies (Kotlin `anonymous_initializer` /
+ *    `getter` / `setter`, Swift `computed_property` / `computed_getter` /
+ *    `computed_setter` / `computed_modify`). Destructuring/locals inside these ARE
+ *    function-local, yet they are absent from FUNCTION_NODE_TYPES; omitting them
+ *    UNDER-stripped and emitted spurious class `HAS_PROPERTY` edges for
+ *    `init {}` / accessor-body destructuring bindings.
+ *
+ * Kept separate from FUNCTION_NODE_TYPES because that set has many other consumers
+ * (e.g. enclosing-callable resolution) where signatures must remain function nodes
+ * and accessor bodies must not.
+ */
+export const LOCAL_SCOPE_BODY_NODE_TYPES = new Set([...FUNCTION_NODE_TYPES]
+    .filter((t) => t !== 'function_signature' && t !== 'method_signature')
+    .concat([
+    'anonymous_initializer', // Kotlin: init { }
+    'getter', // Kotlin: val x get() { }
+    'setter', // Kotlin: var x set(v) { }
+    'computed_property', // Swift: var x: T { get set }
+    'computed_getter', // Swift: get { }
+    'computed_setter', // Swift: set { }
+    'computed_modify', // Swift: _modify { }
+]));
 // ============================================================================
 // Generic AST traversal helpers (shared by parse-worker + php-helpers)
 // ============================================================================
@@ -663,3 +894,19 @@ export function findNodeAtRange(root, range, expectedType) {
     }
     return null;
 }
+/**
+ * Return the captured node if its type is one of `types`, else null.
+ *
+ * The threaded-node equivalent of `findNodeAtRange(root, capture.range, type)`
+ * for the common case where a tree-sitter query already hands you the matched
+ * node (`c.node`): the captured node IS the node at that range, so a type check
+ * is exact and there is no need to re-walk from the tree root (the
+ * O(matches × rootChildren) hot path #1848 hit). Unlike `findNodeAtRange`, this
+ * does NOT traverse — the caller must already hold the node; for a multi-type
+ * call the node must literally be one of `types` (no fallback search).
+ *
+ * Used by every language's scope-capture path (go/python/ruby/php/rust/csharp).
+ */
+export function nodeIfType(node, ...types) {
+    return node !== undefined && types.includes(node.type) ? node : null;
+}

package/dist/core/ingestion/utils/callable-labels.d.ts

@@ -0,0 +1,13 @@
+import type { NodeLabel } from '../../../_shared/index.js';
+/**
+ * Callables whose same-name overloads occupy distinct graph nodes keyed by
+ * parameter types / shape. Shared by graph-bridge registration (`node-lookup.ts`)
+ * and resolution (`ids.ts`) so overload keys stay aligned.
+ *
+ * Constructors belong here: a class with `Foo()` and `Foo(int)` mints distinct
+ * `#0`/`#1` Constructor nodes, and a `: this(...)` / `: base(...)` (C#),
+ * `this(...)`/`super(...)` (Java), or `new Foo(args)` edge must reach the
+ * right overload — otherwise both ctor nodes collapse onto the first-wins
+ * qualified/simple key and a ctor chain becomes a self-loop (#1928 F38 / #2046).
+ */
+export declare function isOverloadableCallable(label: NodeLabel | undefined): boolean;

package/dist/core/ingestion/utils/callable-labels.js

@@ -0,0 +1,14 @@
+/**
+ * Callables whose same-name overloads occupy distinct graph nodes keyed by
+ * parameter types / shape. Shared by graph-bridge registration (`node-lookup.ts`)
+ * and resolution (`ids.ts`) so overload keys stay aligned.
+ *
+ * Constructors belong here: a class with `Foo()` and `Foo(int)` mints distinct
+ * `#0`/`#1` Constructor nodes, and a `: this(...)` / `: base(...)` (C#),
+ * `this(...)`/`super(...)` (Java), or `new Foo(args)` edge must reach the
+ * right overload — otherwise both ctor nodes collapse onto the first-wins
+ * qualified/simple key and a ctor chain becomes a self-loop (#1928 F38 / #2046).
+ */
+export function isOverloadableCallable(label) {
+    return label === 'Function' || label === 'Method' || label === 'Constructor';
+}

package/dist/core/ingestion/utils/deferred-resolution-profile.d.ts

@@ -10,12 +10,22 @@
  * because the UI progress bar updates every 100 files and intermediate
  * stages emit little to the log.
  */
+/** Min wall-clock gap between always-on slow-file warnings (throttle). */
+export declare const ALWAYS_ON_SLOW_FILE_WARN_THROTTLE_MS = 30000;
 /** True when deferred-stage timing / progress logs should emit. */
 export declare const isDeferredResolutionProfileEnabled: () => boolean;
 /** Log a call-resolution progress line every N files (finer when verbose). */
 export declare const deferredCallLogEveryN: () => number;
 /** Per-file call-resolution log threshold (ms). Lower default when verbose. */
 export declare const deferredCallFileSlowMs: () => number;
+/**
+ * Always-on per-file slow threshold (ms) for the `logger.warn` watchdog in
+ * `processCallsFromExtracted`. Unlike {@link deferredCallFileSlowMs} this is
+ * NOT gated on verbose/profile — it fires on every run. `0` (or a negative /
+ * non-finite override) disables the watchdog entirely. Override via
+ * `GITNEXUS_SLOW_FILE_WARN_MS`.
+ */
+export declare const alwaysOnSlowFileWarnMs: () => number;
 export declare const profileNow: () => bigint;
 export declare const profileElapsedMs: (start: bigint) => number;
 /**

package/dist/core/ingestion/utils/deferred-resolution-profile.js

@@ -19,6 +19,19 @@ const LOG_EVERY_N_VERBOSE = 10;
 const LOG_EVERY_N_PROFILE = 100;
 const DEFAULT_SLOW_MS_VERBOSE = 3_000;
 const DEFAULT_SLOW_MS = 5_000;
+/**
+ * Always-on (NOT gated on verbose/profile) threshold above which a single
+ * file's deferred call resolution earns a `logger.warn`. The verbose
+ * slow-file profile (above) only fires with `-v`/`GITNEXUS_PROFILE_DEFERRED`;
+ * a plain `analyze` run that hangs in "Resolving calls" (the #1741 symptom)
+ * gives the user a frozen progress bar and nothing in the log. This higher
+ * default (15s — never hit by a healthy file) turns that silence into one
+ * actionable line naming the expensive file. Override via
+ * `GITNEXUS_SLOW_FILE_WARN_MS`; the throttle in the caller bounds volume.
+ */
+const DEFAULT_ALWAYS_ON_SLOW_FILE_WARN_MS = 15_000;
+/** Min wall-clock gap between always-on slow-file warnings (throttle). */
+export const ALWAYS_ON_SLOW_FILE_WARN_THROTTLE_MS = 30_000;
 /** True when deferred-stage timing / progress logs should emit. */
 export const isDeferredResolutionProfileEnabled = () => isVerboseIngestionEnabled() || parseTruthyEnv(process.env.GITNEXUS_PROFILE_DEFERRED);
 /** Log a call-resolution progress line every N files (finer when verbose). */
@@ -35,6 +48,23 @@ export const deferredCallFileSlowMs = () => {
     }
     return isVerboseIngestionEnabled() ? DEFAULT_SLOW_MS_VERBOSE : DEFAULT_SLOW_MS;
 };
+/**
+ * Always-on per-file slow threshold (ms) for the `logger.warn` watchdog in
+ * `processCallsFromExtracted`. Unlike {@link deferredCallFileSlowMs} this is
+ * NOT gated on verbose/profile — it fires on every run. `0` (or a negative /
+ * non-finite override) disables the watchdog entirely. Override via
+ * `GITNEXUS_SLOW_FILE_WARN_MS`.
+ */
+export const alwaysOnSlowFileWarnMs = () => {
+    const raw = process.env.GITNEXUS_SLOW_FILE_WARN_MS;
+    if (raw !== undefined) {
+        const n = Number(raw);
+        // 0 / negative / NaN → disabled. Use Number() not parseInt (see
+        // deferredCallFileSlowMs for the '1e9' prefix-parse hazard).
+        return Number.isFinite(n) && n > 0 ? n : 0;
+    }
+    return DEFAULT_ALWAYS_ON_SLOW_FILE_WARN_MS;
+};
 export const profileNow = () => process.hrtime.bigint();
 export const profileElapsedMs = (start) => Number(process.hrtime.bigint() - start) / 1e6;
 // Module-private counter for `[deferred-profile]` log lines the underlying

package/dist/core/ingestion/utils/heap-probe.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Synchronous heap probes for large-repo OOM investigation (#1983).
+ *
+ * Writes to stderr (not pino) so lines flush under CI=1 / gdb attach.
+ * Enabled with `GITNEXUS_DEBUG_HEAP=1` or `GITNEXUS_PROFILE_DEFERRED=1`.
+ */
+export declare const isDebugHeapEnabled: () => boolean;
+export declare const heapUsedMb: () => number;
+/**
+ * Flush a one-line heap snapshot to stderr.
+ *
+ * stderr is async on a pipe (Linux), so a probe written just before an
+ * OOM-kill is lost in the pipe buffer. For OOM investigation set
+ * `GITNEXUS_HEAP_PROBE_FILE=/path` — each probe is then ALSO appended to
+ * that file with a synchronous `appendFileSync`, whose `write(2)` syscall
+ * completes (data handed to the kernel) before the call returns, so the
+ * last line survives SIGKILL. Includes rss alongside heapUsed so the
+ * native/off-heap gap is visible.
+ */
+export declare const logHeapProbe: (label: string, detail?: string) => void;