gitnexus 1.6.6-rc.31 → 1.6.6-rc.32

package/dist/cli/optional-grammars.d.ts

@@ -1,15 +1,18 @@
 /**
  * Optional grammar availability check.
  *
- * tree-sitter-dart and tree-sitter-proto are optionalDependencies that
- * require a `node-gyp rebuild` at install time. The build can be skipped
- * via GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or it can
- * silently soft-fail when the C++ toolchain is missing.
+ * tree-sitter-dart, tree-sitter-proto, and tree-sitter-swift are vendored
+ * under vendor/ and materialized into node_modules/ at postinstall. Dart
+ * and Proto are built from source with node-gyp; Swift ships platform
+ * prebuilds activated via node-gyp-build. All three can be skipped via
+ * GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or can silently
+ * soft-fail when the toolchain is missing (Dart/Proto) or no prebuild
+ * matches the host platform (Swift).
  *
  * Either path produces the same observable: the .node binding is absent
  * at runtime. This helper detects that condition and surfaces a single
- * stderr line per missing grammar so users learn why .dart/.proto support
- * is unavailable instead of silently getting a degraded index.
+ * stderr line per missing grammar so users learn why .dart/.proto/.swift
+ * support is unavailable instead of silently getting a degraded index.
  */
 export interface MissingGrammar {
     name: string;
@@ -19,8 +22,8 @@ export interface MissingGrammar {
  * Returns the list of optional grammars whose native binding cannot be
  * loaded. Actually `require()`s the package — `require.resolve` would
  * locate the entry path even when the `.node` binding is absent (the
- * `file:` package directory is installed regardless of postinstall
- * outcome), giving false negatives for the exact users we want to warn:
+ * package directory exists without a working `.node` binding), giving false
+ * negatives for the exact users we want to warn:
  * those who installed with `GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1` or whose
  * native rebuild soft-failed for missing toolchain.
  *

package/dist/cli/optional-grammars.js

@@ -1,15 +1,18 @@
 /**
  * Optional grammar availability check.
  *
- * tree-sitter-dart and tree-sitter-proto are optionalDependencies that
- * require a `node-gyp rebuild` at install time. The build can be skipped
- * via GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or it can
- * silently soft-fail when the C++ toolchain is missing.
+ * tree-sitter-dart, tree-sitter-proto, and tree-sitter-swift are vendored
+ * under vendor/ and materialized into node_modules/ at postinstall. Dart
+ * and Proto are built from source with node-gyp; Swift ships platform
+ * prebuilds activated via node-gyp-build. All three can be skipped via
+ * GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (postinstall scripts), or can silently
+ * soft-fail when the toolchain is missing (Dart/Proto) or no prebuild
+ * matches the host platform (Swift).
  *
  * Either path produces the same observable: the .node binding is absent
  * at runtime. This helper detects that condition and surfaces a single
- * stderr line per missing grammar so users learn why .dart/.proto support
- * is unavailable instead of silently getting a degraded index.
+ * stderr line per missing grammar so users learn why .dart/.proto/.swift
+ * support is unavailable instead of silently getting a degraded index.
  */
 import { createRequire } from 'module';
 import { cliWarn } from './cli-message.js';
@@ -17,13 +20,14 @@ const _require = createRequire(import.meta.url);
 const OPTIONAL_GRAMMARS = [
     { name: 'tree-sitter-dart', pkg: 'tree-sitter-dart', extensions: ['.dart'] },
     { name: 'tree-sitter-proto', pkg: 'tree-sitter-proto', extensions: ['.proto'] },
+    { name: 'tree-sitter-swift', pkg: 'tree-sitter-swift', extensions: ['.swift'] },
 ];
 /**
  * Returns the list of optional grammars whose native binding cannot be
  * loaded. Actually `require()`s the package — `require.resolve` would
  * locate the entry path even when the `.node` binding is absent (the
- * `file:` package directory is installed regardless of postinstall
- * outcome), giving false negatives for the exact users we want to warn:
+ * package directory exists without a working `.node` binding), giving false
+ * negatives for the exact users we want to warn:
  * those who installed with `GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1` or whose
  * native rebuild soft-failed for missing toolchain.
  *

package/dist/core/ingestion/parsing-processor.js

@@ -7,7 +7,7 @@ import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
-import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
+import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from './utils/method-props.js';
@@ -400,6 +400,9 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path, provider.resolveEnclosingOwner)
                 : null;
             const enclosingClassId = enclosingClassInfo?.classId ?? null;
+            const objectLiteralOwnerInfo = !enclosingClassId && nodeLabel === 'Method' && definitionNode
+                ? findObjectLiteralBindingInfo(definitionNode, file.path)
+                : null;
             // Qualify method/property IDs with enclosing class name to avoid collisions
             // e.g. "Method:animal.dart:Animal.speak" vs "Method:animal.dart:Dog.speak"
             const qualifiedName = enclosingClassInfo
@@ -615,7 +618,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
                 returnType: methodProps.returnType,
                 declaredType,
                 templateArguments: classTemplateArguments,
-                ownerId: enclosingClassId ?? undefined,
+                ownerId: enclosingClassId ?? objectLiteralOwnerInfo?.ownerId ?? undefined,
                 qualifiedName: qualifiedTypeName,
             });
             const fileId = generateId('File', file.path);
@@ -630,15 +633,18 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, sco
             };
             graph.addRelationship(relationship);
             // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ──
-            if (enclosingClassId) {
+            const ownerIdForMemberEdge = enclosingClassId ?? objectLiteralOwnerInfo?.ownerId ?? null;
+            if (ownerIdForMemberEdge) {
                 const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD';
                 graph.addRelationship({
-                    id: generateId(memberEdgeType, `${enclosingClassId}->${nodeId}`),
-                    sourceId: enclosingClassId,
+                    id: generateId(memberEdgeType, `${ownerIdForMemberEdge}->${nodeId}`),
+                    sourceId: ownerIdForMemberEdge,
                     targetId: nodeId,
                     type: memberEdgeType,
                     confidence: 1.0,
-                    reason: '',
+                    reason: objectLiteralOwnerInfo
+                        ? 'object literal method belongs to exported object binding'
+                        : '',
                 });
             }
         });

package/dist/core/ingestion/scope-extractor.js

@@ -511,8 +511,14 @@ function normalizeNodeLabel(kindStr) {
         case 'property':
             return 'Property';
         case 'variable':
-        case 'const':
             return 'Variable';
+        // `const` / `let` declarations align with the legacy DAG parse phase,
+        // which emits `Const` graph nodes via `@definition.const` capture for
+        // `lexical_declaration`. Returning `'Const'` here lets resolveDefGraphId's
+        // qualified-key path succeed for value receivers without relying on the
+        // simple-key fallback (PR #1718 review Finding 1 / 2026-05-21-002 U4).
+        case 'const':
+            return 'Const';
         case 'typealias':
         case 'type_alias':
             return 'TypeAlias';

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

@@ -41,3 +41,24 @@ export declare function tryEmitEdge(graph: KnowledgeGraph, scopes: ScopeResoluti
     };
     readonly kind: string;
 }, targetDef: SymbolDefinition, reason: string, seen: Set<string>, confidence?: number, collapseByCallerTarget?: boolean): boolean;
+/**
+ * Variant of `tryEmitEdge` that takes a pre-resolved target graph id
+ * instead of resolving it from a `SymbolDefinition`. Used by the
+ * value-receiver-owner bridge (`receiver-bound-calls.ts` Case 5) where
+ * the picked owner-indexed method def carries no `qualifiedName` (object
+ * literals have no class owner to seed it) and therefore cannot
+ * round-trip through `resolveDefGraphId`. The def's `nodeId` IS the
+ * canonical graph node id (written by the parse phase), so the caller
+ * passes it directly.
+ *
+ * All other invariants of `tryEmitEdge` apply: dedup key shape, collapse
+ * flag honoring, edge-type mapping, caller-id resolution.
+ */
+export declare function tryEmitEdgeWithExplicitTargetId(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, nodeLookup: GraphNodeLookup, site: {
+    readonly inScope: ScopeId;
+    readonly atRange: {
+        startLine: number;
+        startCol: number;
+    };
+    readonly kind: string;
+}, targetGraphId: string, reason: string, seen: Set<string>, confidence?: number, collapseByCallerTarget?: boolean): boolean;

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

@@ -77,3 +77,40 @@ export function tryEmitEdge(graph, scopes, nodeLookup, site, targetDef, reason,
     });
     return true;
 }
