gitnexus 1.6.10-rc.221 → 1.6.10-rc.223

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.js

@@ -17,7 +17,7 @@
  * migrate.
  */
 import { generateId } from '../../../../lib/utils.js';
-import { AMBIGUOUS_POSITION, localNameKey, positionKey, qualifiedKey, simpleKey, } from '../graph-bridge/node-lookup.js';
+import { AMBIGUOUS_POSITION, exactPositionKey, localNameKey, positionKey, qualifiedKey, simpleKey, } from '../graph-bridge/node-lookup.js';
 import { isOverloadableCallable, isPositionQualifiedLocalLabel, } from '../../utils/callable-labels.js';
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
 import { parameterShapeIdTag } from '../../utils/method-props.js';
@@ -143,13 +143,6 @@ function pickCallerCallableDef(scope, scopes, atRange) {
  * resolution working for languages that don't yet synthesize
  * qualifiers).
  */
-/**
- * Extract the 1-based declaration line from a scope-resolution def id.
- * Shape: `def:<filePath>#<line>:<col>:<...>`; `undefined` when it doesn't match.
- */
-function defStartLine(nodeId, filePath) {
-    return definitionIdPosition(nodeId, filePath)?.line;
-}
 /**
  * Trailing segment of a dotted qualified name (`Outer.inner` -> `inner`),
  * with any function-local `@line:col` identity suffix stripped
@@ -214,9 +207,21 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
         // AST nodes (outer wrapper vs inner callable), but the graph node's
         // `startLine` follows the initializer (#2735) so this join matches even
         // when the binding is split across lines.
-        const line = defStartLine(def.nodeId, filePath);
+        const definitionPosition = definitionIdPosition(def.nodeId, filePath);
+        const line = definitionPosition?.line;
         if (line !== undefined && isPositionQualifiedLocalLabel(def.type)) {
             const simple = simpleNameOf(qn);
+            if (definitionPosition !== undefined) {
+                const exactHit = nodeLookup.get(exactPositionKey(filePath, def.type, definitionPosition.line - 1, definitionPosition.column));
+                if (exactHit !== undefined && exactHit !== AMBIGUOUS_POSITION)
+                    return exactHit;
+                if (exactHit === undefined && siblingLabel !== undefined) {
+                    const siblingExactHit = nodeLookup.get(exactPositionKey(filePath, siblingLabel, definitionPosition.line - 1, definitionPosition.column));
+                    if (siblingExactHit !== undefined && siblingExactHit !== AMBIGUOUS_POSITION) {
+                        return siblingExactHit;
+                    }
+                }
+            }
             const posHit = nodeLookup.get(positionKey(filePath, def.type, line - 1, simple));
             if (posHit !== undefined && posHit !== AMBIGUOUS_POSITION)
                 return posHit;

package/dist/core/ingestion/scope-resolution/graph-bridge/node-lookup.d.ts

@@ -51,6 +51,8 @@ export declare function simpleKey(filePath: string, name: string): string;
  * name-based keys rather than picking by source order.
  */
 export declare function positionKey(filePath: string, label: NodeLabel, startLine: number, name: string): string;
+/** Exact source-position key used before the legacy line/name join. */
+export declare function exactPositionKey(filePath: string, label: NodeLabel, startLine: number, startColumn: number): string;
 /**
  * Key recording that a FUNCTION-LOCAL callable with this simple name exists in the
  * file (#2699 follow-up).

package/dist/core/ingestion/scope-resolution/graph-bridge/node-lookup.js

@@ -79,6 +79,10 @@ export function simpleKey(filePath, name) {
 export function positionKey(filePath, label, startLine, name) {
     return `<p>:${filePath}::${label}::${startLine}::${name}`;
 }
+/** Exact source-position key used before the legacy line/name join. */
+export function exactPositionKey(filePath, label, startLine, startColumn) {
+    return `<pc>:${filePath}::${label}::${startLine}:${startColumn}`;
+}
 /**
  * Key recording that a FUNCTION-LOCAL callable with this simple name exists in the
  * file (#2699 follow-up).
@@ -116,6 +120,10 @@ export function buildGraphNodeLookup(graph) {
         // ambiguous rather than letting source order decide.
         const startLine = props.startLine;
         if (startLine !== undefined && isPositionQualifiedLocalLabel(node.label)) {
+            if (props.startColumn !== undefined) {
+                const exactK = exactPositionKey(props.filePath, node.label, startLine, props.startColumn);
+                lookup.set(exactK, lookup.has(exactK) ? AMBIGUOUS_POSITION : node.id);
+            }
             const posK = positionKey(props.filePath, node.label, startLine, props.name);
             lookup.set(posK, lookup.has(posK) ? AMBIGUOUS_POSITION : node.id);
             // A local-identity node carries `@<row>:<col>` on its last name segment. Record

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

@@ -294,6 +294,16 @@ export interface ObjectLiteralBindingInfo {
      */
     ownerName?: string;
 }
