gitnexus 1.6.9 → 1.6.10-aptos.0

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

@@ -111,6 +111,11 @@ export function extract(matches, filePath, provider) {
     // ── Pass 5: collect reference sites ─────────────────────────────────
     const referenceSites = [];
     pass5CollectReferences(partitioned.reference, positionIndex, filePath, referenceSites, provider, scopeTree);
+    // ── Pass 6: collect normalized callable-value-flow facts ───────────
+    // Kept after (and independent from) Pass 5 so existing reference-site
+    // extraction remains byte-identical.
+    const callableFlowSites = [];
+    pass6CollectCallableFlows(partitioned.callableFlow, positionIndex, filePath, callableFlowSites);
     // Freeze Scope drafts into final shape and return.
     const frozenScopes = scopeDrafts.map(draftToScope);
     return Object.freeze({
@@ -120,12 +125,15 @@ export function extract(matches, filePath, provider) {
         parsedImports: Object.freeze(parsedImports.slice()),
         localDefs: Object.freeze(localDefs.slice()),
         referenceSites: Object.freeze(referenceSites.slice()),
+        ...(callableFlowSites.length > 0
+            ? { callableFlowSites: Object.freeze(callableFlowSites.slice()) }
+            : {}),
     });
 }
 /**
- * Bucket each match by the topic of its anchor capture. The anchor is the
- * capture whose name is prefixed with the match's topic (`@scope.*`,
- * `@declaration.*`, `@import.*`, `@type-binding.*`, `@reference.*`).
+ * Bucket each match by every topic represented by its anchor captures. An
+ * emitter may deliberately group a lexical scope and its declaration in one
+ * match so both passes observe the exact same source range.
  *
  * A match may contain additional captures (e.g., `@import.source`,
  * `@declaration.class.name`) that are used by the provider hooks to
@@ -138,49 +146,50 @@ function partitionByTopic(matches) {
     const import_ = [];
     const typeBinding = [];
     const reference = [];
+    const callableFlow = [];
     for (const match of matches) {
-        const topic = topicOf(match);
-        switch (topic) {
-            case 'scope':
-                scope.push(match);
-                break;
-            case 'declaration':
-                declaration.push(match);
-                break;
-            case 'import':
-                import_.push(match);
-                break;
-            case 'type-binding':
-                typeBinding.push(match);
-                break;
-            case 'reference':
-                reference.push(match);
-                break;
-            case 'unknown':
-                // Unrecognized anchor — silently skip. Providers may emit extra
-                // captures (e.g., `@comment`) that the extractor has no topic for.
-                break;
+        for (const topic of topicsOf(match)) {
+            switch (topic) {
+                case 'scope':
+                    scope.push(match);
+                    break;
+                case 'declaration':
+                    declaration.push(match);
+                    break;
+                case 'import':
+                    import_.push(match);
+                    break;
+                case 'type-binding':
+                    typeBinding.push(match);
+                    break;
+                case 'reference':
+                    reference.push(match);
+                    break;
+                case 'callable-flow':
+                    callableFlow.push(match);
+                    break;
+            }
         }
     }
-    return { scope, declaration, import_, typeBinding, reference };
+    return { scope, declaration, import_, typeBinding, reference, callableFlow };
 }
-function topicOf(match) {
-    // The anchor is the capture whose name uses one of the known topic
-    // prefixes. For multi-capture matches, ALL captures share the topic;
-    // we pick the first matching key for efficiency.
+function topicsOf(match) {
+    const topics = new Set();
     for (const name of Object.keys(match)) {
         if (name.startsWith('@scope.'))
-            return 'scope';
-        if (name.startsWith('@declaration.'))
-            return 'declaration';
-        if (name.startsWith('@import.'))
-            return 'import';
-        if (name.startsWith('@type-binding.'))
-            return 'type-binding';
-        if (name.startsWith('@reference.'))
-            return 'reference';
-    }
-    return 'unknown';
+            topics.add('scope');
+        else if (name.startsWith('@declaration.'))
+            topics.add('declaration');
+        else if (name.startsWith('@import.'))
+            topics.add('import');
+        else if (name.startsWith('@type-binding.'))
+            topics.add('type-binding');
+        else if (name.startsWith('@reference.'))
+            topics.add('reference');
+        else if (name.startsWith('@callable-flow.'))
+            topics.add('callable-flow');
+    }
+    return topics;
 }
 function ensureModuleScope(scopeDrafts, filePath, allMatches) {
     const moduleScope = scopeDrafts.find((s) => s.kind === 'Module');
@@ -299,6 +308,8 @@ function resolveKindForScopeMatch(match, anchor, provider) {
             return 'Block';
         case 'expression':
             return 'Expression';
+        case 'object':
+            return 'Object';
         default:
             return null;
     }
@@ -574,6 +585,8 @@ function normalizeNodeLabel(kindStr) {
             return 'Annotation';
         case 'namespace':
             return 'Namespace';
+        case 'program':
+            return 'Module';
         case 'macro':
             return 'Macro';
         default:
@@ -757,13 +770,15 @@ function followChainedRef(start, draftById) {
  * name in the same scope. Higher number wins; ties keep the later match
  * (last-write-wins preserves historical order within a tier).
  *
- * Rationale: explicit annotations always beat inferred ones because they
- * reflect user intent. `self`/`cls` are treated as strongly as annotations
- * because they are language-required receiver types.
+ * Rationale: explicit variable and field annotations always beat bindings
+ * derived from parameter annotations or inference because they reflect the
+ * most specific user intent. `self`/`cls` are treated as strongly as other
+ * declared types because they are language-required receiver types.
  */
 function typeBindingStrength(source) {
     switch (source) {
         case 'annotation':
+            return 3;
         case 'parameter-annotation':
         case 'return-annotation':
         case 'self':
@@ -801,6 +816,9 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
         const arity = extractArity(match);
         const argumentTypes = extractArgumentTypes(match);
         const argumentTypeClasses = parseJsonParameterTypeClassesCapture(match['@reference.parameter-type-classes']);
+        // Object-literal key for value-ref sites (`{ key: fn }` / shorthand);
+        // consumed by the property-dispatch pass (#2437).
+        const propertyKeyCap = match['@reference.property-key'];
         const site = {
             name: nameCap.text,
             atRange: anchor.range,
@@ -809,6 +827,9 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
             ...(qualifiedCap?.text !== undefined && qualifiedCap.text.length > 0
                 ? { rawQualifiedName: qualifiedCap.text }
                 : {}),
+            ...(propertyKeyCap?.text !== undefined && propertyKeyCap.text.length > 0
+                ? { propertyKey: propertyKeyCap.text }
+                : {}),
             ...(callForm !== undefined ? { callForm } : {}),
             ...(explicitReceiver !== undefined ? { explicitReceiver } : {}),
             ...(arity !== undefined ? { arity } : {}),
@@ -840,6 +861,8 @@ function referenceKindFromAnchor(name) {
             return 'import-use';
         case 'macro':
             return 'macro';
+        case 'value-ref':
+            return 'value-ref';
         default:
             return undefined;
     }
@@ -893,6 +916,245 @@ function extractArgumentTypes(match) {
     }
     return undefined;
 }
+// ─── Pass 6: collect callable-value-flow facts ─────────────────────────────
+const CALLABLE_FLOW_KINDS = [
+    'seed',
+    'copy',
+    'alias',
+    'address',
+    'store',
+    'load',
+    'formal',
+    'argument',
+    'invoke',
+];
+function pass6CollectCallableFlows(matches, positionIndex, filePath, out) {
+    for (const match of matches) {
+        const kind = callableFlowKind(match);
+        if (kind === undefined)
+            continue;
+        const anchor = match[`@callable-flow.${kind}`];
+        if (anchor === undefined)
+            continue;
+        switch (kind) {
+            case 'seed': {
+                const destination = callableFlowOperand(match, 'destination', positionIndex, filePath);
+                const target = match['@callable-flow.target'];
+                const targetName = match['@callable-flow.target-name']?.text ?? target?.text;
+                if (destination === undefined || target === undefined || !nonEmpty(targetName))
+                    continue;
+                const expectedSignature = callableFlowExpectedSignature(match);
+                out.push({
+                    kind,
+                    destination,
+                    targetName,
+                    targetRange: target.range,
+                    ...(nonEmpty(match['@callable-flow.target-qualified-name']?.text)
+                        ? { targetQualifiedName: match['@callable-flow.target-qualified-name'].text }
+                        : {}),
+                    ...(expectedSignature !== undefined ? { expectedSignature } : {}),
+                });
+                break;
+            }
+            case 'copy':
+            case 'alias': {
+                const source = callableFlowOperand(match, 'source', positionIndex, filePath);
+                const destination = callableFlowOperand(match, 'destination', positionIndex, filePath);
+                if (source === undefined || destination === undefined)
+                    continue;
+                out.push({ kind, source, destination });
+                break;
+            }
+            case 'address': {
+                const source = callableFlowOperand(match, 'source', positionIndex, filePath);
+                const destination = callableFlowOperand(match, 'destination', positionIndex, filePath);
+                if (source === undefined || destination === undefined)
+                    continue;
+                out.push({ kind, source, destination });
+                break;
+            }
+            case 'store': {
+                const source = callableFlowOperand(match, 'source', positionIndex, filePath);
+                const pointer = callableFlowOperand(match, 'pointer', positionIndex, filePath);
+                if (source === undefined || pointer === undefined)
+                    continue;
+                out.push({ kind, source, pointer });
+                break;
+            }
+            case 'load': {
+                const pointer = callableFlowOperand(match, 'pointer', positionIndex, filePath);
+                const destination = callableFlowOperand(match, 'destination', positionIndex, filePath);
+                if (pointer === undefined || destination === undefined)
+                    continue;
+                out.push({ kind, pointer, destination });
+                break;
+            }
+            case 'formal': {
+                const owner = match['@callable-flow.owner'];
+                const binding = callableFlowOperand(match, 'binding', positionIndex, filePath);
+                const parameterIndex = parseNonNegativeInt(match['@callable-flow.parameter-index']?.text);
+                const passingMode = parseCallablePassingMode(match['@callable-flow.passing-mode']?.text);
+                if (owner === undefined ||
+                    !nonEmpty(owner.text) ||
+                    binding === undefined ||
+                    parameterIndex === undefined ||
+                    passingMode === undefined) {
+                    continue;
+                }
+                const expectedSignature = callableFlowExpectedSignature(match);
+                out.push({
+                    kind,
+                    ownerName: owner.text,
+                    ownerRange: owner.range,
+                    parameterIndex,
+                    binding,
+                    passingMode,
+                    ...(expectedSignature !== undefined ? { expectedSignature } : {}),
+                });
+                break;
+            }
+            case 'argument': {
+                const source = callableFlowOperand(match, 'source', positionIndex, filePath);
+                const parameterIndex = parseNonNegativeInt(match['@callable-flow.parameter-index']?.text);
+                if (source === undefined || parameterIndex === undefined)
+                    continue;
+                out.push({
+                    kind,
+                    callSite: anchor.range,
+                    parameterIndex,
+                    source,
+                    ...(nonEmpty(match['@callable-flow.direct-callee-name']?.text)
+                        ? { directCalleeName: match['@callable-flow.direct-callee-name'].text }
+                        : {}),
+                });
+                break;
+            }
+            case 'invoke': {
+                const callee = callableFlowOperand(match, 'callee', positionIndex, filePath);
+                const inScope = positionIndex.atPosition(filePath, anchor.range.startLine, anchor.range.startCol);
+                const invocationKind = parseCallableInvocationKind(match['@callable-flow.invocation-kind']?.text);
+                if (callee === undefined || inScope === undefined || invocationKind === undefined)
+                    continue;
+                const receiver = callableFlowOperand(match, 'receiver', positionIndex, filePath);
+                const arity = parseNonNegativeInt(match['@callable-flow.arity']?.text);
+                out.push({
+                    kind,
+                    callSite: anchor.range,
+                    inScope,
+                    callee,
+                    invocationKind,
+                    ...(receiver !== undefined ? { receiver } : {}),
+                    ...(arity !== undefined ? { arity } : {}),
+                });
+                break;
+            }
+        }
+    }
+}
+function callableFlowKind(match) {
+    return CALLABLE_FLOW_KINDS.find((kind) => match[`@callable-flow.${kind}`] !== undefined);
+}
+function callableFlowOperand(match, role, positionIndex, filePath) {
+    const cap = match[`@callable-flow.${role}`];
+    if (cap === undefined || !nonEmpty(cap.text))
+        return undefined;
+    const inScope = positionIndex.atPosition(filePath, cap.range.startLine, cap.range.startCol);
+    if (inScope === undefined)
+        return undefined;
+    const expressionKind = parseCallableOperandKind(match[`@callable-flow.${role}-kind`]?.text);
+    const indirection = parseNonNegativeInt(match[`@callable-flow.${role}-indirection`]?.text);
+    if (indirection !== undefined && indirection > 16)
+        return undefined;
+    return {
+        name: cap.text,
+        inScope,
+        atRange: cap.range,
+        indirection: indirection ?? 0,
+        addressOf: match[`@callable-flow.${role}-address`]?.text === 'true',
+        ...(expressionKind !== undefined ? { expressionKind } : {}),
+        ...(nonEmpty(match[`@callable-flow.${role}-qualified-name`]?.text)
+            ? { qualifiedName: match[`@callable-flow.${role}-qualified-name`].text }
+            : {}),
+    };
+}
+function callableFlowExpectedSignature(match) {
+    const parameterCount = parseNonNegativeInt(match['@callable-flow.expected-arity']?.text);
+    const parameterTypes = parseJsonStringArray(match['@callable-flow.expected-types']?.text);
+    const parameterTypeClasses = parseJsonParameterTypeClassesCapture(match['@callable-flow.expected-type-classes']);
+    const isConst = parseBooleanText(match['@callable-flow.expected-const']?.text);
+    if (parameterCount === undefined &&
+        parameterTypes === undefined &&
+        parameterTypeClasses === undefined &&
+        isConst === undefined) {
+        return undefined;
+    }
+    return {
+        ...(parameterCount !== undefined ? { parameterCount } : {}),
+        ...(parameterTypes !== undefined ? { parameterTypes } : {}),
+        ...(parameterTypeClasses !== undefined ? { parameterTypeClasses } : {}),
+        ...(isConst !== undefined ? { isConst } : {}),
+    };
+}
+function parseCallableOperandKind(text) {
+    switch (text) {
+        case 'binding':
+        case 'callable-designator':
+        case 'bound-member':
+        case 'anonymous-callable':
+            return text;
+        default:
+            return undefined;
+    }
+}
+function parseBooleanText(text) {
+    if (text === 'true')
+        return true;
+    if (text === 'false')
+        return false;
+    return undefined;
+}
+function parseJsonStringArray(text) {
+    if (text === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        return Array.isArray(parsed) && parsed.every((value) => typeof value === 'string')
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseNonNegativeInt(text) {
+    if (text === undefined || !/^\d+$/.test(text))
+        return undefined;
+    const value = Number.parseInt(text, 10);
+    return Number.isSafeInteger(value) ? value : undefined;
+}
+function parseCallablePassingMode(text) {
+    switch (text) {
+        case 'value':
+        case 'reference':
+        case 'pointer':
+            return text;
+        default:
+            return undefined;
+    }
+}
+function parseCallableInvocationKind(text) {
+    switch (text) {
+        case 'indirect':
+        case 'member-pointer':
+        case 'callable-object':
+            return text;
+        default:
+            return undefined;
+    }
+}
+function nonEmpty(value) {
+    return value !== undefined && value.length > 0;
+}
 // ─── Internal: range + capture utilities ───────────────────────────────────
 function rangesEqual(a, b) {
     return (a.startLine === b.startLine &&
@@ -919,6 +1181,7 @@ const KNOWN_SUB_TAGS = new Set([
     '@type-binding.type',
     '@reference.name',
     '@reference.qualified-name',
+    '@reference.property-key',
     '@reference.receiver',
     '@reference.operator',
     '@reference.arity',

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -267,7 +267,7 @@
  * Plan that introduced most of these invariants:
  * `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
-import type { BindingRef, Callsite, ConstraintContext, ParsedFile, ReferenceSite, ScopeId, SupportedLanguages, SymbolDefinition } from '../../../../_shared/index.js';
+import type { BindingRef, Callsite, ConstraintContext, ParsedFile, ParsedImport, ReferenceSite, ScopeId, SupportedLanguages, SymbolDefinition } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { LanguageProvider } from '../../language-provider.js';
@@ -288,6 +288,10 @@ export type ReceiverMemberResolution = {
     readonly kind: 'ambiguous';
     readonly candidateIds: readonly string[];
 };
+export interface ImportResolutionContext {
+    readonly parsedFiles: readonly ParsedFile[];
+    readonly parsedImport?: ParsedImport;
+}
 /** Re-exported for ScopeResolver consumers — same shape as
  *  `RegistryProviders.constraintCompatibility`'s third parameter. */
 export type { ConstraintContext } from '../../../../_shared/index.js';
@@ -320,8 +324,13 @@ export interface ScopeResolver {
      * orchestrator). TypeScript uses this to thread `tsconfig.json` path
      * aliases through to the standard resolver. Languages that don't
      * need any extra config ignore the parameter.
+     *
+     * `context.parsedFiles` is the complete, read-only language workspace. It is
+     * optional so resolvers that only need paths retain their existing shape.
+     * `context.parsedImport` is the exact import being finalized. PHP uses both
+     * when a PSR-4 import names a function instead of a file.
      */
-    resolveImportTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown): string | readonly string[] | null;
+    resolveImportTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown, context?: ImportResolutionContext): string | readonly string[] | null;
     /**
      * Enumerate names visible through a wildcard import after the target
      * module scope has been linked. Languages that do not support
@@ -364,6 +373,21 @@ export interface ScopeResolver {
      * `(def, callsite)` and need an adapter at the wiring site.
      */
     arityCompatibility(callsite: Callsite, def: SymbolDefinition): ArityVerdict;
+    /**
+     * Add provider-specific callable value targets beyond the shared
+     * Function/Method/Constructor set. This is intentionally a predicate hook:
+     * shared flow analysis never branches on a language name or syntax kind.
+     */
+    readonly isCallableValueTarget?: (def: SymbolDefinition) => boolean;
+    /**
+     * Restrict this provider's scope-resolution graph mutations to callable-value
+     * CALLS edges. Providers with an existing structural edge pipeline can use
+     * the shared scope model and callable solver without duplicating their
+     * established CALLS, IMPORTS, heritage, or property-dispatch edges.
+     *
+     * Default: `all`.
+     */
+    readonly scopeResolutionEdgeMode?: 'all' | 'callable-flow-only';
     /**
      * Per-language constraint compatibility between a callsite and a
      * candidate `def` that carries `templateConstraints` metadata.
@@ -555,6 +579,21 @@ export interface ScopeResolver {
      * and any text the simple `isSuperReceiver` hook also rejects.
      */
     readonly isSuperReceiverInContext?: (receiverText: string, callerScope: ScopeId, scopes: ScopeResolutionIndexes) => boolean;
+    /**
+     * Source-text retention policy for post-extraction hooks that receive a
+     * `fileContents` context (`populateWorkspaceOwners`,
+     * `populateNamespaceSiblings`, `populateRangeBindings`, and
+     * `emitPostResolutionEdges`).
+     *
+     * The default, `all-files`, preserves the existing contract: source text is
+     * loaded for every file before any of those hooks run. A resolver may choose
+     * `uncached-files` only when all of its hooks derive cached-file facts from
+     * `ParsedFile` / capture side-channels and tolerate an empty content string
+     * for pre-extracted files. This keeps the durable ParsedFile path at
+     * O(uncached source) memory without putting language checks in the shared
+     * pipeline.
+     */
+    readonly postExtractSourceTextPolicy?: 'all-files' | 'uncached-files';
     /**
      * Whether the orchestrator should run `propagateImportedReturnTypes`
      * after finalize. Default `true`. TypeScript with explicit type
@@ -602,6 +641,23 @@ export interface ScopeResolver {
      * but is too loose as a default for strict module systems.
      */
     readonly allowGlobalFreeCallFallback?: boolean;
+    /**
+     * In this language every `Method` belongs to a class instance, so a
+     * FREE (receiver-less) call may resolve to a `Method` only when the
+     * caller's enclosing class chain — the class itself plus its MRO —
+     * contains the method's owner (#2550). Suppresses the finalize-bucket
+     * leak where an unqualified call matched any same-file method by bare
+     * name (`materializeBindings` flattens every declaration onto module
+     * scope). Java opts in; C# is the intended next adopter.
+     *
+     * NOT implemented via `LanguageProvider.builtInNames`: that mechanism
+     * has unrelated consumers (`parse-worker`'s call-site extraction gate
+     * suppresses member calls too; `type-env`'s return-type lookup) which
+     * assume a flagged name is never a real repository declaration —
+     * false for common method names like `run`/`get`/`compare` (verified
+     * regression).
+     */
+    readonly freeCallsRequireInstanceOwnership?: boolean;
     /**
      * When true, a constructor-form call `Type(...)` links to the Class def
      * itself rather than its explicit Constructor def. Default
@@ -644,6 +700,19 @@ export interface ScopeResolver {
      * Languages without file-local linkage semantics leave this undefined.
      */
     readonly isFileLocalDef?: (def: SymbolDefinition) => boolean;
+    /**
+     * Optional precise linkage predicate used when callable-value flow joins a
+     * declaration graph node (for example a C/C++ prototype in a caller file)
+     * to its out-of-file definition. Unlike `isFileLocalDef`, this hook MUST
+     * answer only language-level internal/file-local linkage. It must not fold
+     * in broader unqualified-name visibility rules such as namespace or member
+     * lookup: an explicit declaration already establishes caller visibility.
+     *
+     * C and C++ provide this hook for `static` free functions. Languages whose
+     * declaration/definition identity is already represented by imports or one
+     * graph node leave it undefined, disabling cross-file prototype joining.
+     */
+    readonly hasFileLocalCallableLinkage?: (def: SymbolDefinition) => boolean;
     /**
      * Optional predicate to identify members for which dispatch through
      * an instance receiver is **invalid at the language level** — i.e.

package/dist/core/ingestion/scope-resolution/graph-bridge/callee-id-sink.d.ts

@@ -21,9 +21,9 @@
  * `(atRange.startLine, atRange.startCol)` is byte-equal to U1's `at` — no
  * normalization needed.
  *
- * Gating (R4): the concrete sink is created in `run.ts` only when
- * `input.pdg === true`; otherwise `undefined` is threaded through, so off-mode
- * does zero work and emits byte-identical output.
+ * Gating (R4): the concrete sink is created in `run.ts` when PDG is enabled OR
+ * always-on callable-flow facts need direct call targets for actual→formal
+ * propagation. The read-side CFG join remains strictly PDG-gated.
  *
  * Multi-target dispatch (R2/KTD8): one site → multiple emit calls → the `Set`
  * accumulates every resolved target. Capture is per-emit-call, so the
@@ -67,9 +67,9 @@ export interface CalleeIdMapView {
 /** The concrete accumulator: a write sink that also exposes the read view. */
 export interface CalleeIdAccumulator extends CalleeIdSink, CalleeIdMapView {
 }
+export type CalleeIdCaptureFilter = (filePath: string, line: number, col: number) => boolean;
 /**
- * Create the concrete nested-`Map` accumulator. Call ONLY when
- * `input.pdg === true` (else thread `undefined` for byte-identity / zero
- * overhead — R4).
+ * Create the concrete nested-`Map` accumulator for PDG callee capture or
+ * callable-value-flow's direct-target index.
  */
-export declare function createCalleeIdAccumulator(): CalleeIdAccumulator;
+export declare function createCalleeIdAccumulator(shouldCapture?: CalleeIdCaptureFilter): CalleeIdAccumulator;

package/dist/core/ingestion/scope-resolution/graph-bridge/callee-id-sink.js

@@ -21,9 +21,9 @@
  * `(atRange.startLine, atRange.startCol)` is byte-equal to U1's `at` — no
  * normalization needed.
  *
- * Gating (R4): the concrete sink is created in `run.ts` only when
- * `input.pdg === true`; otherwise `undefined` is threaded through, so off-mode
- * does zero work and emits byte-identical output.
+ * Gating (R4): the concrete sink is created in `run.ts` when PDG is enabled OR
+ * always-on callable-flow facts need direct call targets for actual→formal
+ * propagation. The read-side CFG join remains strictly PDG-gated.
  *
  * Multi-target dispatch (R2/KTD8): one site → multiple emit calls → the `Set`
  * accumulates every resolved target. Capture is per-emit-call, so the
@@ -36,14 +36,15 @@ export function calleeIdPosKey(line, col) {
     return `${line}:${col}`;
 }
 /**
- * Create the concrete nested-`Map` accumulator. Call ONLY when
- * `input.pdg === true` (else thread `undefined` for byte-identity / zero
- * overhead — R4).
+ * Create the concrete nested-`Map` accumulator for PDG callee capture or
+ * callable-value-flow's direct-target index.
  */
-export function createCalleeIdAccumulator() {
+export function createCalleeIdAccumulator(shouldCapture) {
     const byFile = new Map();
     return {
         add(filePath, line, col, calleeId) {
+            if (shouldCapture?.(filePath, line, col) === false)
+                return;
             let byPos = byFile.get(filePath);
             if (byPos === undefined) {
                 byPos = new Map();

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

@@ -21,7 +21,9 @@ import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import type { CalleeIdSink } from './callee-id-sink.js';
 /**
  * Optional resolved-callee-id capture context (#2227 follow-up U2). Threaded
- * in only under `--pdg` (else `undefined` → zero overhead, byte-identity R4).
+ * in under `--pdg` OR when always-on callable-flow facts need direct call
+ * targets (#2437 — the accumulator then carries a position filter); else
+ * `undefined` → zero overhead, byte-identity (R4).
  * `filePath` is NOT on the `site` param, so it rides here alongside the sink.
  */
 export interface CalleeIdCaptureCtx {

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

@@ -31,6 +31,12 @@ export function mapReferenceKindToEdgeType(kind) {
             return 'EXTENDS';
         case 'type-reference':
             return 'USES';
+        // A function registered as an object-literal property value emits a
+        // reference-class USES edge, NOT CALLS — a registration is not an
+        // invocation (Kythe `ref` vs `ref/call`; Joern `METHOD_REF`). The
+        // invocation side is synthesized by the property-dispatch pass (#2437).
+        case 'value-ref':
+            return 'USES';
         // Macro invocations resolve to a `Macro` node (never a function), so
         // they emit `USES` — kept out of the `CALLS` keyspace which denotes
         // function/method dispatch (#1934 review).

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

@@ -44,6 +44,7 @@ function isCallerAnchorLabel(label) {
     return (label === 'Function' ||
         label === 'Method' ||
         label === 'Constructor' ||
+        label === 'Module' ||
         label === 'Class' ||
         label === 'Interface' ||
         label === 'Struct' ||