+/**
+ * Variant of `tryEmitEdge` that takes a pre-resolved target graph id
+ * instead of resolving it from a `SymbolDefinition`. Used by the
+ * value-receiver-owner bridge (`receiver-bound-calls.ts` Case 5) where
+ * the picked owner-indexed method def carries no `qualifiedName` (object
+ * literals have no class owner to seed it) and therefore cannot
+ * round-trip through `resolveDefGraphId`. The def's `nodeId` IS the
+ * canonical graph node id (written by the parse phase), so the caller
+ * passes it directly.
+ *
+ * All other invariants of `tryEmitEdge` apply: dedup key shape, collapse
+ * flag honoring, edge-type mapping, caller-id resolution.
+ */
+export function tryEmitEdgeWithExplicitTargetId(graph, scopes, nodeLookup, site, targetGraphId, reason, seen, confidence = 0.85, collapseByCallerTarget = false) {
+    const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup);
+    const edgeType = mapReferenceKindToEdgeType(site.kind);
+    if (callerGraphId === undefined)
+        return false;
+    if (edgeType === undefined)
+        return false;
+    const useCollapsed = collapseByCallerTarget && edgeType === 'CALLS';
+    const dedupKey = useCollapsed
+        ? `${edgeType}:${callerGraphId}->${targetGraphId}`
+        : `${edgeType}:${callerGraphId}->${targetGraphId}:${site.atRange.startLine}:${site.atRange.startCol}`;
+    if (seen.has(dedupKey))
+        return false;
+    seen.add(dedupKey);
+    graph.addRelationship({
+        id: `rel:${dedupKey}`,
+        sourceId: callerGraphId,
+        targetId: targetGraphId,
+        type: edgeType,
+        confidence,
+        reason,
+    });
+    return true;
+}

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

