gitnexus 1.6.6-rc.31 → 1.6.6-rc.33

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/group/extractors/http-patterns/python.js

@@ -5,7 +5,12 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  *   - FastAPI `@app.get("/path")` provider decorators
  *   - `requests.get/post/...("url")` consumer calls
  *   - Generic `requests.request("METHOD", "url")` consumer calls
- *   - `httpx.AsyncClient` instances calling `.get/.post/...("url")`
+ *   - `httpx.AsyncClient` instances calling `.get/.post/...("url")`, including
+ *     aliased imports such as `import httpx as hx`,
+ *     `from httpx import AsyncClient`, and
+ *     `from httpx import AsyncClient as HttpxAsyncClient`.
+ *     Locally rebound names (e.g. `AsyncClient = mock_factory()` inside a
+ *     function) are excluded to avoid false-positive consumer contracts.
  */
 const FASTAPI_VERBS = {
     get: 'GET',
@@ -67,12 +72,48 @@ const REQUESTS_GENERIC_PATTERNS = compilePatterns({
     ],
 });
 // ─── Consumer: httpx.AsyncClient assignments ────────────────────────
-// NOTE: This targeted detector only tracks explicit `httpx.AsyncClient(...)`
-// construction. Direct imports (`from httpx import AsyncClient`) and module
-// aliases (`import httpx as hx`) and annotated assignments (`client: httpx.AsyncClient = ...`)
-// are intentionally left for a follow-up. Module-scope clients are only matched
+// Module-scope clients are only matched
 // at module scope; calls inside functions require a function/class-local tracked
 // client to avoid false positives from same-name local variables.
