gitnexus 1.6.9 → 1.6.10-aptos.1

package/dist/core/ingestion/languages/php/import-decomposer.js

@@ -98,6 +98,7 @@ function parseUseClause(clause, qualifier) {
             if (alias !== '') {
                 return {
                     kind: 'alias',
+                    symbolKind: symbolKindFor(qualifier),
                     source,
                     name: alias,
                     alias,
@@ -108,6 +109,7 @@ function parseUseClause(clause, qualifier) {
     }
     return {
         kind: qualifier,
+        symbolKind: symbolKindFor(qualifier),
         source,
         name: lastSegment(source),
         atNode: clause,
@@ -178,6 +180,7 @@ function parseInnerClause(clause, prefix, qualifier) {
             if (alias !== '') {
                 return {
                     kind: 'alias',
+                    symbolKind: symbolKindFor(qualifier),
                     source,
                     name: alias,
                     alias,
@@ -188,6 +191,7 @@ function parseInnerClause(clause, prefix, qualifier) {
     }
     return {
         kind: qualifier,
+        symbolKind: symbolKindFor(qualifier),
         source,
         name: lastSegment(innerPath),
         atNode: clause,
@@ -198,6 +202,7 @@ function buildImportMatch(stmtNode, spec) {
     const m = {
         '@import.statement': nodeToCapture('@import.statement', stmtNode),
         '@import.kind': syntheticCapture('@import.kind', spec.atNode, spec.kind),
+        '@import.symbol-kind': syntheticCapture('@import.symbol-kind', spec.atNode, spec.symbolKind),
         '@import.source': syntheticCapture('@import.source', spec.atNode, spec.source),
         '@import.name': syntheticCapture('@import.name', spec.atNode, spec.name),
     };
@@ -212,6 +217,13 @@ function lastSegment(path) {
     const parts = path.split('\\').filter(Boolean);
     return parts[parts.length - 1] ?? path;
 }
+function symbolKindFor(kind) {
+    if (kind === 'function')
+        return 'function';
+    if (kind === 'const')
+        return 'const';
+    return 'type';
+}
 /** Find the first named child with a given node type. */
 function findNamedChild(node, type) {
     for (let i = 0; i < node.namedChildCount; i++) {

package/dist/core/ingestion/languages/php/import-target.d.ts

@@ -15,6 +15,7 @@
  * `linkStatus: 'unresolved'`.
  */
 import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+import type { ImportResolutionContext } from '../../scope-resolution/contract/scope-resolver.js';
 import type { ComposerConfig } from '../../language-config.js';
 export interface PhpResolveContext {
     readonly fromFile: string;
@@ -44,4 +45,4 @@ export declare function resolvePhpImportTarget(parsedImport: ParsedImport, works
  * (a `ComposerConfig | null` loaded once per workspace by
  * `loadPhpComposerConfig`) and threads it into `resolvePhpImportInternal`.
  */
-export declare function resolvePhpImportTargetInternal(targetRaw: string, _fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown): string | null;
+export declare function resolvePhpImportTargetInternal(targetRaw: string, _fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown, context?: ImportResolutionContext): string | null;

package/dist/core/ingestion/languages/php/import-target.js

@@ -17,6 +17,73 @@
 import { resolvePhpImportInternal } from '../../import-resolvers/php.js';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
+function normalizePhpPath(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+function namespaceDirectories(targetRaw, composerConfig, resolved) {
+    const directories = new Set();
+    if (resolved !== null) {
+        const normalizedResolved = normalizePhpPath(resolved);
+        const separator = normalizedResolved.lastIndexOf('/');
+        if (separator >= 0)
+            directories.add(normalizedResolved.slice(0, separator));
+    }
+    if (composerConfig === null)
+        return [...directories];
+    const normalizedTarget = normalizePhpPath(targetRaw);
+    const mappings = [...composerConfig.psr4.entries()].sort((left, right) => {
+        const lengthDifference = right[0].length - left[0].length;
+        return lengthDifference !== 0 ? lengthDifference : left[0].localeCompare(right[0]);
+    });
+    for (const [namespacePrefix, directoryPrefix] of mappings) {
+        const normalizedPrefix = normalizePhpPath(namespacePrefix);
+        if (normalizedTarget !== normalizedPrefix &&
+            !normalizedTarget.startsWith(`${normalizedPrefix}/`)) {
+            continue;
+        }
+        const remainder = normalizedTarget.slice(normalizedPrefix.length).replace(/^\//, '');
+        const separator = remainder.lastIndexOf('/');
+        const relativeNamespace = separator >= 0 ? remainder.slice(0, separator) : '';
+        directories.add(normalizePhpPath(relativeNamespace === '' ? directoryPrefix : `${directoryPrefix}/${relativeNamespace}`));
+        break;
+    }
+    return [...directories];
+}
+// A scope-resolution pass shares one stable parsedFiles array across imports.
+const phpDirectoryIndexCache = new WeakMap();
+function parentDirectory(filePath) {
+    const normalizedPath = normalizePhpPath(filePath);
+    const separator = normalizedPath.lastIndexOf('/');
+    return separator < 0 ? '' : normalizedPath.slice(0, separator);
+}
+function directoryAliases(filePath) {
+    const normalizedPath = normalizePhpPath(filePath);
+    const separator = normalizedPath.lastIndexOf('/');
+    if (separator < 0)
+        return [''];
+    const parent = normalizedPath.slice(0, separator);
+    const aliases = new Set([parent]);
+    const segments = parent.split('/').filter(Boolean);
+    for (let index = 0; index < segments.length; index++) {
+        aliases.add(segments.slice(index).join('/'));
+    }
+    return [...aliases];
+}
+function filesByDirectory(parsedFiles) {
+    const cached = phpDirectoryIndexCache.get(parsedFiles);
+    if (cached)
+        return cached;
+    const mutable = new Map();
+    for (const parsed of parsedFiles) {
+        for (const directory of directoryAliases(parsed.filePath)) {
+            const files = mutable.get(directory) ?? [];
+            files.push(parsed);
+            mutable.set(directory, files);
+        }
+    }
+    phpDirectoryIndexCache.set(parsedFiles, mutable);
+    return mutable;
+}
 // ─── loadResolutionConfig ──────────────────────────────────────────────────
 /**
  * Load and parse `composer.json` from the repo root. Returns a
@@ -87,7 +154,7 @@ export function resolvePhpImportTarget(parsedImport, workspaceIndex) {
  * (a `ComposerConfig | null` loaded once per workspace by
  * `loadPhpComposerConfig`) and threads it into `resolvePhpImportInternal`.
  */
-export function resolvePhpImportTargetInternal(targetRaw, _fromFile, allFilePaths, resolutionConfig) {
+export function resolvePhpImportTargetInternal(targetRaw, _fromFile, allFilePaths, resolutionConfig, context) {
     if (targetRaw === '')
         return null;
     const composerConfig = resolutionConfig !== undefined && resolutionConfig !== null
@@ -96,5 +163,46 @@ export function resolvePhpImportTargetInternal(targetRaw, _fromFile, allFilePath
     const allFiles = allFilePaths;
     const normalizedFileList = [...allFiles].map((f) => f.replace(/\\/g, '/'));
     const allFileList = [...allFiles];
-    return resolvePhpImportInternal(targetRaw, composerConfig, allFiles, normalizedFileList, allFileList, undefined);
+    const resolved = resolvePhpImportInternal(targetRaw, composerConfig, allFiles, normalizedFileList, allFileList, undefined);
+    const parsedImport = context?.parsedImport;
+    const symbolKind = parsedImport?.kind === 'named' || parsedImport?.kind === 'alias'
+        ? parsedImport.importedSymbolKind
+        : undefined;
+    if (context === undefined ||
+        parsedImport === undefined ||
+        (symbolKind !== 'function' && symbolKind !== 'const')) {
+        return resolved;
+    }
+    const importedName = targetRaw.replace(/\\/g, '/').split('/').filter(Boolean).at(-1);
+    if (importedName === undefined)
+        return resolved;
+    const directories = namespaceDirectories(targetRaw, composerConfig, resolved);
+    const directoryIndex = filesByDirectory(context.parsedFiles);
+    const candidateFiles = [
+        ...new Set(directories.flatMap((directory) => {
+            const files = directoryIndex.get(normalizePhpPath(directory)) ?? [];
+            // A suffix alias can match directories under different roots (for
+            // example app/Models and vendor/pkg/app/Models). Picking either root
+            // would be a guess, so fail closed to the composer resolution instead.
+            const distinctParents = new Set(files.map((file) => parentDirectory(file.filePath)));
+            return distinctParents.size > 1 ? [] : files;
+        })),
+    ];
+    const expectedType = symbolKind === 'function' ? 'Function' : 'Variable';
+    const declaringFiles = candidateFiles.filter((parsed) => parsed.localDefs.some((def) => {
+        if (def.type !== expectedType)
+            return false;
+        const simpleName = (def.qualifiedName ?? '').split(/[\\.]/).at(-1);
+        return simpleName === importedName;
+    }));
+    if (declaringFiles.length > 1)
+        return null;
+    if (declaringFiles.length === 1)
+        return declaringFiles[0].filePath;
+    // PHP constants are not currently emitted as local definitions. A single
+    // file in the namespace directory is still unambiguous; multiple files must
+    // fail closed rather than inheriting Set iteration order.
+    if (symbolKind === 'const' && candidateFiles.length === 1)
+        return candidateFiles[0].filePath;
+    return resolved;
 }

package/dist/core/ingestion/languages/php/interpret.js

@@ -16,12 +16,18 @@ export function interpretPhpImport(captures) {
     const sourceCap = captures['@import.source'];
     const nameCap = captures['@import.name'];
     const aliasCap = captures['@import.alias'];
+    const symbolKindCap = captures['@import.symbol-kind'];
     const kind = kindCap?.text;
     if (kind === undefined || sourceCap === undefined)
         return null;
     const source = sourceCap.text.trim();
     if (source === '')
         return null;
+    const importedSymbolKind = symbolKindCap?.text === 'function' || symbolKindCap?.text === 'const'
+        ? symbolKindCap.text
+        : kind === 'function' || kind === 'const'
+            ? kind
+            : 'type';
     switch (kind) {
         case 'namespace': {
             // `use Foo\Bar;` — PHP `use` is a NAMED import (binds the class
@@ -34,6 +40,7 @@ export function interpretPhpImport(captures) {
                 localName,
                 importedName: localName,
                 targetRaw: source,
+                importedSymbolKind,
             };
         }
         case 'alias': {
@@ -50,6 +57,7 @@ export function interpretPhpImport(captures) {
                 importedName,
                 alias,
                 targetRaw: source,
+                importedSymbolKind,
             };
         }
         case 'function': {
@@ -61,6 +69,7 @@ export function interpretPhpImport(captures) {
                 localName,
                 importedName: localName,
                 targetRaw: source,
+                importedSymbolKind,
             };
         }
         case 'const': {
@@ -71,6 +80,7 @@ export function interpretPhpImport(captures) {
                 localName,
                 importedName: localName,
                 targetRaw: source,
+                importedSymbolKind,
             };
         }
         default:

package/dist/core/ingestion/languages/php/scope-resolver.js

@@ -308,7 +308,7 @@ const phpScopeResolver = {
     language: SupportedLanguages.PHP,
     languageProvider: phpProvider,
     importEdgeReason: 'php-scope: use',
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => resolvePhpImportTargetInternal(targetRaw, fromFile, allFilePaths, resolutionConfig),
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig, context) => resolvePhpImportTargetInternal(targetRaw, fromFile, allFilePaths, resolutionConfig, context),
     loadResolutionConfig: (repoPath) => loadPhpComposerConfig(repoPath),
     // PHP LEGB-like precedence: local > import/namespace/reexport > wildcard.
     // The per-scope id is unused by phpMergeBindings (tier ordering computed

package/dist/core/ingestion/languages/python/captures.d.ts

@@ -8,10 +8,9 @@
  *   1. **Per-name import statements** — `import a, b` and
  *      `from m import x, y` decompose to one match per imported name
  *      (see `import-decomposer.ts`).
- *   2. **Receiver type bindings** — each `function_definition` inside a
- *      class body emits a `@type-binding.self` (or `@type-binding.cls`
- *      for `@classmethod`) capture so Pass-4 attaches the implicit
- *      receiver (see `receiver-binding.ts`).
+ *   2. **Receiver type bindings** — methods emit an implicit `self` / `cls`
+ *      binding, and `__init__` assignments from annotated parameters emit
+ *      class-scoped instance-field bindings (see `receiver-binding.ts`).
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */

package/dist/core/ingestion/languages/python/captures.js

@@ -8,23 +8,40 @@
  *   1. **Per-name import statements** — `import a, b` and
  *      `from m import x, y` decompose to one match per imported name
  *      (see `import-decomposer.ts`).
- *   2. **Receiver type bindings** — each `function_definition` inside a
- *      class body emits a `@type-binding.self` (or `@type-binding.cls`
- *      for `@classmethod`) capture so Pass-4 attaches the implicit
- *      receiver (see `receiver-binding.ts`).
+ *   2. **Receiver type bindings** — methods emit an implicit `self` / `cls`
+ *      binding, and `__init__` assignments from annotated parameters emit
+ *      class-scoped instance-field bindings (see `receiver-binding.ts`).
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */
 import { nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { splitImportStatement } from './import-decomposer.js';
 import { getPythonParser, getPythonScopeQuery } from './query.js';
-import { synthesizeReceiverTypeBinding } from './receiver-binding.js';
+import { synthesizeConstructorFieldTypeBindings, synthesizeReceiverTypeBinding, } from './receiver-binding.js';
 import { synthesizeDependsReferences } from './depends-references.js';
 import { computePythonArityMetadata } from './arity-metadata.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { pythonFunctionDefinitionLabel } from './simple-hooks.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+const PYTHON_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_definition', 'lambda']),
+    callNodeTypes: new Set(['call']),
+    parameterListNodeTypes: new Set(['parameters', 'argument_list']),
+    parameterNodeTypes: new Set([
+        'identifier',
+        'default_parameter',
+        'typed_parameter',
+        'typed_default_parameter',
+        'list_splat_pattern',
+        'dictionary_splat_pattern',
+    ]),
+    bindingNodeTypes: new Set(['assignment', 'named_expression']),
+    assignmentNodeTypes: new Set(['assignment', 'named_expression']),
+    identifierNodeTypes: new Set(['identifier']),
+    functionScopedValueBindings: true,
+};
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // Skip the parse when the caller (the scope-resolution orchestrator's
     // `treeCache`) already produced a Tree for this source — empty under
@@ -104,6 +121,7 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
                 const synth = synthesizeReceiverTypeBinding(fnNode);
                 if (synth !== null)
                     out.push(synth);
+                out.push(...synthesizeConstructorFieldTypeBindings(fnNode));
                 for (const depRef of synthesizeDependsReferences(fnNode))
                     out.push(depRef);
             }
@@ -145,6 +163,7 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
         out.push(grouped);
     }
     out.push(...synthesizePythonInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, PYTHON_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**

package/dist/core/ingestion/languages/python/interpret.js

@@ -118,6 +118,10 @@ export function interpretPythonTypeBinding(captures) {
     // `Registry.lookup` Step 2 treats them identically.
     else if (captures['@type-binding.cls'] !== undefined)
         source = 'self';
+    else if (captures['@type-binding.instance-field'] !== undefined) {
+        source =
+            captures['@type-binding.parameter'] !== undefined ? 'parameter-annotation' : 'annotation';
+    }
     else if (captures['@type-binding.constructor'] !== undefined)
         source = 'constructor-inferred';
     else if (captures['@type-binding.annotation'] !== undefined)

package/dist/core/ingestion/languages/python/receiver-binding.d.ts

@@ -1,6 +1,6 @@
 /**
- * Synthesize `@type-binding.self` / `@type-binding.cls` captures for
- * methods.
+ * Synthesize implicit receiver and constructor-assigned field type bindings
+ * for methods.
  *
  * Tree-sitter can't easily express "the first parameter of a function
  * defined directly inside a class body" via a single static query.
@@ -19,3 +19,16 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * 'function_definition'`.
  */
 export declare function synthesizeReceiverTypeBinding(fnNode: SyntaxNode): CaptureMatch | null;
+/**
+ * Synthesize class-scope field bindings for the common Python constructor
+ * injection pattern:
+ *
+ *   def __init__(self, service: Service):
+ *       self.service = service
+ *
+ * An explicit field annotation (`self.service: Service = ...`) is also
+ * accepted and takes precedence over a parameter annotation. Deliberately do
+ * not infer from arbitrary unannotated RHS expressions: the receiver resolver
+ * needs a declared type, not a name-only guess.
+ */
+export declare function synthesizeConstructorFieldTypeBindings(fnNode: SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/python/receiver-binding.js

@@ -1,6 +1,6 @@
 /**
- * Synthesize `@type-binding.self` / `@type-binding.cls` captures for
- * methods.
+ * Synthesize implicit receiver and constructor-assigned field type bindings
+ * for methods.
  *
  * Tree-sitter can't easily express "the first parameter of a function
  * defined directly inside a class body" via a single static query.
@@ -114,3 +114,97 @@ export function synthesizeReceiverTypeBinding(fnNode) {
         '@type-binding.type': syntheticCapture('@type-binding.type', first, className),
     };
 }
+/**
+ * Synthesize class-scope field bindings for the common Python constructor
+ * injection pattern:
+ *
+ *   def __init__(self, service: Service):
+ *       self.service = service
+ *
+ * An explicit field annotation (`self.service: Service = ...`) is also
+ * accepted and takes precedence over a parameter annotation. Deliberately do
+ * not infer from arbitrary unannotated RHS expressions: the receiver resolver
+ * needs a declared type, not a name-only guess.
+ */
+export function synthesizeConstructorFieldTypeBindings(fnNode) {
+    if (fnNode.childForFieldName('name')?.text !== '__init__')
+        return [];
+    if (findEnclosingClassDefinition(fnNode) === null)
+        return [];
+    if (hasDecorator(fnNode, 'staticmethod') || hasDecorator(fnNode, 'classmethod'))
+        return [];
+    const receiver = synthesizeReceiverTypeBinding(fnNode);
+    const receiverName = receiver?.['@type-binding.self']?.text;
+    if (receiverName === undefined)
+        return [];
+    const parameters = fnNode.childForFieldName('parameters');
+    const body = fnNode.childForFieldName('body');
+    if (parameters === null || body === null)
+        return [];
+    const parameterTypes = new Map();
+    for (let i = 0; i < parameters.namedChildCount; i++) {
+        const parameter = parameters.namedChild(i);
+        if (parameter === null)
+            continue;
+        const name = firstParameterName(parameter);
+        const annotation = parameter.childForFieldName('type');
+        if (name !== null && annotation !== null)
+            parameterTypes.set(name, annotation.text);
+    }
+    const candidates = new Map();
+    const stack = [body];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node !== body &&
+            (node.type === 'function_definition' ||
+                node.type === 'lambda' ||
+                node.type === 'class_definition' ||
+                node.type === 'if_statement' ||
+                node.type === 'for_statement' ||
+                node.type === 'while_statement' ||
+                node.type === 'try_statement' ||
+                node.type === 'match_statement')) {
+            continue;
+        }
+        if (node.type === 'assignment') {
+            const left = node.childForFieldName('left');
+            const right = node.childForFieldName('right');
+            if (left?.type === 'attribute') {
+                const object = left.childForFieldName('object');
+                const field = left.childForFieldName('attribute');
+                if (object?.type === 'identifier' && object.text === receiverName && field !== null) {
+                    const explicitType = node.childForFieldName('type');
+                    const parameterType = right?.type === 'identifier' ? parameterTypes.get(right.text) : undefined;
+                    const typeName = explicitType?.text ?? parameterType;
+                    if (typeName !== undefined) {
+                        const explicit = explicitType !== null;
+                        const existing = candidates.get(field.text);
+                        if (existing === undefined || explicit || !existing.explicit) {
+                            candidates.set(field.text, {
+                                explicit,
+                                match: {
+                                    '@type-binding.name': syntheticCapture('@type-binding.name', field, field.text),
+                                    '@type-binding.type': syntheticCapture('@type-binding.type', explicitType ?? right ?? field, typeName),
+                                    ...(explicit
+                                        ? {}
+                                        : {
+                                            '@type-binding.parameter': syntheticCapture('@type-binding.parameter', right ?? field, '1'),
+                                        }),
+                                    '@type-binding.instance-field': syntheticCapture('@type-binding.instance-field', node, '1'),
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Push in reverse so the LIFO walk visits source order. That keeps Map
+        // insertion order (and therefore emitted capture order) deterministic.
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return [...candidates.values()].map(({ match }) => match);
+}

package/dist/core/ingestion/languages/python/simple-hooks.d.ts

@@ -9,11 +9,11 @@ import type { CaptureMatch, NodeLabel, ParsedImport, Scope, ScopeId, ScopeTree,
 import type { SyntaxNode } from 'tree-sitter';
 export declare function pythonFunctionDefinitionLabel(functionNode: SyntaxNode, defaultLabel: NodeLabel): NodeLabel;
 /** Python has no block scope, so the central extractor's "innermost
- *  enclosing scope" default is already correct: `for x in …` creates
- *  `x` in the enclosing function/module scope (because we never emit a
- *  `@scope.block` for the for-loop body), comprehension variables stay
- *  in their expression context, etc. Returns `null` to delegate. */
-export declare function pythonBindingScopeFor(_decl: CaptureMatch, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+ *  enclosing scope" default is already correct for ordinary bindings.
+ *  Constructor-injected instance fields are the exception: their marker is
+ *  anchored inside `__init__`, but compound receiver resolution needs the
+ *  field type on the enclosing Class scope. */
+export declare function pythonBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
 /** Function-local `from x import Y` should attach the binding to the
  *  function scope, not the module. Class-body imports (rare but legal —
  *  `class A: import x` makes `x` a class attribute) attach to the class.

package/dist/core/ingestion/languages/python/simple-hooks.js

@@ -15,11 +15,21 @@ export function pythonFunctionDefinitionLabel(functionNode, defaultLabel) {
 }
 // ─── bindingScopeFor ──────────────────────────────────────────────────────
 /** Python has no block scope, so the central extractor's "innermost
- *  enclosing scope" default is already correct: `for x in …` creates
- *  `x` in the enclosing function/module scope (because we never emit a
- *  `@scope.block` for the for-loop body), comprehension variables stay
- *  in their expression context, etc. Returns `null` to delegate. */
-export function pythonBindingScopeFor(_decl, _innermost, _tree) {
+ *  enclosing scope" default is already correct for ordinary bindings.
+ *  Constructor-injected instance fields are the exception: their marker is
+ *  anchored inside `__init__`, but compound receiver resolution needs the
+ *  field type on the enclosing Class scope. */
+export function pythonBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.instance-field'] !== undefined) {
+        let current = innermost;
+        while (current !== undefined) {
+            if (current.kind === 'Class')
+                return current.id;
+            if (current.parent === null)
+                break;
+            current = tree.getScope(current.parent);
+        }
+    }
     return null;
 }
 // ─── importOwningScope ────────────────────────────────────────────────────

package/dist/core/ingestion/languages/ruby/captures.js

@@ -6,6 +6,7 @@ import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitQualifiedName } from '../../utils/qualified-name.js';
 import { encodeMarker } from '../../utils/heritage-marker.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 const FUNCTION_NODE_TYPES = ['method', 'singleton_method'];
 const HERITAGE_CALL_NAMES = new Set(['include', 'extend', 'prepend']);
 const ATTR_CALL_NAMES = new Set([
@@ -13,6 +14,46 @@ const ATTR_CALL_NAMES = new Set([
     'attr_reader',
     'attr_writer',
 ]);
+const RUBY_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['method', 'singleton_method', 'lambda']),
+    callNodeTypes: new Set(['call']),
+    parameterListNodeTypes: new Set(['method_parameters', 'argument_list']),
+    parameterNodeTypes: new Set([
+        'identifier',
+        'optional_parameter',
+        'splat_parameter',
+        'hash_splat_parameter',
+        'block_parameter',
+    ]),
+    bindingNodeTypes: new Set(['assignment']),
+    assignmentNodeTypes: new Set(['assignment', 'operator_assignment']),
+    identifierNodeTypes: new Set([
+        'identifier',
+        'constant',
+        'instance_variable',
+        'class_variable',
+        'global_variable',
+    ]),
+    functionScopedValueBindings: true,
+    callableProtocolMethods: new Set(['call']),
+    // A bare receiver-less identifier in value position is a method CALL in
+    // Ruby (`action = process` stores process's RETURN value) — only explicit
+    // reference forms (method(:x), &:x, lambda/proc) reference the callable.
+    bareNamesAreCalls: true,
+    extractCallableReference: (node) => {
+        if (node.type !== 'call')
+            return undefined;
+        const method = node.childForFieldName('method');
+        if (method?.text !== 'method' && method?.text !== 'public_method')
+            return undefined;
+        const args = node.childForFieldName('arguments');
+        const symbol = args?.namedChildren.find((child) => child !== null && child.type === 'simple_symbol');
+        if (symbol === undefined)
+            return undefined;
+        const name = symbol.text.replace(/^:/, '');
+        return name.length === 0 ? undefined : { name, anchor: symbol };
+    },
+};
 /**
  * Build the full `.`-joined qualified owner name for a heritage/attr call by
  * walking ALL enclosing class/module ancestors (not just the immediate one),
@@ -400,6 +441,7 @@ export function emitRubyScopeCaptures(sourceText, _filePath, cachedTree) {
     // flow through `emitHeritageEdges` (the `__heritage__:` import path above),
     // an independent lane that stays intact when the legacy heritage leg is gated off.
     out.push(...synthesizeRubySuperclassReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, RUBY_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**

package/dist/core/ingestion/languages/rust/captures.js

@@ -5,6 +5,18 @@ import { splitRustUseDeclaration } from './import-decomposer.js';
 import { synthesizeRustReceiverBinding } from './receiver-binding.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+const RUST_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_item', 'closure_expression']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameters', 'arguments']),
+    parameterNodeTypes: new Set(['parameter', 'self_parameter']),
+    bindingNodeTypes: new Set(['let_declaration']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'type_identifier', 'field_identifier']),
+    callableReferenceNodeTypes: new Set(['scoped_identifier']),
+    normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+};
 export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -117,6 +129,7 @@ export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
         out.push(grouped);
     }
     out.push(...synthesizeRustInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, RUST_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**