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

package/dist/core/ingestion/language-provider.d.ts

@@ -83,9 +83,17 @@ interface LanguageProviderConfig {
      * The current C++ UE-macro preprocessor relies on the practical fact that
      * UE reflection macros and module-export tokens are ASCII-only.
      *
-     * Must be a pure function — same input always yields the same output. Called
-     * once per file, on every code path that re-parses (parsing-processor, import
-     * processor, heritage processor, call processor, parse worker).
+     * Must be a pure function — same input always yields the same output, and
+     * re-applying it to its own output changes nothing.
+     *
+     * Applied by the parse worker (`parse-worker.ts`), by `extractParsedFile`
+     * (`scope-extractor-bridge.ts`) on the parse-cache-miss path, and by the
+     * embedding parse (`embeddings/ast-utils.ts`, which does not go through the
+     * bridge). Any *new* path that re-parses a file must apply it too, or the two
+     * halves of the pipeline analyze different programs — and note the set is not
+     * closed today: language-owned re-parse helpers reached through other
+     * provider hooks (e.g. `populateRangeBindings`) still see raw text.
+     * `test/unit/preprocess-source-parity.test.ts` pins the bridge equivalence.
      *
      * Default: undefined (no preprocessing — `file.content` is parsed verbatim).
      */
@@ -163,6 +171,16 @@ interface LanguageProviderConfig {
      *  (e.g., 'Method' for Kotlin), or defaultLabel to keep as-is.
      *  Default: undefined (standard label assignment). */
     readonly labelOverride?: (functionNode: SyntaxNode, defaultLabel: NodeLabel) => NodeLabel | null;
+    /**
+     * Suppress a definition query match after its default label is known.
+     * Languages use this for syntax that represents an implicit declaration
+     * unless an explicit declaration with the same semantics is present.
+     *
+     * `defaultLabel` is supplied so an implementation can scope itself to one
+     * kind of definition; implementations whose capture map alone decides the
+     * question may ignore it.
+     */
+    readonly shouldSkipDefinitionCapture?: (captureMap: CaptureMap, defaultLabel: NodeLabel) => boolean;
     /** MRO strategy for multiple inheritance resolution.
      *  Default: 'first-wins'. */
     readonly mroStrategy?: MroStrategy;
@@ -217,14 +235,22 @@ interface LanguageProviderConfig {
      *  Default: undefined (no route extraction). */
     readonly extractRoutes?: (tree: Parser.Tree, filePath: string, reader: (relativePath: string) => string | null, parser?: Parser | null) => ExtractedRoute[];
     /**
-     * Extract decorator-style route annotations from a parsed file.
+     * Extract routes that a parsed file declares in its own AST.
      *
      * When defined, the parse worker calls this after per-file capture processing
-     * to extract framework route definitions that require AST-level analysis beyond
+     * to extract route definitions that require AST-level analysis beyond
      * generic `@decorator` captures (e.g., Java Spring class-level prefix joining,
      * multi-class handling). The returned routes are appended to `decoratorRoutes`.
      *
-     * Default: undefined (no language-specific decorator route extraction).
+     * Decorators are the common case and the reason for the name, but not the only
+     * shape: JS/TS uses this hook for hand-rolled dispatch guards
+     * (`route-extractors/dispatch-guard.ts`), where a raw `node:http` server
+     * declares a route by comparing the request path to a literal. Anything that
+     * yields a `(path, verb, handler)` triple from one file's AST belongs here —
+     * set `ExtractedDecoratorRoute.source` when the provenance is not a decorator,
+     * so the `HANDLES_ROUTE` edge does not claim one.
+     *
+     * Default: undefined (no language-specific route extraction).
      */
     readonly extractDecoratorRoutes?: (tree: Parser.Tree, filePath: string, lineOffset: number) => ExtractedDecoratorRoute[];
     /**
@@ -339,6 +365,93 @@ interface LanguageProviderConfig {
      * Required when `emitScopeCaptures` is implemented.
      */
     readonly interpretImport?: (captures: CaptureMatch) => ParsedImport | null;
+    /**
+     * Do this language's imports EXECUTE at the point in the program where they
+     * are written?
+     *
+     * The scope extractor marks an import `runsOnlyWhenCalled` when the statement
+     * sits inside a `Function` scope (Pass 3): where imports are executed
+     * statements, one written in a function body runs only when that function is
+     * called — Python's `def f(): from x import Y`, Ruby's
+     * `def f; require 'x'; end`, a CommonJS `require()` in a body (which
+     * `javascript/captures.ts` does capture, via its own AST walk). That rule is
+     * about EXECUTION. It says nothing true about a language whose "import" is
+     * not an executed statement at all, and in such a language moving one into a
+     * function body defers exactly nothing.
+     *
+     * "Where written" is about execution time, not textual placement: a
+     * `#include` is spliced precisely where it is written and still answers
+     * `false`, because splicing is not running.
+     *
+     * **The failure directions are not symmetric, which is why the default is
+     * what it is.** Answering `false` for a language that really does execute
+     * its imports un-defers a deliberately lazy one, and `check --cycles`
+     * reports a cycle its author broke on purpose — wrong, but visible on screen
+     * and arguable by whoever reads it. Answering `true` for a language that
+     * does not SUPPRESSES a cycle that is entirely real: nobody sees it, so
+     * nobody can argue with it. Getting this wrong in the `true` direction hides
+     * a true cycle, and that is the failure that matters.
+     *
+     * Absent — the default — reads as `true`, so every provider that does not
+     * name this keeps today's behaviour exactly. The flag never ADDS deferral;
+     * declaring `false` only WITHHOLDS it.
+     *
+     * Declared `false` by, and only by:
+     *
+     *   - **C and C++** — `#include` is a preprocessor directive. The header's
+     *     text is spliced in before a line of the program runs, wherever the
+     *     directive sits, and C permits one inside a function body. C++'s only
+     *     other Pass-3 import form, `using ns::name` / `using namespace ns`, is
+     *     compile-time name lookup, is legal in a function body too, and defers
+     *     no more than an `#include` does.
+     *   - **Rust** — `use` is a compile-time path alias, not a statement that
+     *     runs. `fn f() { use crate::m::X; }` is legal, and putting the `use`
+     *     there changes only where the name is VISIBLE, never when anything
+     *     happens; Rust has no module-initialization order in the JS/Python
+     *     sense and permits intra-crate module cycles outright. It is the
+     *     structural twin of C++'s `using ns::name`. `rust/query.ts` captures
+     *     `(use_declaration)` and nothing else, so this covers the whole
+     *     surface. (The claim here is the narrow one: POSITION does not defer a
+     *     Rust import. Whether a Rust `use` can create an initialization
+     *     dependency *at all* is a larger and separate question, and this flag
+     *     deliberately does not answer it.)
+     *   - **COBOL** — `COPY` is a pure textual splice performed by the copybook
+     *     preprocessor, the `#include` case exactly. Latent today: the COBOL
+     *     `@scope.function` capture covers a single line (`cobol/captures.ts`
+     *     ranges sections and paragraphs `line → line`), so a `COPY` on any
+     *     later line never resolves inside one and Pass 3 has nothing to mark.
+     *     Declared anyway, so that giving those anchors their true multi-line
+     *     ranges cannot silently start suppressing real copybook cycles.
+     *
+     * Per-provider rather than per-import, and that is sufficient — the question
+     * this answers is narrower than "do this language's imports execute". It is
+     * only ever asked of an import that resolved INSIDE A FUNCTION SCOPE, so the
+     * real domain is: *can a function-local import in this language be
+     * non-executing?* No supported language has two forms that are both
+     * function-local and disagree. C++ has two forms, `#include` and
+     * `using ns::name`; both can appear in a body and both are compile-time.
+     *
+     * PHP is the case that looks like a counterexample and is not. It does mix —
+     * `use Foo\Bar;` aliases at compile time while `require` executes — but
+     * `use` cannot appear in a function body at all (`php/query.ts` records this
+     * twice: "`namespace_use_declaration` is an import only at top level / inside
+     * namespace scope"), so it never reaches this flag. Absent is therefore
+     * PERMANENTLY correct for PHP, including the day `require` is captured: a
+     * `require` in a body will correctly defer, and a `use` still cannot get
+     * here. Do not read PHP as a reason to build a per-`ParsedImport`
+     * classification hook — it would cost a provider call per import on the
+     * extractor's hot path, and `ParsedImport.kind` does not discriminate the
+     * thing being asked anyway.
+     *
+     * A capability on the provider rather than a language check in
+     * `scope-extractor.ts`: shared `core/ingestion/` pipeline code must not name
+     * languages (AGENTS.md), and "imports here are not executed statements" is a
+     * property of the language, not of the walk.
+     *
+     * Default: undefined, read as `true` (imports execute where they are
+     * written; position defers them).
+     */
+    readonly importsExecuteWhereWritten?: boolean;
     /**
      * What is the implicit receiver on a Function scope? For instance methods
      * this is `self`/`this`; for standalone functions it is `null`. Consulted
@@ -367,6 +480,19 @@ interface LanguageProviderConfig {
      * suffix — `@scope.function` → `'Function'`, etc.).
      */
     readonly resolveScopeKind?: (captures: CaptureMatch) => ScopeKind | null;
+    /**
+     * Report the receiver names this scope BINDS rather than inherits — see
+     * `Scope.ownsReceivers` (#2701).
+     *
+     * Called once per `@scope.*` capture during scope-tree construction.
+     * Return the shared frozen set for a scope that starts a fresh receiver
+     * (a JS/TS ordinary `function`, whose `this` is bound at call time), and
+     * `undefined` for one that inherits it (an arrow function, and every
+     * closure form in languages that capture the receiver lexically).
+     *
+     * Default: undefined everywhere — the receiver walk is unchanged.
+     */
+    readonly scopeOwnsReceivers?: (captures: CaptureMatch) => ReadonlySet<string> | undefined;
     /**
      * Override where a declaration's name becomes visible. By default the name
      * is bound in the innermost enclosing scope; return a different `ScopeId`
@@ -396,7 +522,7 @@ interface LanguageProviderConfig {
      * Required when `emitScopeCaptures` is implemented. Ring 2 PKG #922
      * provides the adapter that bridges today's resolver shape to this hook.
      */
-    readonly resolveImportTarget?: (parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex) => string | null;
+    readonly resolveImportTarget?: (parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex) => string | readonly string[] | null;
     /**
      * Enumerate the exported names of a file — used by the finalize algorithm
      * to expand `import * from M` into individual `BindingRef`s with

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

@@ -5,6 +5,21 @@ import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitCInclude } from './import-decomposer.js';
 import { computeCDeclarationArity, computeCCallArity } from './arity-metadata.js';
 import { markStaticName } from './static-linkage.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
+import { synthesizeCallableFlowCaptures, } from '../../utils/callable-flow-captures.js';
+const C_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_definition']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter_declaration']),
+    bindingNodeTypes: new Set(['init_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'field_identifier', 'type_identifier']),
+    callableSignatureDeclarationNodeTypes: new Set(['declaration', 'parameter_declaration']),
+    emitCanonicalInvokeReference: true,
+    parameterPassingMode: (parameter) => containsNodeType(parameter, 'pointer_declarator') ? 'pointer' : 'value',
+    expectedSignature: (container, destination) => functionDeclaratorSignature(destination) ?? functionDeclaratorSignature(container),
+};
 export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -104,10 +119,58 @@ export function emitCScopeCaptures(sourceText, filePath, cachedTree) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(computeCCallArity(callNode)));
             }
         }
+        // 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(...synthesizeCallableFlowCaptures(tree.rootNode, C_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
+function functionDeclaratorSignature(node) {
+    const declarator = findDescendantOfType(node, 'function_declarator');
+    const parameters = declarator?.childForFieldName('parameters');
+    if (parameters === null || parameters === undefined)
+        return undefined;
+    const parameterNodes = parameters.namedChildren.filter((child) => child !== null && child.type === 'parameter_declaration');
+    // tree-sitter-c materializes `...` as a NAMED `variadic_parameter` node —
+    // the anonymous-token checks never matched, so variadic signatures were
+    // emitted with a wrong fixed arity (#2522 review). Keep the token checks
+    // for grammar variants that expose `...` as an anonymous literal.
+    const hasEllipsis = parameters.children.some((child) => child.type === 'variadic_parameter' ||
+        child.type === '...' ||
+        (!child.isNamed && child.text === '...'));
+    const isVoidOnly = parameterNodes.length === 1 &&
+        parameterNodes[0].namedChildCount === 1 &&
+        parameterNodes[0].firstNamedChild?.text === 'void';
+    if (isVoidOnly)
+        return { parameterCount: 0, parameterTypes: [] };
+    const parameterTypes = parameterNodes.map((parameter) => parameter.childForFieldName('type')?.text ?? 'unknown');
+    if (hasEllipsis)
+        parameterTypes.push('...');
+    return {
+        ...(hasEllipsis ? {} : { parameterCount: parameterNodes.length }),
+        parameterTypes,
+    };
+}
+function containsNodeType(root, type) {
+    return findDescendantOfType(root, type) !== null;
+}
+function findDescendantOfType(root, type) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === type)
+            return node;
+        for (const child of node.namedChildren)
+            if (child !== null)
+                stack.push(child);
+    }
+    return null;
+}
 /**
  * Check if a C function_definition or declaration has `static` storage class.
  * Walks direct children for a `storage_class_specifier` node with text `static`.

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

@@ -1,4 +1,5 @@
 import { dirname, join } from 'path';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 /**
  * Per-pass memo: workspace paths bucketed by basename (last path segment),
  * keyed on the `allFilePaths` set identity.
@@ -15,25 +16,20 @@ import { dirname, join } from 'path';
  * `WeakMap`-keyed so it is reclaimed with the pass (no cross-pass staleness).
  * Shared by C and C++ (`resolveCppImportTarget` delegates here).
  */
-const suffixIndexByPaths = new WeakMap();
-function suffixIndex(allFilePaths) {
-    let index = suffixIndexByPaths.get(allFilePaths);
-    if (index === undefined) {
-        index = new Map();
-        for (const original of allFilePaths) {
-            const normalized = original.replace(/\\/g, '/');
-            const basename = normalized.slice(normalized.lastIndexOf('/') + 1);
-            let bucket = index.get(basename);
-            if (bucket === undefined) {
-                bucket = [];
-                index.set(basename, bucket);
-            }
-            bucket.push({ original, normalized, depth: normalized.split('/').length });
+const suffixIndex = perFileSet((allFilePaths) => {
+    const index = new Map();
+    for (const original of allFilePaths) {
+        const normalized = original.replace(/\\/g, '/');
+        const basename = normalized.slice(normalized.lastIndexOf('/') + 1);
+        let bucket = index.get(basename);
+        if (bucket === undefined) {
+            bucket = [];
+            index.set(basename, bucket);
         }
-        suffixIndexByPaths.set(allFilePaths, index);
+        bucket.push({ original, normalized, depth: normalized.split('/').length });
     }
     return index;
-}
+});
 /**
  * Resolve a C #include path to a file in the workspace.
  *

package/dist/core/ingestion/languages/c/query.js

@@ -117,6 +117,23 @@ const C_SCOPE_QUERY = `
   declarator: (pointer_declarator
     declarator: (identifier) @declaration.name)) @declaration.variable
 
+;; Declarations — function-pointer variables (\`void (*fp)(int);\`), with and
+;; without initializer. Without these the file-scope pointer has no scope-tree
+;; binding, so callable-flow cells written in one function and read in another
+;; canonicalize to different keys and never join (#2522 review, H1).
+(declaration
+  declarator: (function_declarator
+    declarator: (parenthesized_declarator
+      (pointer_declarator
+        declarator: (identifier) @declaration.name)))) @declaration.variable
+
+(declaration
+  declarator: (init_declarator
+    declarator: (function_declarator
+      declarator: (parenthesized_declarator
+        (pointer_declarator
+          declarator: (identifier) @declaration.name))))) @declaration.variable
+
 ;; Declarations — macro definitions
 (preproc_def
   name: (identifier) @declaration.name) @declaration.macro

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

@@ -6,6 +6,7 @@ import { cArityCompatibility, cMergeBindings, resolveCImportTarget } from './ind
 import { scanHeaderFiles } from './header-scan.js';
 import { expandCWildcardNames, isStaticName, clearStaticNames } from './static-linkage.js';
 import { applyCStaticLinkageSideChannel } from './capture-side-channel.js';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 /**
  * Per-pass memo of the augmented `#include`-resolution file set
  * (`allFilePaths` ∪ header `.h` paths), keyed on the two stable source sets.
@@ -16,25 +17,25 @@ import { applyCStaticLinkageSideChannel } from './capture-side-channel.js';
  * handing it a new set identity each time. Both `allFilePaths` (built once in
  * scope-resolution `run.ts`) and the header set (`loadResolutionConfig`
  * result) are stable per pass, so the union is built once and reused.
- * `WeakMap`-keyed → reclaimed with the pass (no cross-pass staleness).
+ * Reclaimed with the pass (no cross-pass staleness).
+ *
+ * Two inputs, so two levels of `perFileSet` composed rather than a second
+ * primitive: the outer memo's value is the inner memo, and a function is an
+ * object, which is all `T extends object` asks for.
+ *
+ * The MEMO stays private to this file even though the C++ resolver's twin is
+ * byte-identical. The augmented set's IDENTITY is load-bearing downstream —
+ * C++ delegates to `resolveCImportTarget`, whose `suffixIndex` memo is keyed on
+ * exactly this set — so one memo shared across the two languages would hand
+ * each the other's index. Same builder-shared/memo-separate rule as
+ * `import-resolvers/pass-cache.ts`.
  */
-const augmentedPathsByPass = new WeakMap();
-function augmentedFilePaths(allFilePaths, headerPaths) {
-    let byHeaders = augmentedPathsByPass.get(allFilePaths);
-    if (byHeaders === undefined) {
-        byHeaders = new WeakMap();
-        augmentedPathsByPass.set(allFilePaths, byHeaders);
-    }
-    let augmented = byHeaders.get(headerPaths);
-    if (augmented === undefined) {
-        const set = new Set(allFilePaths);
-        for (const h of headerPaths)
-            set.add(h);
-        augmented = set;
-        byHeaders.set(headerPaths, augmented);
-    }
-    return augmented;
-}
+const augmentedFilePathsFor = perFileSet((allFilePaths) => perFileSet((headerPaths) => {
+    const set = new Set(allFilePaths);
+    for (const h of headerPaths)
+        set.add(h);
+    return set;
+}));
 /**
  * C `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -78,7 +79,7 @@ export const cScopeResolver = {
         // targets .h files classified as C++ in language detection.
         const headerPaths = resolutionConfig;
         if (headerPaths !== undefined && headerPaths.size > 0) {
-            return resolveCImportTarget(targetRaw, fromFile, augmentedFilePaths(allFilePaths, headerPaths));
+            return resolveCImportTarget(targetRaw, fromFile, augmentedFilePathsFor(allFilePaths)(headerPaths));
         }
         return resolveCImportTarget(targetRaw, fromFile, allFilePaths);
     },
@@ -100,4 +101,10 @@ export const cScopeResolver = {
         const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
         return isStaticName(def.filePath, simple);
     },
+    // Precise linkage-only variant used to associate a visible prototype with
+    // its implementation during callable-value actual-to-formal propagation.
+    hasFileLocalCallableLinkage: (def) => {
+        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+        return isStaticName(def.filePath, simple);
+    },
 };

package/dist/core/ingestion/languages/c/static-linkage.js

@@ -1,3 +1,4 @@
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 /**
  * Per-file set of function names declared with `static` storage class.
  * Populated during `emitCScopeCaptures` and consumed by `expandCWildcardNames`
@@ -52,27 +53,22 @@ export function clearStaticNames() {
  * thousands of resolved includes) that is ~10^10+ comparisons on a single
  * thread — the dominant term in the scope-resolution finalize grind.
  *
- * Building the lookup once collapses it to O(R_include + F). `WeakMap`-keyed
- * on the array so the index is reclaimed with the pass — no cross-pass
+ * Building the lookup once collapses it to O(R_include + F). `perFileSet` keys
+ * on the array identity so the index is reclaimed with the pass — no cross-pass
  * staleness (mirrors the {@link clearStaticNames} discipline for server-mode
  * / multi-repo reuse), and a fresh array transparently rebuilds.
  */
-const moduleScopeIndexByPass = new WeakMap();
-function moduleScopeIndex(parsedFiles) {
-    let index = moduleScopeIndexByPass.get(parsedFiles);
-    if (index === undefined) {
-        index = new Map();
-        // First-wins to preserve `Array.find` semantics (returns the first match).
-        // `moduleScope` is unique per file in practice, so collisions are absent;
-        // the guard only formalises identical behaviour to the prior `.find`.
-        for (const p of parsedFiles) {
-            if (!index.has(p.moduleScope))
-                index.set(p.moduleScope, p);
-        }
-        moduleScopeIndexByPass.set(parsedFiles, index);
+const moduleScopeIndex = perFileSet((parsedFiles) => {
+    const index = new Map();
+    // First-wins to preserve `Array.find` semantics (returns the first match).
+    // `moduleScope` is unique per file in practice, so collisions are absent;
+    // the guard only formalises identical behaviour to the prior `.find`.
+    for (const p of parsedFiles) {
+        if (!index.has(p.moduleScope))
+            index.set(p.moduleScope, p);
     }
     return index;
-}
+});
 /**
  * Return the names visible through a C wildcard import (`#include`).
  * All module-scope defs from the target file are visible EXCEPT those

package/dist/core/ingestion/languages/c-cpp.js

@@ -369,6 +369,13 @@ export const cProvider = defineLanguage({
     // than a DataCloneError at the worker boundary (#2143).
     collectCaptureSideChannel: (filePath) => assertCloneable(collectCStaticLinkageSideChannel(filePath)),
     interpretImport: interpretCImport,
+    // `#include` is a preprocessor directive, not a statement that runs. The
+    // header text is spliced in before the program starts, wherever the directive
+    // sits — and C allows it inside a function body. Without this the central
+    // Pass-3 position rule would mark such an include `runsOnlyWhenCalled` and
+    // `check --cycles` would silently drop an include cycle that is entirely
+    // real. See `LanguageProvider.importsExecuteWhereWritten`.
+    importsExecuteWhereWritten: false,
     interpretTypeBinding: interpretCTypeBinding,
     bindingScopeFor: cBindingScopeFor,
     importOwningScope: cImportOwningScope,
@@ -447,6 +454,12 @@ export const cppProvider = defineLanguage({
     // re-parse (#1983). See `cpp/capture-side-channel.ts`.
     collectCaptureSideChannel: (filePath) => assertCloneable(collectCppCaptureSideChannel(filePath)),
     interpretImport: interpretCppImport,
+    // Same as C — `cpp/query.ts` emits `@import.statement` for `preproc_include`
+    // too. It holds for C++'s whole import surface: the only other form Pass 3
+    // sees is `@import.using-decl` (`using ns::name` / `using namespace ns`),
+    // which is a compile-time name-lookup declaration and executes no more than
+    // an `#include` does. See the note on `cProvider`.
+    importsExecuteWhereWritten: false,
     interpretTypeBinding: interpretCppTypeBinding,
     bindingScopeFor: cppBindingScopeFor,
     importOwningScope: cppImportOwningScope,

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

@@ -44,6 +44,20 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
     // Run the regex tagger on the preprocessed source
     const extracted = extractCobolSymbolsWithRegex(cleaned, _filePath);
     const out = [];
+    const procedurePointers = new Set(extracted.dataItems
+        .filter((item) => /(?:PROCEDURE|FUNCTION)-POINTER/.test(item.usage?.toUpperCase() ?? ''))
+        .map((item) => item.name.toUpperCase()));
+    // Fallback for declarations the clause parser missed. Scan CLEANED lines —
+    // on raw fixed-format sources the sequence number (cols 1-6) satisfied
+    // `\d+` and the LEVEL NUMBER got captured as the name, so the set never
+    // contained the real pointer name and the whole feature no-op'd (#2522
+    // review, H3). COBOL data names must contain a letter, so `[A-Z]` first
+    // rejects level numbers.
+    for (const line of cleaned.split(/\r?\n/)) {
+        const declaration = line.match(/^\s*\d{1,2}\s+([A-Z][A-Z0-9-]*).*\b(?:PROCEDURE|FUNCTION)-POINTER\b/i);
+        if (declaration !== null)
+            procedurePointers.add(declaration[1].toUpperCase());
+    }
     // ── 1. PROGRAM-ID → @scope.module ───────────────────────────────────
     // The primary program name (first PROGRAM-ID encountered)
     if (extracted.programName) {
@@ -208,6 +222,85 @@ export function emitCobolScopeCaptures(sourceText, _filePath, _cachedTree) {
         if (m !== null)
             out.push(m);
     }
+    // ── 9. Procedure-pointer value flow ────────────────────────────────
+    // ISO COBOL exposes callable values through USAGE PROCEDURE-POINTER,
+    // SET ... TO ENTRY, and dynamic CALL data-items. The regex provider emits
+    // the same normalized facts as AST-backed providers so shared ingestion
+    // remains language-agnostic.
+    for (const program of extracted.programs) {
+        for (let index = 0; index < (program.procedureUsing?.length ?? 0); index++) {
+            const parameter = program.procedureUsing[index];
+            const ownerRange = rangeOf(program.startLine, 0, program.endLine, 0);
+            out.push({
+                '@callable-flow.formal': capture('@callable-flow.formal', ownerRange, program.name),
+                '@callable-flow.owner': capture('@callable-flow.owner', ownerRange, program.name),
+                '@callable-flow.binding': capture('@callable-flow.binding', rangeOf(program.startLine, 0, program.startLine, parameter.length), parameter),
+                '@callable-flow.parameter-index': capture('@callable-flow.parameter-index', ownerRange, String(index)),
+                '@callable-flow.passing-mode': capture('@callable-flow.passing-mode', ownerRange, 'reference'),
+            });
+        }
+    }
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        // Comment lines must not seed flows — a commented-out SET produced a
+        // live seed and a false CALLS edge from dead code (#2522 review, M1).
+        // Fixed format marks comments with '*'/'/' in indicator column 7; free
+        // format uses '*>' (also valid inline, so strip the tail).
+        if (line[6] === '*' || line[6] === '/')
+            continue;
+        const code = line.split('*>')[0];
+        const lineNumber = index + 1;
+        const lineRange = rangeOf(lineNumber, 0, lineNumber, endColFrom(line));
+        const entry = code.match(/\bSET\s+([A-Z0-9][A-Z0-9-]*)\s+TO\s+ENTRY\s+(?:"([^"]+)"|'([^']+)')/i);
+        if (entry !== null) {
+            const destination = entry[1];
+            const target = entry[2] ?? entry[3];
+            if (procedurePointers.has(destination.toUpperCase())) {
+                out.push({
+                    '@callable-flow.seed': capture('@callable-flow.seed', lineRange, line),
+                    '@callable-flow.destination': capture('@callable-flow.destination', lineRange, destination),
+                    '@callable-flow.target': capture('@callable-flow.target', lineRange, target),
+                    '@callable-flow.target-name': capture('@callable-flow.target-name', lineRange, target),
+                });
+            }
+            continue;
+        }
+        const copy = code.match(/\bSET\s+([A-Z0-9][A-Z0-9-]*)\s+TO\s+([A-Z0-9][A-Z0-9-]*)\b/i);
+        if (copy !== null &&
+            procedurePointers.has(copy[1].toUpperCase()) &&
+            procedurePointers.has(copy[2].toUpperCase())) {
+            out.push({
+                '@callable-flow.copy': capture('@callable-flow.copy', lineRange, line),
+                '@callable-flow.destination': capture('@callable-flow.destination', lineRange, copy[1]),
+                '@callable-flow.source': capture('@callable-flow.source', lineRange, copy[2]),
+            });
+        }
+    }
+    for (const call of extracted.calls) {
+        const line = lines[call.line - 1] ?? '';
+        const lineRange = rangeOf(call.line, 0, call.line, endColFrom(line));
+        for (let index = 0; index < (call.parameters?.length ?? 0); index++) {
+            const parameter = call.parameters[index];
+            out.push({
+                '@callable-flow.argument': capture('@callable-flow.argument', lineRange, line),
+                '@callable-flow.source': capture('@callable-flow.source', lineRange, parameter),
+                '@callable-flow.parameter-index': capture('@callable-flow.parameter-index', lineRange, String(index)),
+                ...(!call.isQuoted && procedurePointers.has(call.target.toUpperCase())
+                    ? {}
+                    : {
+                        '@callable-flow.direct-callee-name': capture('@callable-flow.direct-callee-name', lineRange, call.target),
+                    }),
+            });
+        }
+        if (!call.isQuoted && procedurePointers.has(call.target.toUpperCase())) {
+            out.push({
+                '@callable-flow.invoke': capture('@callable-flow.invoke', lineRange, line),
+                '@callable-flow.callee': capture('@callable-flow.callee', lineRange, call.target),
+                '@callable-flow.invocation-kind': capture('@callable-flow.invocation-kind', lineRange, 'indirect'),
+                '@callable-flow.arity': capture('@callable-flow.arity', lineRange, String(call.parameters?.length ?? 0)),
+            });
+        }
+    }
     return out;
 }
 // ---------------------------------------------------------------------------