+/**
+ * True when an object-literal member is contained by an array before reaching
+ * another callable or class boundary.
+ *
+ * An array does not provide a stable named owner for its elements, so members
+ * below one cannot use `<binding>.<member>` identity or ownership. They still
+ * need distinct graph identities, however; callers use this predicate to opt
+ * into source-position qualification while keeping ownership suppressed.
+ */
+export declare const isArrayContainedObjectLiteralMember: (node: SyntaxNode) => boolean;
 /**
  * Find the file-scope variable that owns an object literal method definition.
  *

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

@@ -980,6 +980,31 @@ getQualifiedOwnerName) => {
     }
     return null;
 };
+/**
+ * True when an object-literal member is contained by an array before reaching
+ * another callable or class boundary.
+ *
+ * An array does not provide a stable named owner for its elements, so members
+ * below one cannot use `<binding>.<member>` identity or ownership. They still
+ * need distinct graph identities, however; callers use this predicate to opt
+ * into source-position qualification while keeping ownership suppressed.
+ */
+export const isArrayContainedObjectLiteralMember = (node) => {
+    let current = node;
+    let sawObject = false;
+    while (current) {
+        if (current.type === 'object')
+            sawObject = true;
+        if (current.type === 'array' && sawObject)
+            return true;
+        if (current !== node &&
+            (FUNCTION_NODE_TYPES.has(current.type) || CLASS_CONTAINER_TYPES.has(current.type))) {
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+};
 /**
  * Block-statement AST types that disqualify an object-literal binding from
  * carrying a HAS_METHOD edge. A `const` declared inside one of these is block-
@@ -1119,6 +1144,12 @@ export const findObjectLiteralBindingInfo = (node, filePath, options) => {
         if (current.type === 'object') {
             objectDepth += 1;
         }
+        if (current !== node && current.type === 'array') {
+            // `const handlers = [{ run() {} }]` has no `handlers.run` member.
+            // Crossing the array would mint a confident but false owner edge; keep
+            // the existing conservative under-approximation used for nested objects.
+            return null;
+        }
         if (current.type === 'variable_declarator' && objectDepth >= 1) {
             if (objectDepth > 1) {
                 // Method belongs to a nested object literal; safe under-approximation.

package/dist/core/ingestion/workers/callable-id.d.ts

@@ -21,12 +21,12 @@
 import type { NodeLabel, SymbolDefinition } from '../../../_shared/index.js';
 import type { SyntaxNode } from '../utils/ast-helpers.js';
 /**
- * Zero-based start row that keys the graph-to-scope position join for a bound
- * callable (#2735).
+ * Zero-based start position that keys the graph-to-scope join for a bound
+ * callable (#2735/#3041).
  *
  * Graph-node queries may anchor on an outer binding wrapper while the scope
- * channel anchors on the inner callable. The join is line-only, so a multi-line
- * binding needs the graph node's `startLine` to follow the semantic definition.
+ * channel anchors on the inner callable. A bound graph node therefore follows
+ * the semantic definition's line and column rather than the outer wrapper.
  *
  * `ParsedFile.localDefs` is the language-agnostic source of that position.
  * Matching uses only the canonical label, name, and source range; shared worker
@@ -36,6 +36,10 @@ import type { SyntaxNode } from '../utils/ast-helpers.js';
  * Missing or ambiguous semantic matches retain the wrapper row, preserving the
  * existing fail-closed behavior.
  */
+export declare function boundCallableStartPosition(definitionNode: SyntaxNode, nodeName: string, nodeLabel: NodeLabel, localDefs: readonly SymbolDefinition[] | undefined, nameNode?: SyntaxNode | null): {
+    readonly row: number;
+    readonly column: number;
+};
 export declare function boundCallableStartRow(definitionNode: SyntaxNode, nodeName: string, nodeLabel: NodeLabel, localDefs: readonly SymbolDefinition[] | undefined, nameNode?: SyntaxNode | null): number;
 /**
  * A function-local callable's own name segment: its name plus its declaration
@@ -60,6 +64,10 @@ export declare function boundCallableStartRow(definitionNode: SyntaxNode, nodeNa
  * bare/class-qualified ids, which is what keeps this off the symbols other
  * files, saved queries and stored references actually address.
  */
+export declare const positionQualifiedCallableName: (name: string, position: {
+    readonly row: number;
+    readonly column: number;
+}) => string;
 export declare const localIdentity: (node: SyntaxNode, name: string) => string;
 /**
  * The qualified name of a callable nested inside another callable — THE single

package/dist/core/ingestion/workers/callable-id.js

@@ -40,12 +40,12 @@ function containsPosition(node, row, column) {
     return true;
 }
 /**
- * Zero-based start row that keys the graph-to-scope position join for a bound
- * callable (#2735).
+ * Zero-based start position that keys the graph-to-scope join for a bound
+ * callable (#2735/#3041).
  *
  * Graph-node queries may anchor on an outer binding wrapper while the scope
- * channel anchors on the inner callable. The join is line-only, so a multi-line
- * binding needs the graph node's `startLine` to follow the semantic definition.
+ * channel anchors on the inner callable. A bound graph node therefore follows
+ * the semantic definition's line and column rather than the outer wrapper.
  *
  * `ParsedFile.localDefs` is the language-agnostic source of that position.
  * Matching uses only the canonical label, name, and source range; shared worker
@@ -55,15 +55,17 @@ function containsPosition(node, row, column) {
  * Missing or ambiguous semantic matches retain the wrapper row, preserving the
  * existing fail-closed behavior.
  */
-export function boundCallableStartRow(definitionNode, nodeName, nodeLabel, localDefs, nameNode) {
+export function boundCallableStartPosition(definitionNode, nodeName, nodeLabel, localDefs, nameNode) {
     if (localDefs === undefined)
-        return definitionNode.startPosition.row;
+        return definitionNode.startPosition;
     const origin = nameNode?.startPosition ?? definitionNode.startPosition;
     let best;
     let tied = false;
     for (const def of localDefs) {
-        if (def.type !== nodeLabel || simpleDefinitionName(def) !== nodeName)
+        if (def.type !== nodeLabel ||
+            (simpleDefinitionName(def) !== nodeName && def.qualifiedName !== nodeName)) {
             continue;
+        }
         const position = definitionIdPosition(def.nodeId, def.filePath);
         if (position === undefined)
             continue;
@@ -72,14 +74,20 @@ export function boundCallableStartRow(definitionNode, nodeName, nodeLabel, local
             continue;
         const distance = Math.abs(row - origin.row) * 1_000_000 + Math.abs(position.column - origin.column);
         if (best === undefined || distance < best.distance) {
-            best = { row, distance };
+            best = { row, column: position.column, distance };
             tied = false;
         }
-        else if (distance === best.distance && row !== best.row) {
+        else if (distance === best.distance &&
+            (row !== best.row || position.column !== best.column)) {
             tied = true;
         }
     }
-    return best !== undefined && !tied ? best.row : definitionNode.startPosition.row;
+    return best !== undefined && !tied
+        ? { row: best.row, column: best.column }
+        : definitionNode.startPosition;
+}
+export function boundCallableStartRow(definitionNode, nodeName, nodeLabel, localDefs, nameNode) {
+    return boundCallableStartPosition(definitionNode, nodeName, nodeLabel, localDefs, nameNode).row;
 }
 /**
  * A function-local callable's own name segment: its name plus its declaration
@@ -104,7 +112,8 @@ export function boundCallableStartRow(definitionNode, nodeName, nodeLabel, local
  * bare/class-qualified ids, which is what keeps this off the symbols other
  * files, saved queries and stored references actually address.
  */
-export const localIdentity = (node, name) => `${name}@${node.startPosition.row}:${node.startPosition.column}`;
+export const positionQualifiedCallableName = (name, position) => `${name}@${position.row}:${position.column}`;
+export const localIdentity = (node, name) => positionQualifiedCallableName(name, node.startPosition);
 /**
  * The qualified name of a callable nested inside another callable — THE single
  * definition of that rule, shared by all three id-building phases.

package/dist/core/ingestion/workers/parse-worker.js

@@ -1,5 +1,5 @@
 import { parentPort, threadId, workerData } from 'node:worker_threads';
-import { boundCallableStartRow, localIdentity, nestedCallableQualifiedName, } from './callable-id.js';
+import { boundCallableStartPosition, localIdentity, nestedCallableQualifiedName, positionQualifiedCallableName, } from './callable-id.js';
 import Parser from 'tree-sitter';
 import JavaScript from 'tree-sitter-javascript';
 import TypeScript from 'tree-sitter-typescript';
@@ -59,7 +59,7 @@ try {
 }
 catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
-import { buildDefinitionPreScan, FUNCTION_NODE_TYPES, findAncestorBeforeBoundary, findSplitBodyCallableAncestor, SPLIT_SIGNATURE_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, findReturnShapeOwnerInfo, isReturnShapeProperty, findMemberAssignmentOwnerInfo, isCjsDefaultExportAssignment, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, isValueDefinitionLabel, isQualifiableScopeLabel, MEMBER_OWNER_NODE_TYPES, qualifyByEnclosingModScope, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, PARAMETER_LIST_NODE_TYPES, LOCAL_SCOPE_BODY_NODE_TYPES, } from '../utils/ast-helpers.js';
+import { buildDefinitionPreScan, FUNCTION_NODE_TYPES, findAncestorBeforeBoundary, findSplitBodyCallableAncestor, SPLIT_SIGNATURE_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, isArrayContainedObjectLiteralMember, findReturnShapeOwnerInfo, isReturnShapeProperty, findMemberAssignmentOwnerInfo, isCjsDefaultExportAssignment, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, isValueDefinitionLabel, isQualifiableScopeLabel, MEMBER_OWNER_NODE_TYPES, qualifyByEnclosingModScope, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, PARAMETER_LIST_NODE_TYPES, LOCAL_SCOPE_BODY_NODE_TYPES, } from '../utils/ast-helpers.js';
 import { isPositionQualifiedLocalLabel } from '../utils/callable-labels.js';
 import { extractCallArgTypes } from '../utils/call-analysis.js';
 import { buildTypeEnv } from '../type-env.js';
@@ -406,6 +406,11 @@ const CALLABLE_PREFIX_BOUNDARY_TYPES = new Set([
     'object_literal', // Kotlin: object : Runnable { ... }
     'anonymous_object_creation_expression', // C#
 ]);
+/**
+ * Object-literal callables use the binding owner in their identity so spelling
+ * a member as a property or shorthand method cannot change its graph semantics.
+ */
+const shouldObjectOwnerQualifyCallable = (label) => label === 'Function' || label === 'Method';
 const enclosingCallablePrefix = (node, filePath, provider) => {
     // Boundary on class-likes: a method's owner is its CLASS, not whatever
     // function that class happens to sit inside. `CLASS_CONTAINER_TYPES` alone is
@@ -464,18 +469,33 @@ const callableOwnQualifiedName = (fnNode, filePath, provider) => {
     // `ownName === null` branch below carries the position INSTEAD of a name,
     // never in addition to one, so the two spellings cannot stack.
     const ownName = efnResult?.funcName ?? genericFuncName(fnNode) ?? null;
+    let finalLabel = efnResult?.label ?? inferFunctionLabel(fnNode.type);
+    if (provider.labelOverride) {
+        const override = provider.labelOverride(fnNode, finalLabel);
+        if (override !== null)
+            finalLabel = override;
+    }
     const prefix = enclosingCallablePrefix(fnNode, filePath, provider);
     const classInfo = prefix === undefined
         ? cachedFindEnclosingClassInfo(fnNode, filePath, provider.resolveEnclosingOwner)
         : null;
-    const owner = prefix ?? classInfo?.className;
+    const objectOwner = prefix === undefined && classInfo === null && shouldObjectOwnerQualifyCallable(finalLabel)
+        ? findObjectLiteralBindingInfo(fnNode, filePath, { includeOwnerName: true })?.ownerName
+        : undefined;
+    const owner = prefix ?? classInfo?.className ?? objectOwner;
+    const needsArrayPosition = owner === undefined &&
+        ownName !== null &&
+        shouldObjectOwnerQualifyCallable(finalLabel) &&
+        isArrayContainedObjectLiteralMember(fnNode);
     const result = prefix !== undefined
         ? nestedCallableQualifiedName(prefix, fnNode, ownName ?? 'fn')
         : ownName === null
             ? localIdentity(fnNode, 'fn')
             : owner
                 ? `${owner}.${ownName}`
-                : ownName;
+                : needsArrayPosition
+                    ? positionQualifiedCallableName(ownName, fnNode.startPosition)
+                    : ownName;
     callableQualifiedNameCache.set(fnNode, result);
     return result;
 };
@@ -518,7 +538,18 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                 // to the METHOD, not directly to the class, and a Go receiver method can
                 // never itself be nested inside another callable.
                 const nestedPrefix = enclosingCallablePrefix(current, filePath, provider);
-                const ownerName = nestedPrefix ?? classInfo?.className ?? standaloneMethodInfo?.receiverType ?? undefined;
+                const objectOwnerName = nestedPrefix === undefined &&
+                    classInfo === null &&
+                    shouldObjectOwnerQualifyCallable(finalLabel)
+                    ? findObjectLiteralBindingInfo(current, filePath, { includeOwnerName: true })?.ownerName
+                    : undefined;
+                const ownerName = nestedPrefix ??
+                    classInfo?.className ??
+                    standaloneMethodInfo?.receiverType ??
+                    objectOwnerName;
+                const needsArrayPosition = ownerName === undefined &&
+                    shouldObjectOwnerQualifyCallable(finalLabel) &&
+                    isArrayContainedObjectLiteralMember(current);
                 // Lockstep with the other two id-building phases — see
                 // `nestedCallableQualifiedName`, which is the shared rule. When a
                 // nested prefix exists it IS `ownerName`, so this branch and the
@@ -527,7 +558,9 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                     ? nestedCallableQualifiedName(nestedPrefix, current, funcName)
                     : ownerName
                         ? `${ownerName}.${funcName}`
-                        : funcName;
+                        : needsArrayPosition
+                            ? positionQualifiedCallableName(funcName, current.startPosition)
+                            : funcName;
                 // Include #<arity> suffix to match definition-phase Method/Constructor IDs.
                 // Use the same MethodExtractor (getMethodInfo) as the definition phase.
                 // When same-arity collisions exist, also append ~type1,type2.
@@ -1658,15 +1691,16 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             // wrapper while scope-resolution anchors on the INNER expression. The
             // position join is line-only, so `startLine` must follow the initializer
             // (ids still use `definitionNode` via `localIdentity`).
-            const startRow = definitionNode &&
+            const startPosition = definitionNode &&
                 (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor')
-                ? boundCallableStartRow(definitionNode, nodeName, nodeLabel, parsedFile?.localDefs, nameNode)
-                : definitionNode?.startPosition.row;
-            const startLine = startRow !== undefined
-                ? startRow + lineOffset
+                ? boundCallableStartPosition(definitionNode, nodeName, nodeLabel, parsedFile?.localDefs, nameNode)
+                : definitionNode?.startPosition;
+            const startLine = startPosition !== undefined
+                ? startPosition.row + lineOffset
                 : nameNode
                     ? nameNode.startPosition.row + lineOffset
                     : lineOffset;
+            const startColumn = startPosition?.column ?? nameNode?.startPosition.column ?? 0;
             // Compute enclosing class BEFORE node ID — needed to qualify method IDs
             const needsOwner = nodeLabel === 'Method' ||
                 nodeLabel === 'Constructor' ||
@@ -1733,19 +1767,27 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             // and COLLAPSE INTO ONE node — two distinct settings become one symbol,
             // and the merged name then looks workspace-unique to name inference,
             // which resolves reads of it to a node representing both.
-            const objectLiteralOwnerInfo = !enclosingClassId && (nodeLabel === 'Method' || nodeLabel === 'Property') && definitionNode
+            const objectLiteralBindingInfo = !enclosingClassId &&
+                (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Property') &&
+                definitionNode
+                ? findObjectLiteralBindingInfo(definitionNode, file.path, {
+                    includeOwnerName: shouldObjectOwnerQualifyCallable(nodeLabel) || nodeLabel === 'Property',
+                })
+                : null;
+            const objectLiteralOwnerInfo = !enclosingClassId &&
+                (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Property') &&
+                definitionNode
                 ? (findMemberAssignmentOwnerInfo(definitionNode, file.path) ??
-                    findObjectLiteralBindingInfo(definitionNode, file.path, {
-                        // Only `Property` opts into the qualifier; `Method` ids must stay
-                        // byte-identical or every object-literal method in every indexed
-                        // repo changes id.
-                        includeOwnerName: nodeLabel === 'Property',
-                    }) ??
+                    objectLiteralBindingInfo ??
                     // R3-4: an anonymous literal in return position is owned by the
                     // function whose shape it is. Last in the chain so a variable-bound
                     // literal keeps its existing owner and its existing id.
                     (nodeLabel === 'Property' ? findReturnShapeOwnerInfo(definitionNode, file.path) : null))
                 : null;
+            const isArrayContainedObjectCallable = !enclosingClassId &&
+                shouldObjectOwnerQualifyCallable(nodeLabel) &&
+                definitionNode !== undefined &&
+                isArrayContainedObjectLiteralMember(definitionNode);
             // Provenance for narrowing (R3-4). A return shape is a real definition but
             // the weaker one, and the unique-name pass ranks declared anchors above it
             // so indexing these cannot change an answer that already resolved.
@@ -1829,7 +1871,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                     // define `bar` stay distinct nodes.
                                     objectLiteralOwnerInfo?.ownerName !== undefined
                                         ? `${objectLiteralOwnerInfo.ownerName}.${nodeName}`
-                                        : nodeName;
+                                        : isArrayContainedObjectCallable
+                                            ? positionQualifiedCallableName(nodeName, startPosition)
+                                            : nodeName;
             // #2742: qualify by the enclosing `mod` chain, so two same-named items at
             // different module depths in one file are DISTINCT nodes. Without this,
             // `mod inner { fn dispatch }` and a crate-root `fn dispatch` both keyed
@@ -2133,6 +2177,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     name: nodeName,
                     filePath: file.path,
                     startLine,
+                    ...(shouldObjectOwnerQualifyCallable(nodeLabel) &&
+                        (objectLiteralBindingInfo?.ownerName || isArrayContainedObjectCallable)
+                        ? { startColumn }
+                        : {}),
                     endLine: definitionNode ? definitionNode.endPosition.row + lineOffset : startLine,
                     language: language,
                     isExported,
@@ -2194,8 +2242,11 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     ? { annotations: methodProps.annotations }
                     : {}),
             });
-            // Only emit File -> Symbol DEFINES for top-level symbols (issue #1944).
-            if (ownerId === undefined) {
+            // Object-literal callables remain file definitions as well as members of
+            // their exported binding. Class members still use HAS_METHOD alone.
+            const isTopLevelObjectCallable = objectLiteralBindingInfo?.ownerName !== undefined &&
+                shouldObjectOwnerQualifyCallable(nodeLabel);
+            if (ownerId === undefined || isTopLevelObjectCallable) {
                 const fileId = generateId('File', file.path);
                 const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
                 result.relationships.push({
@@ -2217,7 +2268,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     type: memberEdgeType,
                     confidence: 1.0,
                     reason: objectLiteralOwnerInfo
-                        ? 'object literal method belongs to exported object binding'
+                        ? 'object literal member belongs to exported object binding'
                         : '',
                 });
             }

package/dist/core/lbug/pool-adapter.d.ts

@@ -122,6 +122,15 @@ export declare const initLbug: (repoId: string, dbPath: string) => Promise<boole
  * repoId already injected it), the existing entry is reused.
  */
 export declare function initLbugWithDb(repoId: string, existingDb: lbug.Database, dbPath: string): Promise<void>;
+/**
+ * Lazily load VECTOR for a semantic query.
+ *
+ * Exact graph reads never call this function, so opening their read pool does
+ * not probe or warn about an optional extension they do not use. The promise
+ * lives on SharedDB because extension scope is per Database, and also joins
+ * concurrent first semantic requests onto one LOAD attempt.
+ */
+export declare function ensureVectorExtension(repoId: string): Promise<boolean>;
 export declare const executeQuery: (repoId: string, cypher: string) => Promise<any[]>;
 /**
  * Execute a parameterized query on a specific repo's connection pool.

package/dist/core/lbug/pool-adapter.js

@@ -265,6 +265,7 @@ function closeOne(repoId) {
                 shared.refCount = 0;
                 shared.ftsLoaded = false;
                 shared.vectorLoaded = false;
+                shared.vectorLoadPromise = undefined;
             }
             else {
                 shared.db.close().catch(() => { });
@@ -692,13 +693,6 @@ async function doInitLbug(repoId, dbPath) {
     if (!shared.ftsLoaded) {
         shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
-    // VECTOR too — extension load scope is per-Database, so this one load
-    // makes QUERY_VECTOR_INDEX legal on every pooled connection. Same
-    // load-only contract as FTS above; on failure the semantic-query lane
-    // falls back to the exact scan with its own diagnostic (#2623 follow-up).
-    if (!shared.vectorLoaded) {
-        shared.vectorLoaded = await loadVectorExtension(available[0], { policy: 'load-only' });
-    }
     // Register pool entry only after all connections are pre-warmed and FTS is
     // loaded.  Concurrent executeQuery calls see either "not initialized"
     // (and throw cleanly) or a fully ready pool — never a half-built one.
@@ -761,11 +755,6 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     if (!shared.ftsLoaded) {
         shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
-    // VECTOR too — same per-Database scope and load-only contract as the
-    // doInitLbug site above (#2623 follow-up).
-    if (!shared.vectorLoaded) {
-        shared.vectorLoaded = await loadVectorExtension(available[0], { policy: 'load-only' });
-    }
     pool.set(repoId, {
         db: existingDb,
         available,
@@ -780,6 +769,143 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     ensureIdleTimer();
     traceRss('init', repoId);
 }
+/**
+ * Lazily load VECTOR for a semantic query.
+ *
+ * Exact graph reads never call this function, so opening their read pool does
+ * not probe or warn about an optional extension they do not use. The promise
+ * lives on SharedDB because extension scope is per Database, and also joins
+ * concurrent first semantic requests onto one LOAD attempt.
+ */
+export async function ensureVectorExtension(repoId) {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
+    }
+    const shared = dbCache.get(entry.dbPath);
+    if (!shared) {
+        throw new Error(`LadybugDB shared handle is unavailable for repo "${repoId}".`);
+    }
+    if (shared.vectorLoaded)
+        return true;
+    if (shared.vectorLoadPromise)
+        return shared.vectorLoadPromise;
+    const loadAttempt = (async () => {
+        const conn = await checkout(entry);
+        try {
+            const loaded = await loadVectorExtension(conn, { policy: 'load-only' });
+            shared.vectorLoaded = loaded;
+            return loaded;
+        }
+        finally {
+            checkin(entry, conn);
+        }
+    })();
+    const cachedAttempt = loadAttempt.catch((err) => {
+        // A transient checkout/load failure must not poison this Database for the
+        // rest of its lifetime. Keep resolved false cached, but let a later
+        // semantic request retry a rejected attempt.
+        if (shared.vectorLoadPromise === cachedAttempt) {
+            shared.vectorLoadPromise = undefined;
+        }
+        throw err;
+    });
+    shared.vectorLoadPromise = cachedAttempt;
+    return shared.vectorLoadPromise;
+}
+/**
+ * Detect an actual VECTOR procedure call without treating source text stored in
+ * Cypher literals or comments as executable syntax.
+ */
+function callsVectorIndex(cypher) {
+    if (!/QUERY_VECTOR_INDEX/i.test(cypher))
+        return false;
+    let code = '';
+    let state = 'code';
+    let backtickIdentifier = '';
+    for (let i = 0; i < cypher.length; i++) {
+        const ch = cypher[i];
+        const next = cypher[i + 1];
+        if (state === 'code') {
+            if (ch === "'" || ch === '"' || ch === '`') {
+                state = ch === "'" ? 'single' : ch === '"' ? 'double' : 'backtick';
+                if (state === 'backtick')
+                    backtickIdentifier = '';
+                code += ' ';
+            }
+            else if (ch === '/' && next === '/') {
+                state = 'line-comment';
+                code += '  ';
+                i++;
+            }
+            else if (ch === '/' && next === '*') {
+                state = 'block-comment';
+                code += '  ';
+                i++;
+            }
+            else {
+                code += ch;
+            }
+            continue;
+        }
+        if (state === 'line-comment') {
+            if (ch === '\n' || ch === '\r') {
+                state = 'code';
+                code += ch;
+            }
+            else {
+                code += ' ';
+            }
+            continue;
+        }
+        if (state === 'block-comment') {
+            if (ch === '*' && next === '/') {
+                state = 'code';
+                code += '  ';
+                i++;
+            }
+            else {
+                code += ch === '\n' || ch === '\r' ? ch : ' ';
+            }
+            continue;
+        }
+        if (state === 'backtick') {
+            if (ch === '`' && next === '`') {
+                backtickIdentifier += '`';
+                code += '  ';
+                i++;
+            }
+            else if (ch === '`') {
+                state = 'code';
+                code +=
+                    backtickIdentifier.toUpperCase() === 'QUERY_VECTOR_INDEX' ? 'QUERY_VECTOR_INDEX' : ' ';
+            }
+            else if (ch === '\\' && next !== undefined) {
+                backtickIdentifier += next;
+                code += '  ';
+                i++;
+            }
+            else {
+                backtickIdentifier += ch;
+                code += ch === '\n' || ch === '\r' ? ch : ' ';
+            }
+            continue;
+        }
+        if (ch === '\\') {
+            code += ' ';
+            if (next !== undefined) {
+                code += next === '\n' || next === '\r' ? next : ' ';
+                i++;
+            }
+            continue;
+        }
+        const closesLiteral = (state === 'single' && ch === "'") || (state === 'double' && ch === '"');
+        if (closesLiteral)
+            state = 'code';
+        code += ch === '\n' || ch === '\r' ? ch : ' ';
+    }
+    return /\bCALL\s+QUERY_VECTOR_INDEX\s*\(/i.test(code);
+}
 /**
  * Checkout a connection from the pool.
  * Returns an available connection, or creates a new one if under the cap.
@@ -870,12 +996,26 @@ export const executeParameterized = async (repoId, cypher, params) => {
     // a query built by splicing a caller-sized list names itself even when the
     // repo is not initialized. Never throws (#2915).
     warnIfQueryTextUnbounded(cypher, `pool executeParameterized (repo "${repoId}")`, (message) => poolSidecarLogger.warn(message));
-    const entry = pool.get(repoId);
+    let entry = pool.get(repoId);
     if (!entry) {
         throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initLbug first.`);
     }
-    entry.lastUsed = Date.now();
+    // Exact reads must not pay for VECTOR, but an explicit raw vector procedure
+    // call is a semantic read. Preflight before taking the query connection:
+    // ensureVectorExtension performs its own checkout, so holding one here could
+    // make a saturated pool wait for a connection that every caller is holding.
+    // A load rejection must not replace the query's own diagnostic.
+    if (callsVectorIndex(cypher)) {
+        await ensureVectorExtension(repoId).catch(() => false);
+        // The preflight suspends, so close/re-init may replace the pool entry.
+        // Re-read it before checkout to avoid querying through a stale handle.
+        entry = pool.get(repoId);
+        if (!entry) {
+            throw new Error(`LadybugDB connection pool closed for repo "${repoId}" (re-init/teardown); retry the query.`);
+        }
+    }
     const conn = await checkout(entry);
+    entry.lastUsed = Date.now();
     silenceStdout();
     activeQueryCount++;
     let queryResult;

package/dist/mcp/local/local-backend.d.ts

@@ -256,12 +256,12 @@ export declare class LocalBackend {
      */
     private warnedSiblingDrift;
     /**
-     * One-shot stderr warning for the VECTOR-extension fallback. Without this
-     * guard the diagnostic would fire on every `semanticSearch()` call on
-     * platforms where the extension is unsupported (e.g. Windows), making MCP
-     * stderr noisy per DoD §2.8.
+     * One-shot stderr guards for distinct VECTOR load and index-query failures.
+     * Keeping them separate preserves both diagnostics across semanticSearch calls
+     * without repeating either on hot paths.
      */
-    private warnedVectorUnsupported;
+    private warnedVectorLoadFailed;
+    private warnedVectorQueryFailed;
     /**
      * One-shot warning when a pruned or Node-unloadable optional embedding stack
      * (#2370/#2372) forces semantic search to fall back to BM25 — so the

package/dist/mcp/local/local-backend.js

@@ -8,7 +8,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { createHash } from 'crypto';
-import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, statDbIdentity, dbIdentityChanged, } from '../../core/lbug/pool-adapter.js';
+import { initLbug, executeQuery, executeParameterized, ensureVectorExtension, closeLbug, isLbugReady, statDbIdentity, dbIdentityChanged, } from '../../core/lbug/pool-adapter.js';
 import { queryClassBeanMetadata } from './bean-metadata.js';
 import { querySpringAopMetadata } from './aop-metadata.js';
 import { queryConvexDispatchMetadata } from './convex-metadata.js';
@@ -783,12 +783,12 @@ export class LocalBackend {
      */
     warnedSiblingDrift = new Set();
     /**
-     * One-shot stderr warning for the VECTOR-extension fallback. Without this
-     * guard the diagnostic would fire on every `semanticSearch()` call on
-     * platforms where the extension is unsupported (e.g. Windows), making MCP
-     * stderr noisy per DoD §2.8.
+     * One-shot stderr guards for distinct VECTOR load and index-query failures.
+     * Keeping them separate preserves both diagnostics across semanticSearch calls
+     * without repeating either on hot paths.
      */
-    warnedVectorUnsupported = false;
+    warnedVectorLoadFailed = false;
+    warnedVectorQueryFailed = false;
     /**
      * One-shot warning when a pruned or Node-unloadable optional embedding stack
      * (#2370/#2372) forces semantic search to fall back to BM25 — so the
@@ -2518,17 +2518,25 @@ export class LocalBackend {
             this.lastQueryEmbeddingDims.set(repo.lbugPath, dims);
             const queryVecStr = `[${queryVec.join(',')}]`;
             const maxDistance = getVectorMaxDistance(DEFAULT_MCP_VECTOR_MAX_DISTANCE);
-            let bestChunks = new Map();
-            // Always TRY the vector lane — no platform gate. LadybugDB ships the
-            // VECTOR extension for every supported platform, Windows included
-            // (#2623 follow-up; the old `platform !== 'win32'` gate was stale), so
-            // whether the index is queryable is a per-machine runtime fact. The
-            // catch below is the fallback: any failure (extension unloadable, index
-            // absent, older DB) degrades to the exact scan with a once-per-backend
-            // diagnostic instead of being silently swallowed.
+            let vectorReady = false;
             try {
-                bestChunks = await collectBestChunks(limit, async (fetchLimit) => {
-                    const vectorQuery = `
+                vectorReady = await ensureVectorExtension(repo.lbugPath);
+            }
+            catch (err) {
+                if (!this.warnedVectorLoadFailed) {
+                    this.warnedVectorLoadFailed = true;
+                    logger.warn({ err }, 'GitNexus [query:vector]: vector extension load failed; using exact scan fallback');
+                }
+            }
+            let bestChunks = new Map();
+            // Try the vector lane only after its lazy load succeeds. An unavailable
+            // extension is already reported by ExtensionManager; an index/query
+            // failure below gets its own once-per-backend diagnostic before the exact
+            // scan fallback.
+            if (vectorReady) {
+                try {
+                    bestChunks = await collectBestChunks(limit, async (fetchLimit) => {
+                        const vectorQuery = `
             CALL QUERY_VECTOR_INDEX('${EMBEDDING_TABLE_NAME}', '${EMBEDDING_INDEX_NAME}',
               CAST(${queryVecStr} AS FLOAT[${dims}]), ${fetchLimit})
             YIELD node AS emb, distance
@@ -2538,24 +2546,25 @@ export class LocalBackend {
                    emb.startLine AS startLine, emb.endLine AS endLine, distance
             ORDER BY distance
           `;
-                    const embResults = await executeQuery(repo.lbugPath, vectorQuery);
-                    return embResults.map((row) => ({
-                        nodeId: row.nodeId ?? row[0],
-                        chunkIndex: row.chunkIndex ?? row[1] ?? 0,
-                        startLine: row.startLine ?? row[2] ?? 0,
-                        endLine: row.endLine ?? row[3] ?? 0,
-                        distance: row.distance ?? row[4],
-                    }));
-                });
-            }
-            catch (err) {
-                bestChunks = new Map();
-                if (!this.warnedVectorUnsupported) {
-                    // Rare diagnostic: surface why semantic search fell back to the
-                    // exact scan. Emitted once per `LocalBackend` instance lifetime to
-                    // avoid noisy stderr on hot semantic-search paths (DoD §2.8).
-                    this.warnedVectorUnsupported = true;
-                    logger.warn({ err }, 'GitNexus [query:vector]: vector index query failed; using exact scan fallback');
+                        const embResults = await executeQuery(repo.lbugPath, vectorQuery);
+                        return embResults.map((row) => ({
+                            nodeId: row.nodeId ?? row[0],
+                            chunkIndex: row.chunkIndex ?? row[1] ?? 0,
+                            startLine: row.startLine ?? row[2] ?? 0,
+                            endLine: row.endLine ?? row[3] ?? 0,
+                            distance: row.distance ?? row[4],
+                        }));
+                    });
+                }
+                catch (err) {
+                    bestChunks = new Map();
+                    if (!this.warnedVectorQueryFailed) {
+                        // Rare diagnostic: surface why semantic search fell back to the
+                        // exact scan. Emitted once per `LocalBackend` instance lifetime to
+                        // avoid noisy stderr on hot semantic-search paths (DoD §2.8).
+                        this.warnedVectorQueryFailed = true;
+                        logger.warn({ err }, 'GitNexus [query:vector]: vector index query failed; using exact scan fallback');
+                    }
                 }
             }
             if (bestChunks.size === 0) {
@@ -5149,6 +5158,7 @@ export class LocalBackend {
                         summaryOnly: true,
                         skipEpistemic: true,
                         skipEnrichment: true,
+                        hasExplicitRelationTypes,
                     });
                 }
                 catch (e) {
@@ -5385,6 +5395,7 @@ export class LocalBackend {
                     limit: Number.isFinite(params.limit) ? params.limit : 100,
                     offset: Number.isFinite(params.offset) ? params.offset : 0,
                     pdgBridge,
+                    hasExplicitRelationTypes,
                 });
                 return composeUnifiedPdgImpactResult(pdgResult, interproceduralResult);
             }
@@ -5401,6 +5412,7 @@ export class LocalBackend {
             limit: Number.isFinite(params.limit) ? params.limit : 100,
             offset: Number.isFinite(params.offset) ? params.offset : 0,
             summaryOnly: params.summaryOnly,
+            hasExplicitRelationTypes,
         });
     }
     /**
@@ -5738,7 +5750,11 @@ export class LocalBackend {
         const visited = new Set([symId]);
         const pdgBridgeEvidenceById = new Map();
         let frontier = [symId];
+        const objectCallableFrontier = [];
         let traversalComplete = true;
+        // Fetch one sentinel row beyond the cap so generated object bindings
+        // degrade visibly instead of allocating an unbounded seed frontier.
+        const OBJECT_CALLABLE_MEMBER_CAP = 5000;
         // Fix #480: For Java (and other JVM) Class/Interface nodes, CALLS edges
         // point to Constructor nodes and IMPORTS edges point to File nodes — not
         // the Class/Interface itself. Seed the frontier with the Constructor(s)
@@ -5798,6 +5814,58 @@ export class LocalBackend {
             }
             catch (e) {
                 logQueryError('impact:class-node-expansion', e);
+                traversalComplete = false;
+            }
+        }
+        // Function-valued properties on exported object bindings are represented
+        // as Const/Variable -[:HAS_METHOD]-> Function. HAS_METHOD is intentionally
+        // absent from the default usage traversal, but downstream impact on the
+        // binding still needs to enter its own callable member before following
+        // CALLS.
+        if (direction === 'downstream' &&
+            (symType === 'Const' || symType === 'Variable') &&
+            relationTypes.includes('CALLS') &&
+            !relationTypes.includes('HAS_METHOD') &&
+            !opts.hasExplicitRelationTypes) {
+            try {
+                const memberRows = await executeParameterized(repo.lbugPath, `
+          MATCH (n)-[hm:CodeRelation]->(member:Function)
+          WHERE n.id = $symId AND hm.type = 'HAS_METHOD'
+          RETURN DISTINCT member.id AS id, member.name AS name,
+                 'Function' AS type, member.filePath AS filePath
+          ORDER BY id
+          LIMIT ${OBJECT_CALLABLE_MEMBER_CAP + 1}
+          UNION ALL
+          MATCH (n)-[hm:CodeRelation]->(member:Method)
+          WHERE n.id = $symId AND hm.type = 'HAS_METHOD'
+          RETURN DISTINCT member.id AS id, member.name AS name,
+                 'Method' AS type, member.filePath AS filePath
+          ORDER BY id
+          LIMIT ${OBJECT_CALLABLE_MEMBER_CAP + 1}
+        `, { symId });
+                memberRows.sort((a, b) => compareCodeUnits(String(a.id ?? a[0]), String(b.id ?? b[0])));
+                if (memberRows.length > OBJECT_CALLABLE_MEMBER_CAP)
+                    traversalComplete = false;
+                for (const row of memberRows.slice(0, OBJECT_CALLABLE_MEMBER_CAP)) {
+                    const memberId = row.id || row[0];
+                    if (memberId && !visited.has(memberId)) {
+                        visited.add(memberId);
+                        objectCallableFrontier.push(memberId);
+                        impacted.push({
+                            depth: 1,
+                            id: memberId,
+                            name: row.name || row[1],
+                            type: row.type || row[2],
+                            filePath: row.filePath || row[3] || '',
+                            relationType: 'HAS_METHOD',
+                            confidence: 1,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                logQueryError('impact:object-callable-expansion', e);
+                traversalComplete = false;
             }
         }
         for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
@@ -5939,7 +6007,10 @@ export class LocalBackend {
                 traversalComplete = false;
                 break;
             }
-            frontier = nextFrontier;
+            frontier =
+                depth === 1 && objectCallableFrontier.length > 0
+                    ? [...new Set([...nextFrontier, ...objectCallableFrontier])]
+                    : nextFrontier;
         }
         // Stamp the finalized, order-independent bridge evidence (strongest across
         // all parents) onto each impacted item. Deferred from the BFS loop so a
@@ -6476,6 +6547,7 @@ export class LocalBackend {
                 // the #1858 epistemic/boundaries fields — computing them per neighbor is
                 // dead work on the highest-volume path, so suppress them here too.
                 skipEpistemic: true,
+                hasExplicitRelationTypes: opts.relationTypes.length > 0,
             });
         }
         catch {

package/dist/storage/parse-cache.js

@@ -563,7 +563,6 @@ import { fileURLToPath } from 'url';
 // and the v37/v38 clash it was written for: the next free value above every
 // IN-FLIGHT claim, not above origin/main. Every open PR touching gitnexus/ was
 // scanned; #3017 is the only other claimant.
-// RE-CHECK AGAINST origin/main AND OPEN PRs IMMEDIATELY BEFORE MERGING.
 //
 // 72 -> 74 adds import-proven Convex endpoint metadata to Const/Function worker
 // output. A warm v72 cache has no convexEndpointFactory property, so the MCP
@@ -573,7 +572,17 @@ import { fileURLToPath } from 'url';
 // migration needs both guarantees. Version 73 is intentionally skipped because
 // concurrent PR #3046 (fixes #3041) claims it. Re-check main and open PRs
 // immediately before merge.
-const SCHEMA_BUMP = 74;
+//
+// 74 -> 76 makes object-literal Function and Method members owner-qualified
+// (#3041). A warm v74 cache replays the old collapsed callable ids and omits
+// the new Const/Variable -> callable HAS_METHOD ownership edges, so this bump
+// makes unchanged files re-parse rather than waiting for a source edit. The
+// persisted graph is rebuilt separately when `analyzerRunnerIdentitiesEqual`
+// detects the changed analyzer build in run-analyze.ts. Both guards are
+// required; a parse-cache bump alone must never be read as a graph rebuild.
+// Version 75 is intentionally skipped because concurrent PR #3017 claims it.
+// RE-CHECK AGAINST origin/main AND OPEN PRs IMMEDIATELY BEFORE MERGING.
+const SCHEMA_BUMP = 76;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.221",
+  "version": "1.6.10-rc.223",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",