+const HTTPX_MODULE_IMPORT_PATTERNS = compilePatterns({
+    name: 'python-httpx-module-imports',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (import_statement
+          name: (aliased_import
+            name: (dotted_name (identifier) @module)
+            alias: (identifier) @alias))
+      `,
+        },
+    ],
+});
+const HTTPX_ASYNC_CLIENT_IMPORT_PATTERNS = compilePatterns({
+    name: 'python-httpx-async-client-imports',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (import_from_statement
+          module_name: (dotted_name (identifier) @module)
+          name: (dotted_name (identifier) @client_class))
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (import_from_statement
+          module_name: (dotted_name (identifier) @module)
+          name: (aliased_import
+            name: (dotted_name (identifier) @client_class)
+            alias: (identifier) @alias))
+      `,
+        },
+    ],
+});
 const HTTPX_ASYNC_CLIENT_ASSIGN_PATTERNS = compilePatterns({
     name: 'python-httpx-async-client-assign',
     language: Python,
@@ -84,8 +125,23 @@ const HTTPX_ASYNC_CLIENT_ASSIGN_PATTERNS = compilePatterns({
           left: (_) @client
           right: (call
             function: (attribute
-              object: (identifier) @module (#eq? @module "httpx")
-              attribute: (identifier) @client_class (#eq? @client_class "AsyncClient"))))
+              object: (identifier) @module
+              attribute: (identifier) @client_class)))
+      `,
+        },
+    ],
+});
+const HTTPX_ASYNC_CLIENT_DIRECT_ASSIGN_PATTERNS = compilePatterns({
+    name: 'python-httpx-async-client-direct-assign',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (assignment
+          left: (_) @client
+          right: (call
+            function: (identifier) @client_class))
       `,
         },
     ],
@@ -101,8 +157,23 @@ const HTTPX_ASYNC_CLIENT_WITH_ALIAS_PATTERNS = compilePatterns({
         (as_pattern
           (call
             function: (attribute
-              object: (identifier) @module (#eq? @module "httpx")
-              attribute: (identifier) @client_class (#eq? @client_class "AsyncClient")))
+              object: (identifier) @module
+              attribute: (identifier) @client_class))
+          (as_pattern_target (identifier) @client))
+      `,
+        },
+    ],
+});
+const HTTPX_ASYNC_CLIENT_DIRECT_WITH_ALIAS_PATTERNS = compilePatterns({
+    name: 'python-httpx-async-client-direct-with-alias',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (as_pattern
+          (call
+            function: (identifier) @client_class)
           (as_pattern_target (identifier) @client))
       `,
         },
@@ -131,14 +202,120 @@ function trackedClientScopeKey(clientNode) {
     return getScopeKey(clientNode.parent, clientNode.text.includes('.'));
 }
 function callScopeKeys(clientNode) {
-    const keys = new Set();
-    const preferClass = clientNode.text.includes('.');
-    const nearestScope = getScopeKey(clientNode.parent, preferClass);
-    keys.add(nearestScope);
-    return [...keys];
+    return [getScopeKey(clientNode.parent, clientNode.text.includes('.'))];
+}
+// Returns the scope key that a rebind of an imported alias would shadow under
+// Python LEGB rules, or `null` when the rebind does not shadow anything that
+// could produce a false-positive consumer detection.
+//   - Rebind inside a function/method → that function's scope.
+//   - Rebind at module top level → 'module' (shadows the whole file).
+//   - Rebind in a class body without an enclosing function → null. Python
+//     class attributes do not shadow bare-name lookups inside methods (methods
+//     see the module binding, not the class attribute), so we must not poison
+//     them.
+function shadowScopeKey(node) {
+    let current = node;
+    let passedThroughClass = false;
+    while (current) {
+        if (current.type === 'function_definition') {
+            // Reuse getScopeKey's key format so the two helpers cannot drift apart.
+            return getScopeKey(current);
+        }
+        if (current.type === 'class_definition') {
+            passedThroughClass = true;
+        }
+        current = current.parent;
+    }
+    return passedThroughClass ? null : 'module';
+}
+function collectHttpxImportAliases(tree) {
+    const moduleAliases = new Set(['httpx']);
+    const asyncClientAliases = new Set();
+    // The @module capture is a single identifier inside a `dotted_name`, so for
+    // `import package.httpx as hx` the pattern would match the inner `httpx`
+    // segment. Check the full `dotted_name` text via `parent` to anchor the match.
+    for (const match of runCompiledPatterns(HTTPX_MODULE_IMPORT_PATTERNS, tree)) {
+        const moduleNode = match.captures.module;
+        const aliasNode = match.captures.alias;
+        if (moduleNode?.parent?.text === 'httpx' && aliasNode)
+            moduleAliases.add(aliasNode.text);
+    }
+    for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_IMPORT_PATTERNS, tree)) {
+        const moduleNode = match.captures.module;
+        const classNode = match.captures.client_class;
+        if (moduleNode?.parent?.text !== 'httpx' || classNode?.text !== 'AsyncClient')
+            continue;
+        asyncClientAliases.add(match.captures.alias?.text ?? classNode.text);
+    }
+    return { moduleAliases, asyncClientAliases };
+}
+// Tracks local rebindings (`AsyncClient = ...`, `hx = ...`) that shadow an
+// imported alias. We treat the whole enclosing scope (module, class, or
+// function) as shadowed for that alias name, so subsequent constructions in
+// that scope are not falsely detected as httpx consumers. Covers bare-identifier
+// targets and the common tuple / list destructuring shapes.
+const ALIAS_SHADOW_PATTERNS = compilePatterns({
+    name: 'python-httpx-alias-shadow',
+    language: Python,
+    patterns: [
+        {
+            meta: {},
+            query: `(assignment left: (identifier) @name)`,
+        },
+        {
+            meta: {},
+            query: `(assignment left: (pattern_list (identifier) @name))`,
+        },
+        {
+            meta: {},
+            query: `(assignment left: (tuple_pattern (identifier) @name))`,
+        },
+        {
+            meta: {},
+            query: `(assignment left: (list_pattern (identifier) @name))`,
+        },
+    ],
+});
+function collectAliasShadowScopes(tree, aliases) {
+    const shadowed = new Map();
+    if (aliases.size === 0)
+        return shadowed;
+    for (const match of runCompiledPatterns(ALIAS_SHADOW_PATTERNS, tree)) {
+        const nameNode = match.captures.name;
+        if (!nameNode || !aliases.has(nameNode.text))
+            continue;
+        const scopeKey = shadowScopeKey(nameNode.parent);
+        if (scopeKey === null)
+            continue;
+        const set = shadowed.get(nameNode.text) ?? new Set();
+        set.add(scopeKey);
+        shadowed.set(nameNode.text, set);
+    }
+    return shadowed;
+}
+function isAliasShadowed(shadowed, aliasName, node) {
+    const scopes = shadowed.get(aliasName);
+    if (!scopes || scopes.size === 0)
+        return false;
+    let current = node.parent;
+    while (current) {
+        if (current.type === 'function_definition') {
+            // Reuse getScopeKey's key format so the two helpers cannot drift apart.
+            if (scopes.has(getScopeKey(current)))
+                return true;
+        }
+        current = current.parent;
+    }
+    // A module-level rebind shadows the alias for the entire file.
+    return scopes.has('module');
 }
 function collectHttpxAsyncClients(tree) {
     const clients = new Map();
+    const { moduleAliases, asyncClientAliases } = collectHttpxImportAliases(tree);
+    // Module aliases (`hx`) and AsyncClient aliases (`AsyncClient`,
+    // `HttpxAsyncClient`) share disjoint name spaces, so one shadow map keyed by
+    // alias name serves both lookups and we only walk the tree for rebinds once.
+    const shadowed = collectAliasShadowScopes(tree, new Set([...moduleAliases, ...asyncClientAliases]));
     const addClient = (clientNode) => {
         if (!clientNode)
             return;
@@ -149,9 +326,41 @@ function collectHttpxAsyncClients(tree) {
         clients.set(clientText, scopes);
     };
     for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_ASSIGN_PATTERNS, tree)) {
+        const moduleNode = match.captures.module;
+        const classNode = match.captures.client_class;
+        if (!moduleNode || !classNode)
+            continue;
+        if (!moduleAliases.has(moduleNode.text) || classNode.text !== 'AsyncClient')
+            continue;
+        if (isAliasShadowed(shadowed, moduleNode.text, moduleNode))
+            continue;
+        addClient(match.captures.client);
+    }
+    for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_DIRECT_ASSIGN_PATTERNS, tree)) {
+        const classNode = match.captures.client_class;
+        if (!classNode || !asyncClientAliases.has(classNode.text))
+            continue;
+        if (isAliasShadowed(shadowed, classNode.text, classNode))
+            continue;
         addClient(match.captures.client);
     }
     for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_WITH_ALIAS_PATTERNS, tree)) {
+        const moduleNode = match.captures.module;
+        const classNode = match.captures.client_class;
+        if (!moduleNode || !classNode)
+            continue;
+        if (!moduleAliases.has(moduleNode.text) || classNode.text !== 'AsyncClient')
+            continue;
+        if (isAliasShadowed(shadowed, moduleNode.text, moduleNode))
+            continue;
+        addClient(match.captures.client);
+    }
+    for (const match of runCompiledPatterns(HTTPX_ASYNC_CLIENT_DIRECT_WITH_ALIAS_PATTERNS, tree)) {
+        const classNode = match.captures.client_class;
+        if (!classNode || !asyncClientAliases.has(classNode.text))
+            continue;
+        if (isAliasShadowed(shadowed, classNode.text, classNode))
+            continue;
         addClient(match.captures.client);
     }
     return clients;

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 +