gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

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

@@ -15,8 +15,189 @@
  * `linkStatus: 'unresolved'`.
  */
 import { resolvePhpImportInternal } from '../../import-resolvers/php.js';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
+import { getWorkspaceFileIndex } from '../../import-resolvers/workspace-file-index.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];
+}
+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];
+}
+/**
+ * Directory alias → the files under it, built once per pass.
+ *
+ * A scope-resolution pass shares one stable `parsedFiles` array across imports,
+ * so the array identity is the memo key — see `perFileSet`.
+ */
+const filesByDirectory = perFileSet((parsedFiles) => {
+    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);
+        }
+    }
+    return mutable;
+});
+/** Memoized on the `allFilePaths` Set identity, like `getWorkspaceFileIndex`. */
+const getPhpWorkspaceIndex = perFileSet((allFilePaths) => {
+    // The Set is passed THROUGH to the shared cache, never copied — a defensive
+    // `new Set(...)` here or in `scope-resolver.ts` would hand both WeakMaps a
+    // fresh key per import and silently restore O(imports × files) (#1918 P1).
+    const { normalized, all, index } = getWorkspaceFileIndex(allFilePaths);
+    /**
+     * Whole-path-lowercase → the first PROPER-suffix match, the correction `get`
+     * applies to a whole-path hit from the shared index.
+     *
+     * DEFERRED, and deferred all the way to the branch that reads it rather than
+     * to the first `get`. The builder walks every slash of every path and
+     * lowercases a slice at each, so it is O(paths × depth) in both time and
+     * allocation — measured 46.0 ms at 32 000 paths on the PHP arm of
+     * `bench/import-target/`, filling a map that held ZERO entries, because it
+     * can only hold one when some file's whole path is also a proper suffix of
+     * another's. Most repos never produce that, and the ones that do reach this
+     * branch only for the imports that actually hit a whole path. Pure function
+     * of `normalized`/`all`, both of which the returned object already retains,
+     * so building it late is behaviour-identical and retains nothing new.
+     *
+     * `wholePathLower` is a scratch set of the builder, not state: nothing reads
+     * it afterwards, so deferring the map defers it too.
+     */
+    let firstProperSuffixMatch = null;
+    const getFirstProperSuffixMatch = () => {
+        if (firstProperSuffixMatch !== null)
+            return firstProperSuffixMatch;
+        const wholePathLower = new Set();
+        for (const path of normalized)
+            wholePathLower.add(path.toLowerCase());
+        // Only the suffixes that a whole path can shadow are worth storing; see the
+        // header. Built from `normalized`, so it costs no traversal of the Set.
+        const built = new Map();
+        for (let i = 0; i < normalized.length; i++) {
+            const lower = normalized[i].toLowerCase();
+            for (let slash = lower.indexOf('/'); slash >= 0; slash = lower.indexOf('/', slash + 1)) {
+                const suffix = lower.slice(slash + 1);
+                if (!wholePathLower.has(suffix))
+                    continue;
+                if (!built.has(suffix))
+                    built.set(suffix, all[i]);
+            }
+        }
+        firstProperSuffixMatch = built;
+        return built;
+    };
+    /**
+     * Raw directory → the files directly in it, for `getFilesInDir`.
+     *
+     * DEFERRED for the same reason as the shared `dirMap` (#2903), and here the
+     * case is stronger: `getFilesInDir` has exactly one caller,
+     * `import-resolvers/php.ts`'s PSR-4 function/constant fallback, and that
+     * caller sits inside `if (composerConfig) { … }`. `resolvePhpImportTarget`
+     * hard-codes `composerConfig: null`, so on the LanguageProvider path the map
+     * is statically unreachable; on the ScopeResolver path it is reachable only
+     * in a repo that has a parseable `composer.json` with `autoload.psr-4`.
+     * Measured 6.8 ms / 3.56 MiB at 32 000 paths, paid by every PHP repo without
+     * one. Pure function of `all`, which the returned object retains.
+     */
+    let filesByRawDirectory = null;
+    const getFilesByRawDirectory = () => {
+        if (filesByRawDirectory !== null)
+            return filesByRawDirectory;
+        // Raw paths, not normalized: the scan this replaces tests `f.startsWith(...)`
+        // against the Set's own strings, so a backslash path is a miss there and must
+        // stay a miss here. Insertion order is Set order, so `[0]` is the file the
+        // scan would have returned first.
+        const built = new Map();
+        for (const raw of all) {
+            const separator = raw.lastIndexOf('/');
+            if (separator < 0)
+                continue;
+            const directory = raw.slice(0, separator);
+            const bucket = built.get(directory);
+            if (bucket === undefined)
+                built.set(directory, [raw]);
+            else
+                bucket.push(raw);
+        }
+        filesByRawDirectory = built;
+        return built;
+    };
+    const suffixIndex = {
+        get: (suffix) => {
+            const hit = index.getInsensitive(suffix);
+            if (hit === undefined)
+                return undefined;
+            const lower = suffix.toLowerCase();
+            // A proper-suffix hit is already the scan's answer: the shared map holds
+            // the first file matching EITHER way, so nothing earlier matched at all.
+            if (hit.replace(/\\/g, '/').toLowerCase() !== lower)
+                return hit;
+            // Whole-path hit — invisible to `endsWith('/' + S)`. The scan keeps going.
+            // The only branch that needs the correction map, hence the only one that
+            // builds it.
+            return getFirstProperSuffixMatch().get(lower);
+        },
+        // Site 1 must stay a no-op, and `suffixResolve` folds this into `get`.
+        getInsensitive: () => undefined,
+        getFilesInDir: (dirSuffix, extension) => {
+            // `nsDirPrefix` is `nsDir` when it already ends in `/`, else `nsDir + '/'`
+            // — either way the directory is `nsDir` minus one trailing slash.
+            const directory = dirSuffix.endsWith('/') ? dirSuffix.slice(0, -1) : dirSuffix;
+            const bucket = getFilesByRawDirectory().get(directory);
+            if (bucket === undefined)
+                return [];
+            return bucket.filter((file) => file.endsWith(extension));
+        },
+    };
+    return { normalized, all, suffixIndex };
+});
 // ─── loadResolutionConfig ──────────────────────────────────────────────────
 /**
  * Load and parse `composer.json` from the repo root. Returns a
@@ -74,11 +255,11 @@ export function resolvePhpImportTarget(parsedImport, workspaceIndex) {
         return null;
     if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
         return null;
+    // Cast, not copy: `getPhpWorkspaceIndex` memoizes on this exact Set object.
     const allFiles = ctx.allFilePaths;
-    const normalizedFileList = [...allFiles].map((f) => f.replace(/\\/g, '/'));
-    const allFileList = [...allFiles];
+    const { normalized, all, suffixIndex } = getPhpWorkspaceIndex(allFiles);
     return resolvePhpImportInternal(parsedImport.targetRaw, null, // composerConfig not available through LanguageProvider path
-    allFiles, normalizedFileList, allFileList, undefined);
+    allFiles, normalized, all, suffixIndex);
 }
 /**
  * ScopeResolver-shaped adapter: `(targetRaw, fromFile, allFilePaths, resolutionConfig?) → string | null`.
@@ -87,14 +268,55 @@ 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
         ? resolutionConfig
         : null;
+    // Cast, not copy: `getPhpWorkspaceIndex` memoizes on this exact Set object.
     const allFiles = allFilePaths;
-    const normalizedFileList = [...allFiles].map((f) => f.replace(/\\/g, '/'));
-    const allFileList = [...allFiles];
-    return resolvePhpImportInternal(targetRaw, composerConfig, allFiles, normalizedFileList, allFileList, undefined);
+    const { normalized, all, suffixIndex } = getPhpWorkspaceIndex(allFiles);
+    const resolved = resolvePhpImportInternal(targetRaw, composerConfig, allFiles, normalized, all, suffixIndex);
+    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/query.js

@@ -84,6 +84,23 @@ const PHP_SCOPE_QUERY = `
 (function_definition
   name: (name) @declaration.name) @declaration.function
 
+;; Closure assigned to a variable: $handler = function () {...}; or fn() => ...;
+;; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+;; sits on the INNER anonymous_function / arrow_function, NOT on the
+;; assignment_expression wrapper. That aligns anchor.range with the
+;; @scope.function range above, so pass2AttachDeclarations attaches the
+;; declaration to the CLOSURE's own scope rather than the enclosing function's.
+;; Without this the closure scope owns no callable def and
+;; pickCallerCallableDef falls through to the enclosing callable, making the
+;; closure a call TARGET but never a call SOURCE (#2699).
+(assignment_expression
+  left: (variable_name) @declaration.name
+  right: (anonymous_function) @declaration.function)
+
+(assignment_expression
+  left: (variable_name) @declaration.name
+  right: (arrow_function) @declaration.function)
+
 ;; ── Declarations — properties ─────────────────────────────────────────────
 
 ;; PHP 7.4+ typed property: private UserRepo $repo;
@@ -104,6 +121,20 @@ const PHP_SCOPE_QUERY = `
   (property_element
     name: (variable_name) @declaration.name)) @declaration.variable
 
+;; ── Declarations — closure bindings (#2693) ───────────────────────────────
+;; A dollar-name bound to a closure (fn(x) => x, or function(x){...}) IS a
+;; callable. PHP emitted the callable-flow seed and invoke for it already, but
+;; nothing DECLARED the name, so the flow pass had no SymbolDefinition to attach
+;; the seed to and the call stayed unresolved.
+;; Restricted to a closure value: declaring every PHP assignment would mint defs
+;; repo-wide for no resolution benefit.
+(assignment_expression
+  left: (variable_name (name) @declaration.name)
+  right: (arrow_function)) @declaration.variable
+(assignment_expression
+  left: (variable_name (name) @declaration.name)
+  right: (anonymous_function)) @declaration.variable
+
 ;; ── Imports — namespace_use_declaration ───────────────────────────────────
 ;;
 ;; Captures ALL forms: plain, alias, function/const qualifiers, and grouped.

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/arity-metadata.d.ts

@@ -19,6 +19,7 @@ interface PythonArityMetadata {
     readonly parameterCount: number | undefined;
     readonly requiredParameterCount: number | undefined;
     readonly parameterTypes: readonly string[] | undefined;
+    readonly parameterNames: readonly string[];
 }
 export declare function computePythonArityMetadata(fnNode: SyntaxNode): PythonArityMetadata;
 export {};

package/dist/core/ingestion/languages/python/arity-metadata.js

@@ -41,5 +41,6 @@ export function computePythonArityMetadata(fnNode) {
         parameterCount,
         requiredParameterCount,
         parameterTypes: types.length > 0 ? types : undefined,
+        parameterNames: params.map((parameter) => parameter.name),
     };
 }

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,41 @@
  *   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';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-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
@@ -89,11 +107,23 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
             }
             else {
                 // Defensive fallback: emit the raw match.
+                // Structural receiver chain for a call whose receiver is itself an
+                // expression, so resolution can type it by folding over structure
+                // instead of re-parsing the receiver's source text. Self-gating: a
+                // non-call match, an absent receiver, or a chain with no nameable base
+                // all leave `grouped` untouched.
+                synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
                 out.push(grouped);
             }
             continue;
         }
         if (grouped['@scope.function'] !== undefined) {
+            // Structural receiver chain for a call whose receiver is itself an
+            // expression, so resolution can type it by folding over structure
+            // instead of re-parsing the receiver's source text. Self-gating: a
+            // non-call match, an absent receiver, or a chain with no nameable base
+            // all leave `grouped` untouched.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             // `@scope.function` is captured directly on the `function_definition`
             // node (query: `(function_definition) @scope.function`), so it IS the
@@ -101,9 +131,14 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
             const scopeNode = nodeMap['@scope.function'];
             const fnNode = scopeNode.type === 'function_definition' ? scopeNode : null;
             if (fnNode !== null) {
+                const parameterNames = computePythonArityMetadata(fnNode).parameterNames;
+                if (parameterNames.length > 0) {
+                    grouped['@scope.lexical-names'] = syntheticCapture('@scope.lexical-names', fnNode, JSON.stringify(parameterNames));
+                }
                 const synth = synthesizeReceiverTypeBinding(fnNode);
                 if (synth !== null)
                     out.push(synth);
+                out.push(...synthesizeConstructorFieldTypeBindings(fnNode));
                 for (const depRef of synthesizeDependsReferences(fnNode))
                     out.push(depRef);
             }
@@ -139,12 +174,25 @@ export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
                     grouped['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
                 }
             }
+            // Structural receiver chain for a call whose receiver is itself an
+            // expression, so resolution can type it by folding over structure
+            // instead of re-parsing the receiver's source text. Self-gating: a
+            // non-call match, an absent receiver, or a chain with no nameable base
+            // all leave `grouped` untouched.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             continue;
         }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
         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/import-decomposer.js

@@ -10,7 +10,18 @@
  * carry everything `interpretPythonImport` needs to recover the original
  * `ParsedImport` shape — see `interpret.ts`.
  */
