gitnexus 1.6.13-rc.37 → 1.6.13-rc.38

package/dist/core/ingestion/cfg/visitors/kotlin.d.ts

@@ -3,9 +3,10 @@
  *
  * Kotlin's tree-sitter grammar (vendored, NOT an npm package — loaded via
  * `requireVendoredGrammar('tree-sitter-kotlin')`, exactly like tree-sitter-swift)
- * is field-less for control flow: NONE of the control-flow nodes expose
- * `childForFieldName` fields (verified by a real parse — every `fieldNameForChild`
- * came back null), so this visitor navigates purely by child TYPE and position.
+ * is mostly field-less for control flow (`when` / loops / `try` / `elvis_expression`
+ * expose no fields), so this visitor navigates purely by child TYPE and position.
+ * `if_expression` is the exception: it DOES field `condition` / `consequence` /
+ * `alternative` (#3354 — callable-flow capture reads them); position still works.
  * Every node-type literal below was grammar-validated against the vendored
  * tree-sitter-kotlin via the introspection probe before use (mandatory pre-step —
  * the grammar-literal CI gate maps `kotlin.ts → Kotlin` and fails on a wrong

package/dist/core/ingestion/cfg/visitors/python-harvest.d.ts

@@ -46,8 +46,8 @@
  *  - reads: `attribute` (fields `object`/`attribute`), `subscript` (fields
  *    `value`/`subscript`), `call` (fields `function`/`arguments`),
  *    `boolean_operator` (fields `left`/`operator`/`right`),
- *    `conditional_expression` (ternary: consequent / condition / alternative in
- *    source order), `parenthesized_expression`.
+ *    `conditional_expression` (ternary, FIELDLESS: consequent, condition,
+ *    alternative as positional children), `parenthesized_expression`.
  *
  * TWO-PHASE, ORDER-INDEPENDENT (load-bearing — mirrors the TS / Go harvesters):
  * the CFG walk is NOT source-order, so resolving names against a scope stack

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

@@ -109,6 +109,23 @@ const DART_CALLABLE_CAPTURE_OPTIONS = {
     extractCallCallee: (node) => dartCallableCallee(node) ?? undefined,
     callSiteNode: (node) => dartCallableCallee(node) ?? undefined,
     callableProtocolMethods: new Set(['call']),
+    // tree-sitter-dart spells `a ?? b` as `if_null_expression(first:, second:)`
+    // and `c ? a : b` as a `conditional_expression` with `consequence` /
+    // `alternative` but NO `condition` field, so neither matches the shared
+    // field-based branch rule and only the last operand flowed (#3354).
+    valueAlternatives: (node) => {
+        if (node.type === 'if_null_expression') {
+            const first = node.childForFieldName('first');
+            const second = node.childForFieldName('second');
+            return first !== null && second !== null ? [first, second] : undefined;
+        }
+        if (node.type === 'conditional_expression') {
+            const consequence = node.childForFieldName('consequence');
+            const alternative = node.childForFieldName('alternative');
+            return consequence !== null && alternative !== null ? [consequence, alternative] : undefined;
+        }
+        return undefined;
+    },
 };
 function dartLexicalFunctionOwner(input) {
     let node = input;

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

@@ -57,7 +57,44 @@ const KOTLIN_CALLABLE_CAPTURE_OPTIONS = {
         return destination === undefined || source === undefined ? undefined : { destination, source };
     },
     normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+    valueAlternatives: (node) => kotlinValueAlternatives(node),
 };
+const isKotlinComment = (node) => node.type === 'line_comment' || node.type === 'multiline_comment';
+const namedNonComments = (node) => node.namedChildren.filter((child) => child !== null && !isKotlinComment(child));
+/**
+ * Branches of a Kotlin value-selecting expression (#3354). `a ?: b` is a
+ * FIELDLESS `elvis_expression` (positional operands), so the shared
+ * field-based rule never saw it and only the last operand flowed. An
+ * `if_expression` fields its branches as `control_structure_body` wrappers:
+ * a bare branch (`if (c) ::f`) holds the expression directly, a braced one
+ * (`if (c) { ::f }`) nests it one level deeper in a `statements` node. A
+ * branch holding exactly one expression is that expression's value; an
+ * empty or multi-statement block, or an `if` without `else`, keeps the
+ * whole `if` one opaque source.
+ */
+function kotlinValueAlternatives(node) {
+    if (node.type === 'elvis_expression') {
+        const operands = namedNonComments(node);
+        return operands.length === 2 ? operands : undefined;
+    }
+    if (node.type !== 'if_expression')
+        return undefined;
+    const branches = [];
+    for (const field of ['consequence', 'alternative']) {
+        const body = node.childForFieldName(field);
+        if (body === null)
+            return [node];
+        let values = namedNonComments(body);
+        const [block] = values;
+        if (values.length === 1 && block?.type === 'statements')
+            values = namedNonComments(block);
+        const [value] = values;
+        if (values.length !== 1 || value === undefined)
+            return [node];
+        branches.push(value);
+    }
+    return branches;
+}
 export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {

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

@@ -42,6 +42,19 @@ const PYTHON_CALLABLE_CAPTURE_OPTIONS = {
     assignmentNodeTypes: new Set(['assignment', 'named_expression']),
     identifierNodeTypes: new Set(['identifier']),
     functionScopedValueBindings: true,
+    // `a if c else b` is a FIELDLESS `conditional_expression` (positional
+    // value, condition, value), so the shared condition/consequence/alternative
+    // rule never sees its branches and only the last operand flowed (#3354).
+    // `a or b` is a fielded `boolean_operator` the shared rule already handles.
+    valueAlternatives: (node) => {
+        if (node.type !== 'conditional_expression')
+            return undefined;
+        const named = node.namedChildren.filter((child) => child !== null && child.type !== 'comment');
+        const [value, , alternative] = named;
+        return named.length === 3 && value !== undefined && alternative !== undefined
+            ? [value, alternative]
+            : undefined;
+    },
 };
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // Skip the parse when the caller (the scope-resolution orchestrator's

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

@@ -41,6 +41,7 @@ const RUBY_CALLABLE_CAPTURE_OPTIONS = {
     // Ruby (`action = process` stores process's RETURN value) — only explicit
     // reference forms (method(:x), &:x, lambda/proc) reference the callable.
     bareNamesAreCalls: true,
+    valueAlternatives: (node) => rubyValueAlternatives(node),
     extractCallableReference: (node) => {
         if (node.type !== 'call')
             return undefined;
@@ -55,6 +56,40 @@ const RUBY_CALLABLE_CAPTURE_OPTIONS = {
         return name.length === 0 ? undefined : { name, anchor: symbol };
     },
 };
+/**
+ * Branches of a statement-bodied `if` / `unless` / `elsif` (#3354). They field
+ * `condition` / `consequence` / `alternative` like a ternary, but their
+ * branches are `then` / `else` STATEMENT LISTS, so the shared ternary rule
+ * would dig an identifier out of whichever statement it found (`g = h; 0`
+ * flowed `h`, although the branch evaluates to `0`). A branch holding one
+ * statement is that statement's value. A longer branch is skipped: it adds
+ * no alternative, while the other branches still flow. Every alternative
+ * emitted is a value the conditional really evaluates to, so skipping cannot
+ * add an edge. It only drops the skipped branch's own value. The `elsif`
+ * chain is walked here, so one multi-statement `elsif` no longer hides the
+ * branches after it. When no branch is a single statement, the whole
+ * conditional stays one opaque source. The `c ? a : b` ternary
+ * (`conditional`) is left to the shared rule.
+ */
+function rubyValueAlternatives(node) {
+    if (node.type !== 'if' && node.type !== 'unless' && node.type !== 'elsif')
+        return undefined;
+    const branches = [];
+    for (let link = node; link !== null;) {
+        const consequence = link.childForFieldName('consequence');
+        const alternative = link.childForFieldName('alternative');
+        link = alternative?.type === 'elsif' ? alternative : null;
+        for (const branch of [consequence, link === null ? alternative : null]) {
+            if (branch === null)
+                continue;
+            const statements = branch.namedChildren.filter((child) => child !== null && child.type !== 'comment');
+            const [statement] = statements;
+            if (statements.length === 1 && statement !== undefined)
+                branches.push(statement);
+        }
+    }
+    return branches.length > 0 ? branches : [node];
+}
 /**
  * Build the full `.`-joined qualified owner name for a heritage/attr call by
  * walking ALL enclosing class/module ancestors (not just the immediate one),

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

@@ -94,6 +94,17 @@ const SWIFT_CALLABLE_CAPTURE_OPTIONS = {
     assignmentNodeTypes: new Set(['assignment']),
     identifierNodeTypes: new Set(['simple_identifier', 'type_identifier']),
     extractFunctionParameters: (node) => node.namedChildren.filter((child) => child !== null && child.type === 'parameter'),
+    // tree-sitter-swift fields `a ?? b` as `value` / `if_nil` and `c ? a : b` as
+    // `if_true` / `if_false`, neither of which the shared field-based branch
+    // rule knows, so only the last operand flowed (#3354).
+    valueAlternatives: (node) => {
+        const [first, second] = node.type === 'nil_coalescing_expression'
+            ? [node.childForFieldName('value'), node.childForFieldName('if_nil')]
+            : node.type === 'ternary_expression'
+                ? [node.childForFieldName('if_true'), node.childForFieldName('if_false')]
+                : [null, null];
+        return first !== null && second !== null ? [first, second] : undefined;
+    },
 };
 /** tree-sitter-swift node types that carry arity. */
 const FUNCTION_NODE_TYPES = [

package/dist/core/ingestion/utils/callable-flow-captures.d.ts

@@ -47,6 +47,12 @@
  *   `extractAssignment` (Kotlin's `assignment`, Dart's
  *   `initialized_identifier`). Returning `undefined` falls back to the shared
  *   path, so one callback can handle the odd node and leave the rest alone.
+ * - A **fieldless or oddly-fielded** `??`/`?:`/elvis/ternary node is invisible
+ *   to the shared branch expansion, so only one operand (if any) flows.
+ *   Supply `valueAlternatives` (Kotlin's `elvis_expression`, Swift's
+ *   `nil_coalescing_expression`, Dart's `if_null_expression`, Python's
+ *   `conditional_expression`); return `[node]` to keep a statement-bodied
+ *   `if` opaque (Ruby).
  * - A binding needs a `SymbolDefinition` for the pass to attach to. Captures
  *   alone are not enough: without a `@declaration.*` for the bound name, the
  *   seed has no cell to key on.
@@ -139,6 +145,20 @@ export interface CallableFlowCaptureOptions {
         readonly anchor: SyntaxNode;
         readonly qualifiedName?: string;
     } | undefined;
+    /**
+     * Provider-owned branches of a value-selecting expression (#3354). The
+     * shared rule only knows the field shapes `left`/`operator`/`right` (with a
+     * `??`/`||`/`or` operator) and `condition`/`consequence`/`alternative`; a
+     * grammar that spells the same construct differently (fieldless children,
+     * `value`/`if_nil`, `first`/`second`, a ternary without a `condition`
+     * field) supplies the branches here. Each returned branch is expanded again,
+     * so chains work. Returning `[node]` means "recognized, but opaque": the
+     * whole expression stays one source, which is how a provider keeps the
+     * shared ternary rule off a statement-bodied `if` whose branches are
+     * statement lists, not values. `undefined` falls back to the shared rule
+     * (mirrors `extractAssignment`).
+     */
+    readonly valueAlternatives?: (node: SyntaxNode) => readonly SyntaxNode[] | undefined;
 }
 /**
  * Emit normalized flow captures in deterministic source order.
@@ -146,6 +166,10 @@ export interface CallableFlowCaptureOptions {
  * One explicit DFS supplies all phases below. Query-backed emitters may still
  * perform their existing query walk; this helper never reparses and remains
  * linear in AST size (the scope-capture benchmark guards the scaling ratio).
+ * That includes a value-selecting source: `valueAlternatives` expands a
+ * chain iteratively into disjoint leaves, and each leaf's visibility walk
+ * reuses the memoized anchor spine instead of re-walking to the root (the
+ * `typescript-deep-chain` benchmark case guards that one).
  */
 export declare function synthesizeCallableFlowCaptures(root: SyntaxNode, options: CallableFlowCaptureOptions): readonly CaptureMatch[];
 /**

package/dist/core/ingestion/utils/callable-flow-captures.js

@@ -47,6 +47,12 @@
  *   `extractAssignment` (Kotlin's `assignment`, Dart's
  *   `initialized_identifier`). Returning `undefined` falls back to the shared
  *   path, so one callback can handle the odd node and leave the rest alone.
+ * - A **fieldless or oddly-fielded** `??`/`?:`/elvis/ternary node is invisible
+ *   to the shared branch expansion, so only one operand (if any) flows.
+ *   Supply `valueAlternatives` (Kotlin's `elvis_expression`, Swift's
+ *   `nil_coalescing_expression`, Dart's `if_null_expression`, Python's
+ *   `conditional_expression`); return `[node]` to keep a statement-bodied
+ *   `if` opaque (Ruby).
  * - A binding needs a `SymbolDefinition` for the pass to attach to. Captures
  *   alone are not enough: without a `@declaration.*` for the bound name, the
  *   seed has no cell to key on.
@@ -61,16 +67,23 @@ import { nodeToCapture, syntheticCapture } from './ast-helpers.js';
  * One explicit DFS supplies all phases below. Query-backed emitters may still
  * perform their existing query walk; this helper never reparses and remains
  * linear in AST size (the scope-capture benchmark guards the scaling ratio).
+ * That includes a value-selecting source: `valueAlternatives` expands a
+ * chain iteratively into disjoint leaves, and each leaf's visibility walk
+ * reuses the memoized anchor spine instead of re-walking to the root (the
+ * `typescript-deep-chain` benchmark case guards that one).
  */
 export function synthesizeCallableFlowCaptures(root, options) {
-    const nodes = collectNodes(root);
+    const parentById = new Map();
+    const nodes = collectNodes(root, parentById);
     const functions = collectFunctions(nodes, options);
     const knownCallableNames = new Set(functions.map((fn) => fn.name));
     const assignments = collectAssignments(nodes, options);
-    const valueBindings = buildValueBindingIndex(nodes, assignments, functions, options);
+    const valueBindings = buildValueBindingIndex(nodes, parentById, assignments, functions, options);
     const out = [];
     for (const assignment of assignments) {
-        emitAssignmentFact(assignment, knownCallableNames, valueBindings, options, out);
+        for (const source of valueAlternatives(assignment.source, options)) {
+            emitAssignmentFact({ ...assignment, source }, knownCallableNames, valueBindings, options, out);
+        }
     }
     for (const fn of functions)
         emitFormalFacts(fn, options, out);
@@ -83,7 +96,9 @@ export function synthesizeCallableFlowCaptures(root, options) {
     out.sort((a, b) => compareCaptures(firstCapture(a), firstCapture(b)));
     return out;
 }
-function collectNodes(root) {
+/** Every named node in document order; also records each one's parent into
+ *  `parentById` (see `ValueBindingIndex.parentById`). */
+function collectNodes(root, parentById) {
     const out = [];
     const stack = [root];
     while (stack.length > 0) {
@@ -92,8 +107,10 @@ function collectNodes(root) {
         const children = node.namedChildren;
         for (let i = children.length - 1; i >= 0; i--) {
             const child = children[i];
-            if (child !== null)
-                stack.push(child);
+            if (child === null)
+                continue;
+            parentById.set(child.id, node);
+            stack.push(child);
         }
     }
     return out;
@@ -163,7 +180,7 @@ function collectAssignments(nodes, options) {
     }
     return out;
 }
-function buildValueBindingIndex(nodes, assignments, functions, options) {
+function buildValueBindingIndex(nodes, parentById, assignments, functions, options) {
     const assignmentRegionIdsByName = new Map();
     const memberStoreRegionIdsByName = new Map();
     const formalByOwner = new Map();
@@ -250,13 +267,59 @@ function buildValueBindingIndex(nodes, assignments, functions, options) {
                 byRegion.set(functionOwner.id, signature);
         }
     }
+    const anchorIds = new Set();
+    for (const index of [assignmentRegionIdsByName, memberStoreRegionIdsByName]) {
+        for (const regionIds of index.values())
+            for (const id of regionIds)
+                anchorIds.add(id);
+    }
+    for (const byRegion of signatureByNameAndRegion.values()) {
+        for (const id of byRegion.keys())
+            anchorIds.add(id);
+    }
+    for (const owner of formalByOwner.keys())
+        if (owner !== undefined)
+            anchorIds.add(owner);
     return {
         assignmentRegionIdsByName,
         memberStoreRegionIdsByName,
         formalByOwner,
         signatureByNameAndRegion,
+        anchorIds,
+        parentById,
+        nearestAnchorById: new Map(),
     };
 }
+/** A node the DFS did not reach (none in practice) falls back to tree-sitter. */
+function parentOf(node, bindings) {
+    return bindings.parentById.get(node.id) ?? node.parent;
+}
+/**
+ * The nearest anchor at-or-above `start` (see `ValueBindingIndex.anchorIds`),
+ * or null when none is. Every node visited on the way is memoized, so across
+ * one file each node's `parent` is taken at most once by these walks.
+ */
+function nearestAnchor(start, bindings) {
+    const visited = [];
+    let node = start;
+    let found = null;
+    while (node !== null) {
+        const cached = bindings.nearestAnchorById.get(node.id);
+        if (cached !== undefined) {
+            found = cached;
+            break;
+        }
+        visited.push(node.id);
+        if (bindings.anchorIds.has(node.id)) {
+            found = node;
+            break;
+        }
+        node = parentOf(node, bindings);
+    }
+    for (const id of visited)
+        bindings.nearestAnchorById.set(id, found);
+    return found;
+}
 /** True when a pointer/parenthesized declarator sits between the declaration
  *  and its binding identifier — the shape of a callable-typed variable, never
  *  of a plain prototype. Only C/C++ supply signature-declaration node types,
@@ -307,15 +370,13 @@ function isVisibleValueBinding(input, name, bindings, options) {
             bindings.formalByOwner.get(providerOwner.id)?.has(name) === true)) {
         return true;
     }
-    let node = input;
-    while (node !== null) {
+    for (let node = nearestAnchor(input, bindings); node !== null; node = nearestAnchor(parentOf(node, bindings), bindings)) {
         if (assignmentRegionIds?.has(node.id) === true)
             return true;
         if (options.functionNodeTypes.has(node.type) &&
             bindings.formalByOwner.get(node.id)?.has(name) === true) {
             return true;
         }
-        node = node.parent;
     }
     if (bindings.formalByOwner.get(undefined)?.has(name) === true)
         return true;
@@ -341,11 +402,9 @@ function isVisibleMemberStore(input, name, bindings, options) {
         const providerOwner = options.lexicalFunctionOwner?.(input);
         if (providerOwner !== undefined && regionIds.has(providerOwner.id))
             return true;
-        let node = input;
-        while (node !== null) {
+        for (let node = nearestAnchor(input, bindings); node !== null; node = nearestAnchor(parentOf(node, bindings), bindings)) {
             if (regionIds.has(node.id))
                 return true;
-            node = node.parent;
         }
     }
     return visibleCallableSignature(input, name, bindings, options) !== undefined;
@@ -360,12 +419,10 @@ function visibleCallableSignature(input, name, bindings, options) {
         if (signature !== undefined)
             return signature;
     }
-    let node = input;
-    while (node !== null) {
+    for (let node = nearestAnchor(input, bindings); node !== null; node = nearestAnchor(parentOf(node, bindings), bindings)) {
         const signature = byRegion.get(node.id);
         if (signature !== undefined)
             return signature;
-        node = node.parent;
     }
     return undefined;
 }
@@ -402,6 +459,108 @@ function assignmentParts(node, options) {
         return [];
     return [{ container: node, destination, source }];
 }
+/** Operators whose result is one of their operands, not a computed value. */
+const VALUE_SELECTING_OPERATORS = new Set(['??', '||', 'or']);
+/**
+ * Operators that yield their left operand when it is falsy and their right
+ * operand otherwise. A falsy value is never a callable, so only the RIGHT
+ * operand can be the callable that is later invoked. Where `&&` / `and`
+ * yields a boolean instead (Java, C#, Go, Rust, C, C++, PHP, Zig), the
+ * destination is not callable, so the flow never meets an invoke.
+ */
+const RIGHT_SELECTING_OPERATORS = new Set(['&&', 'and']);
+/**
+ * The operands a value-selecting expression can evaluate to (#3354):
+ * `a ?? b`, `a || b`, `a or b`, and `c ? a : b` each yield one of their
+ * branches, so each branch flows into the destination. `a && b` / `a and b`
+ * can only yield a callable through `b`, so `x and f or g` reaches `f` and `g`.
+ * Anything else is its own single alternative, which leaves every other
+ * source shape untouched. A branch that is itself an operator expression
+ * (`x.kind === f || g`) yields a computed value, so it contributes nothing.
+ * `options.valueAlternatives` is consulted first for grammars whose shape the
+ * field-based rule below cannot see.
+ */
+function valueAlternatives(node, options) {
+    // Explicit stack, not recursion: `a || b || …` nests one level per operand,
+    // so a generated keyword table thousands of operands long overflowed the
+    // call stack (and re-copied every partial result at each level).
+    const out = [];
+    const pending = [node];
+    for (let current = pending.pop(); current !== undefined; current = pending.pop()) {
+        const branches = valueBranches(current, options);
+        if (branches === undefined) {
+            // An operator branch is opaque, as the whole compound source was before
+            // the fan-out: emitted alone, `x.kind === Handlers.run` becomes a seed
+            // whose qualified text slices to receiver `Handlers`, member `run`.
+            if (current === node || !isBinaryOperatorExpression(unwrapParentheses(current))) {
+                out.push(current);
+            }
+            continue;
+        }
+        // Reverse push keeps the left-to-right branch order on output.
+        for (let i = branches.length - 1; i >= 0; i--) {
+            const branch = branches[i];
+            if (branch !== undefined)
+                pending.push(branch);
+        }
+    }
+    return out;
+}
+/** One level of `valueAlternatives`: the branches `node` selects between, or
+ *  undefined when it is opaque (its own single alternative). */
+function valueBranches(node, options) {
+    const inner = unwrapParentheses(node);
+    const provided = options.valueAlternatives?.(inner);
+    if (provided !== undefined) {
+        return provided.length === 1 && provided[0]?.id === inner.id ? undefined : provided;
+    }
+    const consequence = inner.childForFieldName('consequence');
+    const alternative = inner.childForFieldName('alternative');
+    if (consequence !== null && alternative !== null && inner.childForFieldName('condition')) {
+        return [consequence, alternative];
+    }
+    const left = inner.childForFieldName('left');
+    const right = inner.childForFieldName('right');
+    const operator = inner.childForFieldName('operator')?.type;
+    if (left === null || right === null || !operator)
+        return undefined;
+    if (VALUE_SELECTING_OPERATORS.has(operator))
+        return [left, right];
+    if (RIGHT_SELECTING_OPERATORS.has(operator))
+        return [right];
+    return undefined;
+}
+function unwrapParentheses(node) {
+    let inner = node;
+    while (inner.type.includes('parenthesized') && inner.namedChildCount === 1) {
+        const child = inner.namedChild(0);
+        if (child === null)
+            break;
+        inner = child;
+    }
+    return inner;
+}
+/**
+ * True for an expression that computes a value from two operands (`a === b`,
+ * `a + b`, `a is b`), which designates neither operand. Read from the same
+ * field vocabulary as `valueBranches` rather than grammar type names: a
+ * `left`/`right` pair, or an operator token (`operator`, Python's
+ * `operators`, Swift's `op`) that follows the expression's start. A member
+ * access that fields its `.` / `->` as `operator` (Ruby `call`, C/C++
+ * `field_expression`) also fields its member name, so it stays a designator;
+ * a unary `&f` / `*fp` leads with its operator and stays one too.
+ */
+function isBinaryOperatorExpression(node) {
+    if (node.childForFieldName('left') !== null && node.childForFieldName('right') !== null) {
+        return true;
+    }
+    if (memberNameNode(node) !== null)
+        return false;
+    const operator = node.childForFieldName('operator') ??
+        node.childForFieldName('operators') ??
+        node.childForFieldName('op');
+    return operator !== null && operator.startIndex > node.startIndex;
+}
 function emitAssignmentFact(assignment, knownCallableNames, valueBindings, options, out) {
     const destination = operandSyntax(assignment.destination, options, options.bindingNodeTypes.has(assignment.container.type));
     const source = operandSyntax(assignment.source, options);
@@ -699,10 +858,7 @@ function memberParts(input, options) {
     // stay unaffected. Without it every `x.f(arg)` in such a grammar collapsed
     // to a DIRECT call named `f` and the flow solver fanned the argument out to
     // every same-named callable.
-    const memberNode = node.childForFieldName('property') ??
-        node.childForFieldName('field') ??
-        node.childForFieldName('method') ??
-        node.childForFieldName('member');
+    const memberNode = memberNameNode(node);
     if (receiverNode === null || memberNode === null)
         return undefined;
     const receiver = operandSyntax(receiverNode, options);
@@ -713,6 +869,14 @@ function memberParts(input, options) {
         options.memberPointerOperators?.has(child.text) === true);
     return { receiver, member, ...(operator !== undefined ? { operator: operator.text } : {}) };
 }
+/** The member-name child of a member access, under the field names the
+ *  grammars use for it. */
+function memberNameNode(node) {
+    return (node.childForFieldName('property') ??
+        node.childForFieldName('field') ??
+        node.childForFieldName('method') ??
+        node.childForFieldName('member'));
+}
 function operandSyntax(input, options, declarationBinding = false) {
     if (declarationBinding) {
         const binding = bindingIdentifier(input, options);

package/dist/mcp/local/local-backend.js

@@ -178,6 +178,14 @@ function resolveAliasString(canonical, legacy) {
     }
     return undefined;
 }
+/**
+ * A `*_uid` param as a lookup key: trimmed, or `undefined` when it is blank or
+ * not a string (#3354). Strict adapters send `" "`/`""` for an omitted optional
+ * string, and the MCP envelope is not type-validated.
+ */
+function nonBlankUid(value) {
+    return typeof value === 'string' ? value.trim() || undefined : undefined;
+}
 const TOOL_STRING_ALIASES = {
     impact: [{ canonical: 'target', aliases: ['name', 'symbol'] }],
     context: [{ canonical: 'file_path', aliases: ['file'] }],
@@ -3510,7 +3518,11 @@ export class LocalBackend {
      * same filePath), the Class wins silently.
      */
     async resolveSymbolCandidates(repo, query, hints) {
-        const { uid, name, include_content } = query;
+        const { name, include_content } = query;
+        // A blank or non-string uid is omitted, not a lookup key — fall through to
+        // the name instead of `not_found`, matching normalizeToolParams' impact
+        // target_uid check.
+        const uid = nonBlankUid(query.uid);
         const selectClause = `n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''}`;
         // Direct UID — zero-ambiguity path.
         if (uid) {
@@ -5510,7 +5522,7 @@ export class LocalBackend {
         if (fromOutcome.kind === 'not_found') {
             return {
                 status: 'not_found',
-                error: `Source symbol '${params.from_uid ?? params.from}' not found.`,
+                error: `Source symbol '${nonBlankUid(params.from_uid) ?? params.from}' not found.`,
                 suggestion: 'Check the symbol name or use --from-uid for zero-ambiguity.',
             };
         }
@@ -5528,7 +5540,7 @@ export class LocalBackend {
         if (toOutcome.kind === 'not_found') {
             return {
                 status: 'not_found',
-                error: `Target symbol '${params.to_uid ?? params.to}' not found.`,
+                error: `Target symbol '${nonBlankUid(params.to_uid) ?? params.to}' not found.`,
                 suggestion: 'Check the symbol name or use --to-uid for zero-ambiguity.',
             };
         }
@@ -5852,7 +5864,7 @@ export class LocalBackend {
         // selected silently.
         const outcome = await this.resolveSymbolCandidates(repo, { uid: params.target_uid, name: target }, { file_path: params.file_path, kind: params.kind });
         if (outcome.kind === 'not_found') {
-            const missing = params.target_uid ?? target;
+            const missing = nonBlankUid(params.target_uid) ?? target;
             // not_found = no resolved symbol, so the envelope keeps the partial-but-
             // typed target (typed PdgImpactTarget — there is no id/type/filePath yet).
             const notFoundTarget = { name: target };
@@ -6549,6 +6561,12 @@ export class LocalBackend {
         const safeMinConfidence = Number.isFinite(minConfidence) ? minConfidence : 0;
         const confidenceFilter = safeMinConfidence > 0 ? ' AND r.confidence >= $minConfidence' : '';
         const symId = sym.id || sym[0];
+        // #3354: a walk with no anchor id cannot say anything about THIS symbol,
+        // yet it still ships a normal-looking `exact` result with the target's
+        // name echoed back. Throw so every caller's catch reports UNKNOWN instead.
+        if (!symId) {
+            throw new Error(`Impact target '${sym.name || sym[1] || '?'}' resolved without a node id; refusing to report a blast radius`);
+        }
         // #1858 — kick off the epistemic boundary probe concurrently with the BFS.
         // It depends only on symId/symType/symName (all known now) and touches no
         // shared state, so its extra round-trip overlaps the traversal instead of

package/dist/storage/parse-cache.js

@@ -773,7 +773,14 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // v104 (#3339 review): TS/JS pair-HOC queries now name object-pair
 // `mutation(withAuth(arrow))` handlers. Warm caches replay the pre-fix
 // capture set (anonymous arrows, no Function name), so both stores re-extract.
-const SCHEMA_BUMP = 104;
+// v112 (#3354): callable-value flow now follows each branch of `a ?? f`,
+// `a || f`, and `c ? f : g`. Warm caches replay the pre-fix flow facts, which
+// have no flow for those assignments, so both stores re-extract. 105-111 are
+// claimed by open PR #3326 (Elixir).
+// Same v112: the `valueAlternatives` provider hook extends it to Kotlin
+// `?:`/`if`, Swift/Dart `??`/`?:`, and Python `x if c else y`, and keeps a
+// Ruby multi-statement `if` one opaque source.
+const SCHEMA_BUMP = 112;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.37",
+  "version": "1.6.13-rc.38",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",