@@ -137,5 +137,11 @@ export function isLinkableLabel(label) {
         // ACCESSES edges target field nodes (e.g. `user.name = "x"` →
         // ACCESSES edge to User's `name` Variable/Property node).
         label === 'Variable' ||
-        label === 'Property');
+        label === 'Property' ||
+        // Const is linkable so the value-receiver-owner bridge in
+        // `receiver-bound-calls.ts` Case 5 can translate the scope-resolution
+        // `Variable` def for `export const fooService = {...}` to the canonical
+        // `Const:filePath:name` graph node id, against which object-literal
+        // method symbols register their `ownerId` (PR #1718 / issue #1358).
+        label === 'Const');
 }

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -21,6 +21,11 @@
  *      but not a namespace prefix → compound resolver
  *   7. **Case 4 (simple typeBinding)** — `typeRef.rawName` has no dot →
  *      MRO walk + `findOwnedMember`
+ *   8. **Case 5 (value-receiver bridge)** — receiver is a `Const`/`Variable`
+ *      whose `nodeId` is referenced as an `ownerId` in `model.methods`
+ *      (object-literal services). Last-resort fallback for lowercase
+ *      receivers with no class-like or type-binding match. Mirrors
+ *      the legacy DAG bridge in `call-processor.ts`.
  *
  * Reordering or merging cases changes resolution semantics.
  *

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -21,6 +21,11 @@
  *      but not a namespace prefix → compound resolver
  *   7. **Case 4 (simple typeBinding)** — `typeRef.rawName` has no dot →
  *      MRO walk + `findOwnedMember`