-import { findChild, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { findAncestorBeforeBoundary, findChild, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+/**
+ * The only two constructs that stop a module-level `from m import x` from
+ * publishing `x` as `<module>.x`. Python has no block scope, so an import
+ * under `if` / `try` / `for` / `with` still publishes when its branch runs —
+ * verified against CPython 3.11; only `def` and `class` bodies suppress it.
+ */
+const PUBLICATION_SUPPRESSING_ANCESTORS = new Set([
+    'function_definition',
+    'class_definition',
+]);
+const NO_BOUNDARY = new Set();
 export function splitImportStatement(stmtNode) {
     if (stmtNode.type === 'import_statement')
         return splitImportStmt(stmtNode);
@@ -54,6 +65,8 @@ function splitImportFromStmt(stmtNode) {
     const out = [];
     const moduleField = stmtNode.childForFieldName('module_name');
     const moduleText = moduleField?.text ?? '';
+    // Once per statement, not once per name.
+    const publishesToModule = findAncestorBeforeBoundary(stmtNode, PUBLICATION_SUPPRESSING_ANCESTORS, NO_BOUNDARY) === null;
     // Wildcard? tree-sitter-python represents `*` as a `wildcard_import`
     // child and emits no name children.
     const wildcardChild = findChild(stmtNode, 'wildcard_import');
@@ -79,6 +92,7 @@ function splitImportFromStmt(stmtNode) {
                 source: moduleText,
                 name: child.text,
                 atNode: child,
+                publishesToModule,
             }));
         }
         else if (child.type === 'aliased_import') {
@@ -91,6 +105,7 @@ function splitImportFromStmt(stmtNode) {
                     name: dotted.text,
                     alias: alias.text,
                     atNode: child,
+                    publishesToModule,
                 }));
             }
         }
