gitnexus 1.6.10-rc.222 → 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/mcp/local/local-backend.js

@@ -5158,6 +5158,7 @@ export class LocalBackend {
                         summaryOnly: true,
                         skipEpistemic: true,
                         skipEnrichment: true,
+                        hasExplicitRelationTypes,
                     });
                 }
                 catch (e) {
@@ -5394,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);
             }
@@ -5410,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,
         });
     }
     /**
@@ -5747,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)
@@ -5807,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++) {
@@ -5948,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
@@ -6485,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.222",
+  "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",