+ *   8. **Case 5 (value-receiver bridge)** — receiver is a `Const`/`Variable`
+ *      whose `nodeId` is referenced as an `ownerId` in `model.methods`
+ *      (object-literal services). Last-resort fallback for lowercase
+ *      receivers with no class-like or type-binding match. Mirrors
+ *      the legacy DAG bridge in `call-processor.ts`.
  *
  * Reordering or merging cases changes resolution semantics.
  *
@@ -32,8 +37,8 @@
  * resolved to a wrong target.
  */
 import { collectNamespaceTargets } from '../scope/namespace-targets.js';
-import { findClassBindingInScope, findEnclosingClassDef, findExportedDef, findOwnedMember, findReceiverTypeBinding, isClassLike, } from '../scope/walkers.js';
-import { tryEmitEdge } from '../graph-bridge/edges.js';
+import { findClassBindingInScope, findEnclosingClassDef, findExportedDef, findOwnedMember, findReceiverTypeBinding, findValueBindingInScope, isClassLike, } from '../scope/walkers.js';
+import { tryEmitEdge, tryEmitEdgeWithExplicitTargetId } from '../graph-bridge/edges.js';
 import { resolveCompoundReceiverClass } from '../passes/compound-receiver.js';
 import { resolveDefGraphId } from '../graph-bridge/ids.js';
 import { narrowOverloadCandidates, isOverloadAmbiguousAfterNormalization, } from './overload-narrowing.js';
@@ -514,6 +519,49 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                 }
             }
+            // ── Case 5: value-receiver bridge (object-literal services) ──
+            // When prior cases couldn't resolve the receiver as a class or
+            // type binding, fall back to value-binding resolution. Covers:
+            //
+            //   export const fooService = { getUser(id) {...} };
+            //   import { fooService } from './service';
+            //   fooService.getUser(id);   // ← resolve here
+            //
+            // `fooService` is a `Const`/`Variable` (not class-like, no typeBinding
+            // for unannotated literals), so Cases 2-4 skip it. Scope-resolution
+            // defs for non-class values carry a synthetic id, so we translate to
+            // the canonical graph node ID via `resolveDefGraphId` before owner-
+            // indexed lookup — the parser writes the graph node ID as `ownerId`
+            // on the method symbol-table entry to match.
+            //
+            // Object-literal methods do not carry a `qualifiedName` (no class
+            // owner to seed it), so the picked def cannot round-trip through
+            // `tryEmitEdge` → `resolveDefGraphId`. We use
+            // `tryEmitEdgeWithExplicitTargetId` instead, passing `picked.nodeId`
+            // directly — same dedup-key shape, collapse-flag honoring, and
+            // caller resolution as `tryEmitEdge`.
+            const valueDef = findValueBindingInScope(site.inScope, receiverName, scopes);
+            if (valueDef !== undefined) {
+                const ownerGraphId = resolveDefGraphId(valueDef.filePath, valueDef, nodeLookup) ?? valueDef.nodeId;
+                const picked = pickOverload(ownerGraphId, memberName, site, model, provider);
+                if (picked === OVERLOAD_AMBIGUOUS) {
+                    handledSites.add(siteKey);
+                    continue;
+                }
+                if (picked !== undefined) {
+                    const reason = site.kind === 'write' || site.kind === 'read'
+                        ? site.kind
+                        : picked.filePath !== parsed.filePath
+                            ? 'import-resolved'
+                            : 'global';
+                    const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
+                    const ok = tryEmitEdgeWithExplicitTargetId(graph, scopes, nodeLookup, site, picked.nodeId, reason, seen, confidence, collapse);
+                    if (ok)
+                        emitted++;
+                    handledSites.add(siteKey);
+                    continue;
+                }
+            }
         }
     }
     return emitted;

package/dist/core/ingestion/scope-resolution/scope/walkers.d.ts