@@ -108,5 +123,11 @@ function buildImportMatch(stmtNode, spec) {
     if (spec.alias !== undefined) {
         m['@import.alias'] = syntheticCapture('@import.alias', spec.atNode, spec.alias);
     }
+    // Anchored at `spec.atNode`, never `stmtNode`: `anchorCaptureFor` picks the
+    // broadest span with a strict `>`, so a statement-wide span here would tie
+    // with `@import.statement` and let key order decide the anchor.
+    if (spec.publishesToModule === true) {
+        m['@import.publishes'] = syntheticCapture('@import.publishes', spec.atNode, 'module');
+    }
     return m;
 }

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

@@ -9,12 +9,53 @@
  * Returning `null` lets the finalize algorithm mark the edge as
  * `linkStatus: 'unresolved'`.
  */
-import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+import type { ParsedFile, ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
 export interface PythonResolveContext {
     readonly fromFile: string;
     /** `ReadonlySet` so the orchestrator's stable run-level set flows straight
      *  through to `getPythonFileIndex`'s `WeakMap` key (built once per run, not
      *  copied per import). The whole resolver chain only reads the set. */
     readonly allFilePaths: ReadonlySet<string>;
+    /** Optional parsed workspace used to preserve a package's explicit export
+     * when it collides with a same-named concrete submodule. */
+    readonly parsedFiles?: readonly ParsedFile[];
 }
 export declare function resolvePythonImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | null;
+/**
+ * A named Python import is a namespace handle only when its resolved file is
+ * the concrete submodule formed by appending the imported name. This keeps
+ * ordinary symbol imports on the named-binding path.
+ */
+export declare function isPythonImportedModule(parsedImport: ParsedImport, targetFile: string, fromFile: string): boolean;
+/**
+ * The receiver spellings `import a.b.c` makes callable, and the file each one
+ * names (#2826).
+ *
+ * `import a.b.c` binds ONE name — `a` — but makes three attribute paths
+ * reachable, and they name three different files:
+ *
+ *   a        → a/__init__.py
+ *   a.b      → a/b/__init__.py
+ *   a.b.c    → a/b/c.py        (the edge's own target)
+ *
+ * The shared default keyed `a` to the LEAF, which is wrong in both directions:
+ * `a.helper()` resolved into `a/b/c.py` whenever that module happened to export
+ * `helper`, and `a.b.mid()` resolved to nothing.
+ *
+ * Returns `undefined` — meaning "use the shared default" — for every spelling
+ * where the bound name is not the path's root:
+ *   - `import single`            — no dotted path to expand;
+ *   - `import a.b as x`          — binds only `x`; writing `a.b.f()` there is a
+ *                                  NameError, so `a.b` must NOT become a key;
+ *   - `from pkg import db`       — reclassified to a namespace edge whose
+ *                                  importPath is the bare name `db`.
+ *
+ * Prefix files are proposed, not asserted: `moduleFileExists` drops any that
+ * the workspace did not parse, so a PEP-420 namespace package (no
+ * `__init__.py`) contributes no key rather than one pointing at a missing file.
+ */
+export declare function pythonNamespaceReceiverPaths(edge: {
+    readonly localName: string;
+    readonly importPath: string;
+    readonly targetFile: string;
+}, moduleFileExists: (filePath: string) => boolean): readonly (readonly [string, string])[] | undefined;