@@ -91,6 +91,34 @@ export declare function findReceiverTypeBinding(startScope: ScopeId, receiverNam
  * Without (2) we'd miss every cross-file class-receiver call.
  */
 export declare function findClassBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+/**
+ * Predicate for value-receiver bridge: the labels for which
+ * `reconcileOwnership` registers methods/fields under the def's
+ * `nodeId` as the `ownerId`. Explicit allowlist so future NodeLabel
+ * additions (Module, Namespace, TypeAlias, EnumMember, etc.) do NOT
+ * silently widen the bridge — adding a new ownerable label requires
+ * touching both this predicate and `reconcileOwnership`.
+ *
+ * See: `scope-resolution/pipeline/reconcile-ownership.ts` Property /
+ * Variable / Const / Static registration block.
+ */
+export declare function isOwnableValueLabel(t: string): boolean;
+/**
+ * Look up a value-binding (Const/Variable/Property/Static) by name in
+ * the given scope's chain. Used by the value-receiver-owner bridge
+ * for object-literal services such as:
+ *
+ *   export const fooService = { getUser(id) {...} };
+ *
+ * where `fooService` is a `Const`/`Variable` whose `nodeId` is the
+ * `ownerId` of the member method. Neither `findClassBindingInScope`
+ * (rejects non-class-like) nor `findReceiverTypeBinding` (no typeBinding
+ * for an unannotated literal) finds it.
+ *
+ * Mirrors `findClassBindingInScope` exactly; only the accepted def-type
+ * predicate differs.
+ */
+export declare function findValueBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
 /**
  * Look up a callable (Function/Method/Constructor) by name in the
  * given scope's chain. Uses the dual-source pattern (scope.bindings +

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -150,29 +150,9 @@ export function findReceiverTypeBinding(startScope, receiverName, scopes) {
  * Without (2) we'd miss every cross-file class-receiver call.
  */
 export function findClassBindingInScope(startScope, receiverName, scopes) {
-    let currentId = startScope;
-    const visited = new Set();
-    while (currentId !== null) {
-        if (visited.has(currentId))
-            return undefined;
-        visited.add(currentId);
-        const scope = scopes.scopeTree.getScope(currentId);
-        if (scope === undefined)
-            return undefined;
-        const localBindings = scope.bindings.get(receiverName);
-        if (localBindings !== undefined) {
-            for (const b of localBindings) {
-                if (isClassLike(b.def.type))
-                    return b.def;
-            }
-        }
-        const importedBindings = lookupBindingsAt(currentId, receiverName, scopes);
-        for (const b of importedBindings) {
-            if (isClassLike(b.def.type))
-                return b.def;
-        }
-        currentId = scope.parent;
-    }
+    const local = walkScopeChain(startScope, receiverName, scopes, (def) => isClassLike(def.type));
+    if (local !== undefined)
+        return local;
     // Fallback for languages (Go) where namespace-style imports don't
     // create scope bindings: resolve via QualifiedNameIndex. Only fires
     // when the scope-chain walk found nothing; single-match wins.
@@ -198,6 +178,78 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
     }
     return undefined;
 }
+/**
+ * Predicate for value-receiver bridge: the labels for which
+ * `reconcileOwnership` registers methods/fields under the def's
+ * `nodeId` as the `ownerId`. Explicit allowlist so future NodeLabel
+ * additions (Module, Namespace, TypeAlias, EnumMember, etc.) do NOT
+ * silently widen the bridge — adding a new ownerable label requires
+ * touching both this predicate and `reconcileOwnership`.
+ *
+ * See: `scope-resolution/pipeline/reconcile-ownership.ts` Property /
+ * Variable / Const / Static registration block.
+ */
+export function isOwnableValueLabel(t) {
+    return t === 'Const' || t === 'Variable' || t === 'Property' || t === 'Static';
+}
+/**
+ * Look up a value-binding (Const/Variable/Property/Static) by name in
+ * the given scope's chain. Used by the value-receiver-owner bridge
+ * for object-literal services such as:
+ *
+ *   export const fooService = { getUser(id) {...} };
+ *
+ * where `fooService` is a `Const`/`Variable` whose `nodeId` is the
+ * `ownerId` of the member method. Neither `findClassBindingInScope`
+ * (rejects non-class-like) nor `findReceiverTypeBinding` (no typeBinding
+ * for an unannotated literal) finds it.
+ *
+ * Mirrors `findClassBindingInScope` exactly; only the accepted def-type
+ * predicate differs.
+ */
+export function findValueBindingInScope(startScope, receiverName, scopes) {
+    return walkScopeChain(startScope, receiverName, scopes, (def) => isOwnableValueLabel(def.type));
+}
+/**
+ * Generic scope-chain walker. Walks from `startScope` toward the root,
+ * consulting both the local `scope.bindings` channel and the dual-source
+ * `lookupBindingsAt` view (finalized + augmented). At each scope, local
+ * bindings are exhausted BEFORE imported/augmented bindings — preserves
+ * JavaScript-style lexical scoping where a local `const x` shadows an
+ * imported `x` of the same name.
+ *
+ * Returns the first binding `def` matching `predicate`. Cycles in the
+ * scope graph terminate the walk (defensive — should not occur in
+ * well-formed inputs).
+ */
+function walkScopeChain(startScope, name, scopes, predicate) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return undefined;
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return undefined;
+        // Local first: a `const x` in this scope shadows any imported `x`.
+        const localBindings = scope.bindings.get(name);
+        if (localBindings !== undefined) {
+            for (const b of localBindings) {
+                if (predicate(b.def))
+                    return b.def;
+            }
+        }
+        // Then imported/augmented bindings — only consulted when no local match.
+        const importedBindings = lookupBindingsAt(currentId, name, scopes);
+        for (const b of importedBindings) {
+            if (predicate(b.def))
+                return b.def;
+        }
+        currentId = scope.parent;
+    }
+    return undefined;
+}
 /**
  * Look up a callable (Function/Method/Constructor) by name in the
  * given scope's chain. Uses the dual-source pattern (scope.bindings +

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

@@ -46,6 +46,36 @@ export interface EnclosingClassInfo {
     className: string;
 }
 export declare const findEnclosingClassInfo: (node: SyntaxNode, filePath: string, resolveEnclosingOwner?: (node: SyntaxNode) => SyntaxNode | null) => EnclosingClassInfo | null;
+/** Object literal binding info for TS/JS shorthand methods. */
+export interface ObjectLiteralBindingInfo {
+    ownerId: string;
+}
+/**
+ * Find the file-scope variable that owns an object literal method definition.
+ *
+ * Covers TypeScript/JavaScript shorthand object methods such as:
+ *
+ *   export const service = { async load() {} };
+ *
+ * tree-sitter represents `load` as a `method_definition` inside an `object`,
+ * not inside a class container. Without this fallback, ingestion emits a
+ * top-level `Method` node but no edge from the exported `service` value to
+ * that method, so impact queries cannot discover `service.load`.
+ *
+ * Two-phase walk:
+ *   Phase A walks up from `node` tracking how many `object` ancestors we
+ *     cross. The first `variable_declarator` reached with `objectDepth >= 1`
+ *     is the candidate owner — unless `objectDepth > 1` (the method belongs
+ *     to a nested object literal; we return null rather than misattribute
+ *     to the outer binding). Hitting a function/class container before the
+ *     declarator returns null (catches IIFE-wrapped literals).
+ *   Phase B walks the declarator's own ancestors. Any function or class
+ *     ancestor before reaching `program`/`export_statement` returns null
+ *     (catches `const` declared inside a function body). Any block-statement
+ *     ancestor also returns null (catches block-scoped declarations inside
+ *     top-level `if`/`for`/`try`/etc., which cannot be imported).
+ */
+export declare const findObjectLiteralBindingInfo: (node: SyntaxNode, filePath: string) => ObjectLiteralBindingInfo | null;
 /** Convenience wrapper: returns just the class ID string (backward compat). */
 export declare const findEnclosingClassId: (node: SyntaxNode, filePath: string) => string | null;
 /**

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

@@ -385,6 +385,105 @@ export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) =>
     }
     return null;
 };
+/**
+ * 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-
+ * scoped and cannot be imported, so attributing methods to it would create
+ * false-positive cross-file edges.
+ */
+const BLOCK_SCOPE_BOUNDARY_TYPES = new Set([
+    'statement_block',
+    'if_statement',
+    'else_clause',
+    'for_statement',
+    'for_in_statement',
+    'for_of_statement',
+    'while_statement',
+    'do_statement',
+    'try_statement',
+    'catch_clause',
+    'finally_clause',
+    'switch_statement',
+    'switch_case',
+    'switch_default',
+    'with_statement',
+]);
+/**
+ * Find the file-scope variable that owns an object literal method definition.
+ *
+ * Covers TypeScript/JavaScript shorthand object methods such as:
+ *
+ *   export const service = { async load() {} };
+ *
+ * tree-sitter represents `load` as a `method_definition` inside an `object`,
+ * not inside a class container. Without this fallback, ingestion emits a
+ * top-level `Method` node but no edge from the exported `service` value to
+ * that method, so impact queries cannot discover `service.load`.
+ *
+ * Two-phase walk:
+ *   Phase A walks up from `node` tracking how many `object` ancestors we
+ *     cross. The first `variable_declarator` reached with `objectDepth >= 1`
+ *     is the candidate owner — unless `objectDepth > 1` (the method belongs
+ *     to a nested object literal; we return null rather than misattribute
+ *     to the outer binding). Hitting a function/class container before the
+ *     declarator returns null (catches IIFE-wrapped literals).
+ *   Phase B walks the declarator's own ancestors. Any function or class
+ *     ancestor before reaching `program`/`export_statement` returns null
+ *     (catches `const` declared inside a function body). Any block-statement
+ *     ancestor also returns null (catches block-scoped declarations inside
+ *     top-level `if`/`for`/`try`/etc., which cannot be imported).
+ */
+export const findObjectLiteralBindingInfo = (node, filePath) => {
+    // ── Phase A: walk up from node, count `object` ancestors, find declarator
+    let current = node;
+    let objectDepth = 0;
+    let declarator = null;
+    while (current) {
+        if (current.type === 'object') {
+            objectDepth += 1;
+        }
+        if (current.type === 'variable_declarator' && objectDepth >= 1) {
+            if (objectDepth > 1) {
+                // Method belongs to a nested object literal; safe under-approximation.
+                return null;
+            }
+            declarator = current;
+            break;
+        }
+        if (current !== node &&
+            (FUNCTION_NODE_TYPES.has(current.type) || CLASS_CONTAINER_TYPES.has(current.type))) {
+            // Function/class container encountered before owning declarator
+            // (e.g. IIFE-wrapped object literal). Bail out.
+            return null;
+        }
+        current = current.parent;
+    }
+    if (!declarator)
+        return null;
+    // ── Phase B: declarator must live at file scope (program / export_statement)
+    // with no function, class, or block-statement ancestor in between.
+    let anc = declarator.parent;
+    while (anc) {
+        if (anc.type === 'program' || anc.type === 'export_statement') {
+            break;
+        }
+        if (FUNCTION_NODE_TYPES.has(anc.type) || CLASS_CONTAINER_TYPES.has(anc.type)) {
+            return null;
+        }
+        if (BLOCK_SCOPE_BOUNDARY_TYPES.has(anc.type)) {
+            return null;
+        }
+        anc = anc.parent;
+    }
+    const nameNode = declarator.childForFieldName?.('name');
+    if (!nameNode || nameNode.type !== 'identifier')
+        return null;
+    const declaration = declarator.parent;
+    const ownerLabel = declaration?.type === 'variable_declaration' ? 'Variable' : 'Const';
+    return {
+        ownerId: generateId(ownerLabel, `${filePath}:${nameNode.text}`),
+    };
+};
 /** Convenience wrapper: returns just the class ID string (backward compat). */
 export const findEnclosingClassId = (node, filePath) => {
     return findEnclosingClassInfo(node, filePath)?.classId ?? null;