rea-agents 3.2.1 → 4.0.0

package/dist/domain/javascriptSemanticAsyncEffects.js

@@ -3,6 +3,7 @@ import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javasc
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { dataEffectLiteralString, dataEffectMemberCallee, assignedSemanticResultBindings, scalarAssignedResultBinding, semanticProjectedBindingFacts, } from "./javascriptSemanticDataEffectHelpers.js";
 const EVENT_REGISTER_METHODS = [
     "on",
     "once",
@@ -36,19 +37,28 @@ export const collectJavaScriptSemanticAsyncEffects = (program, state, callables)
     const timers = [];
     const callableIds = new Set(callables.map(({ callableId }) => callableId));
     const callableStack = [];
+    const ancestors = [];
     traverseJavaScriptAst(program, {
-        enter: (node, parent) => {
+        enter: (node) => {
             const callableId = semanticCallableIdForNode(node);
             if (callableId !== null && callableIds.has(callableId))
                 callableStack.push(callableId);
-            if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
-                return;
-            const ownerCallableId = callableStack.at(-1) ?? null;
-            collectEvent(node, ownerCallableId, state, events);
-            collectTimer({ node, parent, ownerCallableId, state, output: timers });
+            if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+                const ownerCallableId = callableStack.at(-1) ?? null;
+                collectEvent(node, ownerCallableId, state, events);
+                collectTimer({
+                    node,
+                    ownerCallableId,
+                    state,
+                    output: timers,
+                    ancestors,
+                });
+            }
+            ancestors.push(node);
         },
         exit: (node) => {
             const callableId = semanticCallableIdForNode(node);
+            ancestors.pop();
             if (callableId !== null && callableStack.at(-1) === callableId)
                 callableStack.pop();
         },
@@ -59,7 +69,7 @@ export const collectJavaScriptSemanticAsyncEffects = (program, state, callables)
     };
 };
 const collectEvent = (node, ownerCallableId, state, output) => {
-    const member = memberCallee(node);
+    const member = dataEffectMemberCallee(node);
     if (member === null)
         return;
     const method = EVENT_METHODS.find((candidate) => candidate ===
@@ -70,7 +80,7 @@ const collectEvent = (node, ownerCallableId, state, output) => {
     const eventArgument = node.arguments[0];
     const listenerArgument = node.arguments[1];
     const emitter = emitterIdentity(member.object, state);
-    const eventName = literalString(eventArgument);
+    const eventName = dataEffectLiteralString(eventArgument);
     output.push({
         eventId: `event:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
         kind,
@@ -122,31 +132,43 @@ const emitterIdentity = (node, state) => {
     };
 };
 const collectTimer = (input) => {
-    const { node, parent, ownerCallableId, state, output } = input;
+    const { node, ownerCallableId, state, output, ancestors } = input;
     const method = timerMethod(node.callee, state);
     if (method === null)
         return;
     const kind = TIMER_SCHEDULE_METHODS.some((candidate) => candidate === method)
         ? "schedule"
         : "cancel";
+    const projectedResultBindings = assignedSemanticResultBindings(node, ancestors, state);
     output.push({
         node,
         method,
         kind,
         ownerCallableId,
         handleBindingId: kind === "schedule"
-            ? assignedBindingId(parent, node, state)
+            ? scalarAssignedResultBinding(projectedResultBindings)
             : bindingId(node.arguments[0], state),
+        projectedResultBindings: kind === "schedule"
+            ? semanticProjectedBindingFacts(projectedResultBindings.filter(({ projectionPath }) => projectionPath.length > 0))
+            : [],
     });
 };
 const resolveTimers = (candidates) => {
     const schedulesByBinding = new Map();
     for (const candidate of candidates) {
-        if (candidate.kind !== "schedule" || candidate.handleBindingId === null)
+        if (candidate.kind !== "schedule")
             continue;
-        const existing = schedulesByBinding.get(candidate.handleBindingId) ?? [];
-        existing.push(candidate);
-        schedulesByBinding.set(candidate.handleBindingId, existing);
+        const ids = [
+            ...(candidate.handleBindingId === null
+                ? []
+                : [candidate.handleBindingId]),
+            ...candidate.projectedResultBindings.map(({ bindingId }) => bindingId),
+        ];
+        for (const id of ids) {
+            const existing = schedulesByBinding.get(id) ?? [];
+            existing.push(candidate);
+            schedulesByBinding.set(id, existing);
+        }
     }
     return candidates.map((candidate) => {
         const linked = candidate.kind === "cancel" && candidate.handleBindingId !== null
@@ -159,13 +181,15 @@ const resolveTimers = (candidates) => {
             location: range(candidate.node),
             ownerCallableId: candidate.ownerCallableId,
             handleBindingId: candidate.handleBindingId,
+            projectedResultBindings: candidate.projectedResultBindings,
             linkedTimerId: linked.length === 1 && linked[0] !== undefined
                 ? timerId(linked[0])
                 : null,
             delayMilliseconds: timerDelay(candidate),
             resolution: candidate.kind === "schedule"
                 ? "complete"
-                : linked.length === 1
+                : linked.length === 1 &&
+                    !linked[0]?.projectedResultBindings.some(({ bindingId }) => bindingId === candidate.handleBindingId)
                     ? "complete"
                     : linked.length > 1
                         ? "partial"
@@ -208,31 +232,9 @@ const timerMethodFromBinding = (binding) => {
 };
 const timerNamespaceBinding = (binding) => binding?.directOrigins.some(({ specifier, importedPath }) => timerModule(specifier) && importedPath.length === 0) ?? false;
 const timerModule = (specifier) => specifier === "timers" || specifier === "node:timers";
-const assignedBindingId = (parent, node, state) => {
-    const identifier = t.isVariableDeclarator(parent) &&
-        parent.init === node &&
-        t.isIdentifier(parent.id)
-        ? parent.id
-        : t.isAssignmentExpression(parent) &&
-            parent.right === node &&
-            t.isIdentifier(parent.left)
-            ? parent.left
-            : null;
-    return identifier === null
-        ? null
-        : (resolveSemanticBindingState(state, identifier, identifier.name)
-            ?.bindingId ?? null);
-};
 const bindingId = (node, state) => t.isIdentifier(node)
     ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
     : null;
-const literalString = (node) => {
-    if (t.isStringLiteral(node))
-        return node.value;
-    if (t.isTemplateLiteral(node) && node.expressions.length === 0)
-        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
-    return null;
-};
 const timerDelay = (candidate) => {
     if (candidate.kind !== "schedule" || candidate.method === "setImmediate")
         return null;
@@ -240,6 +242,3 @@ const timerDelay = (candidate) => {
     return t.isNumericLiteral(delay) ? delay.value : null;
 };
 const timerId = (candidate) => `timer:${candidate.kind}:${String(candidate.node.start ?? -1)}:${String(candidate.node.end ?? -1)}`;
-const memberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
-    ? node.callee
-    : null;

package/dist/domain/javascriptSemanticCalls.js

@@ -1,9 +1,10 @@
 import * as t from "@babel/types";
 import { semanticCallableIdForNode, semanticReferenceRole, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
-import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { resolveSemanticBindingState, isUnshadowedGlobal, } from "./javascriptSemanticState.js";
 import { parameterBindings, resolveLocalCallables, } from "./javascriptSemanticCallResolution.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { assignedSemanticResultBindings } from "./javascriptSemanticDataEffectHelpers.js";
 /** Recover direct-call and lexical-capture candidates from inert syntax. */
 export const collectJavaScriptSemanticCalls = (program, state, callables) => {
     const output = {
@@ -21,6 +22,7 @@ export const collectJavaScriptSemanticCalls = (program, state, callables) => {
         output,
         bindingResolutionCache: new Map(),
         parameterBindingCache: new Map(),
+        ancestors: [],
     };
     const callableStack = [];
     traverseJavaScriptAst(program, {
@@ -32,12 +34,15 @@ export const collectJavaScriptSemanticCalls = (program, state, callables) => {
             const owner = enclosingFunction(callableStack);
             collectCapture(node, parent, owner, context);
             collectDynamicProperty(node, owner, state, output);
+            collectDynamicScope(node, owner, state, output);
             if (t.isCallExpression(node) ||
                 t.isOptionalCallExpression(node) ||
                 t.isNewExpression(node))
                 collectCallSite(node, parent, owner, context);
+            context.ancestors.push(node);
         },
         exit: (node) => {
+            context.ancestors.pop();
             const callableId = semanticCallableIdForNode(node);
             if (callableId !== null &&
                 callableStack.at(-1)?.callableId === callableId)
@@ -79,7 +84,7 @@ const collectCallSite = (node, parent, owner, context) => {
         arguments: argumentsValue,
     };
     output.callSites.push(site);
-    collectCallResultFlow(site, node, parent, context);
+    collectCallResultFlow(site, node, context);
     if (site.resolution !== "exact")
         addFrontier({
             kind: "dynamic-call",
@@ -91,31 +96,24 @@ const collectCallSite = (node, parent, owner, context) => {
     if (site.kind === "call")
         collectReturnFlows(site, callableById, state, output);
 };
-const collectCallResultFlow = (site, node, parent, context) => {
-    const identifier = t.isVariableDeclarator(parent) &&
-        parent.init === node &&
-        t.isIdentifier(parent.id)
-        ? parent.id
-        : t.isAssignmentExpression(parent) &&
-            parent.right === node &&
-            t.isIdentifier(parent.left)
-            ? parent.left
-            : null;
-    if (identifier === null)
-        return;
-    const binding = resolveSemanticBindingState(context.state, identifier, identifier.name);
-    const identifierRange = range(identifier);
-    const definition = binding?.definitions.find(({ location }) => location.start.line === identifierRange.start.line &&
-        location.start.column === identifierRange.start.column &&
-        location.end.line === identifierRange.end.line &&
-        location.end.column === identifierRange.end.column);
-    if (binding === undefined || definition === undefined)
-        return;
-    context.output.callResultFlows.push({
-        callSiteId: site.callSiteId,
-        bindingId: binding.bindingId,
-        definitionLocation: definition.location,
-    });
+const collectCallResultFlow = (site, node, context) => {
+    for (const assigned of assignedSemanticResultBindings(node, context.ancestors, context.state).filter(({ projectionPath }) => projectionPath.length === 0)) {
+        const binding = [...context.state.bindingsById.values()].find(({ bindingId }) => bindingId === assigned.bindingId);
+        if (binding === undefined)
+            continue;
+        const identifierRange = range(assigned.identifier);
+        const definition = binding.definitions.find(({ location }) => location.start.line === identifierRange.start.line &&
+            location.start.column === identifierRange.start.column &&
+            location.end.line === identifierRange.end.line &&
+            location.end.column === identifierRange.end.column);
+        if (definition === undefined)
+            continue;
+        context.output.callResultFlows.push({
+            callSiteId: site.callSiteId,
+            bindingId: binding.bindingId,
+            definitionLocation: definition.location,
+        });
+    }
 };
 const retainedArguments = (nodes) => {
     const retained = [];
@@ -223,6 +221,27 @@ const collectDynamicProperty = (node, owner, state, output) => {
             reason: "Computed object property is not a static string or number.",
         }, state, output);
 };
+/**
+ * `with (o) { … }` and `eval("…")` decide at runtime which bindings exist, so
+ * every name inside them is unresolvable statically. Recording the frontier
+ * is what keeps the analyzer from presenting an empty or partial resolution as
+ * an observed fact — silence here would read as "nothing to resolve".
+ */
+const collectDynamicScope = (node, owner, state, output) => {
+    const reason = t.isWithStatement(node)
+        ? "`with` introduces a runtime binding environment; names inside are not statically resolvable."
+        : t.isCallExpression(node) && isUnshadowedGlobal(node.callee, state, "eval")
+            ? "`eval` can declare bindings at runtime; names inside the evaluated source are not statically resolvable."
+            : null;
+    if (reason === null)
+        return;
+    addFrontier({
+        kind: "dynamic-scope",
+        callableId: owner?.callableId ?? null,
+        location: range(node),
+        reason,
+    }, state, output);
+};
 const addFrontier = (frontier, state, output) => {
     output.frontiers.push(frontier);
 };

package/dist/domain/javascriptSemanticChildProcesses.js

@@ -2,7 +2,8 @@ import * as t from "@babel/types";
 import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+import { compareCodePoints, range } from "./javascriptStaticAnalysisHelpers.js";
+import { dataEffectLiteralString, dataEffectMemberCallee, assignedSemanticResultBindings, scalarAssignedResultBinding, semanticProjectedBindingFacts, } from "./javascriptSemanticDataEffectHelpers.js";
 const CHILD_PROCESS_METHODS = ["spawn", "exec", "execFile", "fork"];
 const CHILD_LISTENER_METHODS = ["on", "once", "addListener"];
 /** Recover explicit asynchronous node:child_process ownership candidates. */
@@ -18,36 +19,44 @@ const collectSpawns = (program, state, callables) => {
     const output = [];
     const admittedCallables = new Set(callables.map(({ callableId }) => callableId));
     const callableStack = [];
+    const ancestors = [];
     traverseJavaScriptAst(program, {
-        enter: (node, parent) => {
+        enter: (node) => {
             const callableId = semanticCallableIdForNode(node);
             if (callableId !== null && admittedCallables.has(callableId))
                 callableStack.push(callableId);
-            if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
-                return;
-            const method = childProcessMethod(node.callee, state);
-            if (method === null)
-                return;
-            output.push({
-                node,
-                method,
-                ownerCallableId: callableStack.at(-1) ?? null,
-                resultBindingId: assignedBindingId(parent, node, state),
-            });
+            if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+                const method = childProcessMethod(node.callee, state);
+                if (method !== null) {
+                    const projectedResultBindings = assignedSemanticResultBindings(node, ancestors, state);
+                    output.push({
+                        node,
+                        method,
+                        ownerCallableId: callableStack.at(-1) ?? null,
+                        resultBindingId: scalarAssignedResultBinding(projectedResultBindings),
+                        projectedResultBindings: semanticProjectedBindingFacts(projectedResultBindings.filter(({ projectionPath }) => projectionPath.length > 0)),
+                    });
+                }
+            }
+            ancestors.push(node);
+        },
+        exit: (node) => {
+            ancestors.pop();
+            popCallable(node, callableStack);
         },
-        exit: (node) => popCallable(node, callableStack),
     });
     return output;
 };
 const immutableSpawn = (candidate) => {
     const options = spawnOptions(candidate);
-    const command = literalString(candidate.node.arguments[0]);
+    const command = dataEffectLiteralString(candidate.node.arguments[0]);
     return {
         processId: spawnId(candidate),
         method: candidate.method,
         location: range(candidate.node),
         ownerCallableId: candidate.ownerCallableId,
         resultBindingId: candidate.resultBindingId,
+        projectedResultBindings: candidate.projectedResultBindings,
         command,
         argvCount: spawnArgvCount(candidate),
         environmentSupplied: objectHasProperty(options, "env"),
@@ -63,11 +72,15 @@ const collectInteractions = (program, state, callables, spawns) => {
     const spawnsByBinding = new Map();
     for (const spawn of spawns) {
         spawnByNode.set(spawn.node, spawn);
-        if (spawn.resultBindingId === null)
-            continue;
-        const existing = spawnsByBinding.get(spawn.resultBindingId) ?? [];
-        existing.push(spawn);
-        spawnsByBinding.set(spawn.resultBindingId, existing);
+        const ids = [
+            ...(spawn.resultBindingId === null ? [] : [spawn.resultBindingId]),
+            ...spawn.projectedResultBindings.map(({ bindingId }) => bindingId),
+        ];
+        for (const id of ids) {
+            const existing = spawnsByBinding.get(id) ?? [];
+            existing.push(spawn);
+            spawnsByBinding.set(id, existing);
+        }
     }
     const context = {
         state,
@@ -92,7 +105,7 @@ const collectInteractions = (program, state, callables, spawns) => {
 };
 const childInteraction = (node, ownerCallableId, context) => {
     const { state, spawnByNode, spawnsByBinding } = context;
-    const member = memberCallee(node);
+    const member = dataEffectMemberCallee(node);
     if (member === null)
         return null;
     const method = semanticStaticPropertyName(member.property, member.computed);
@@ -117,17 +130,20 @@ const childInteraction = (node, ownerCallableId, context) => {
             .sort(compareCodePoints),
         eventName: kind === "listener" ? eventName : null,
         signalName: kind === "signal"
-            ? (literalString(node.arguments[0]) ?? "SIGTERM")
+            ? (dataEffectLiteralString(node.arguments[0]) ?? "SIGTERM")
             : null,
         listenerLocation: kind === "listener" && t.isNode(listener) ? range(listener) : null,
-        resolution: linked.length === 1 ? "complete" : "partial",
+        resolution: linked.length === 1 &&
+            !linked[0]?.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
+            ? "complete"
+            : "partial",
     };
 };
 const classifyInteraction = (method, argument) => {
     if (method === "kill")
         return { kind: "signal", interactionMethod: "kill", eventName: null };
     const listenerMethod = CHILD_LISTENER_METHODS.find((candidate) => candidate === method);
-    const eventName = literalString(argument);
+    const eventName = dataEffectLiteralString(argument);
     return listenerMethod !== undefined &&
         (eventName === "exit" || eventName === "error")
         ? { kind: "listener", interactionMethod: listenerMethod, eventName }
@@ -190,38 +206,15 @@ const stdioMode = (options) => {
     return "dynamic";
 };
 const objectProperty = (object, name) => object?.properties.find((property) => (t.isObjectMethod(property) || t.isObjectProperty(property)) &&
-    propertyName(property.key) === name) ?? null;
+    // `{[env]: vars}` has a dynamic key; treating it as `env` would claim
+    // the caller supplied an environment when the real key is unknown.
+    semanticStaticPropertyName(property.key, property.computed) === name) ?? null;
 const objectBinding = (node, state) => t.isIdentifier(node)
     ? resolveSemanticBindingState(state, node, node.name)
     : undefined;
-const assignedBindingId = (parent, node, state) => {
-    const identifier = t.isVariableDeclarator(parent) &&
-        parent.init === node &&
-        t.isIdentifier(parent.id)
-        ? parent.id
-        : t.isAssignmentExpression(parent) &&
-            parent.right === node &&
-            t.isIdentifier(parent.left)
-            ? parent.left
-            : null;
-    return identifier === null
-        ? null
-        : (resolveSemanticBindingState(state, identifier, identifier.name)
-            ?.bindingId ?? null);
-};
-const literalString = (node) => {
-    if (t.isStringLiteral(node))
-        return node.value;
-    if (t.isTemplateLiteral(node) && node.expressions.length === 0)
-        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
-    return null;
-};
 const popCallable = (node, stack) => {
     const callableId = semanticCallableIdForNode(node);
     if (callableId !== null && stack.at(-1) === callableId)
         stack.pop();
 };
 const spawnId = (candidate) => `child:spawn:${String(candidate.node.start ?? -1)}:${String(candidate.node.end ?? -1)}`;
-const memberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
-    ? node.callee
-    : null;

package/dist/domain/javascriptSemanticDataEffectHelpers.js

@@ -1,7 +1,96 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
+/** Resolve bindings written by the nearest variable or assignment owner. */
+export const assignedSemanticResultBindings = (node, ancestors, state) => {
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+        const owner = ancestors[index];
+        if (owner === undefined)
+            continue;
+        let pattern;
+        let source = null;
+        if (t.isVariableDeclarator(owner)) {
+            pattern = owner.id;
+            source = owner.init ?? null;
+        }
+        else if (t.isAssignmentExpression(owner)) {
+            pattern = owner.left;
+            source = owner.right;
+        }
+        if (pattern !== undefined &&
+            source !== null &&
+            assignedSourceIs(node, source))
+            return projectedPatternBindings(pattern, state);
+        if (semanticCallableIdForNode(owner) !== null)
+            return [];
+    }
+    return [];
+};
+const assignedSourceIs = (node, source) => {
+    let value = source;
+    while (true) {
+        if (t.isAwaitExpression(value))
+            value = value.argument;
+        else if (t.isParenthesizedExpression(value) ||
+            t.isTSAsExpression(value) ||
+            t.isTSTypeAssertion(value) ||
+            t.isTypeCastExpression(value) ||
+            t.isTSSatisfiesExpression(value))
+            value = value.expression;
+        else
+            break;
+    }
+    return value === node;
+};
+const projectedPatternBindings = (pattern, state) => {
+    const output = [];
+    const visit = (current, path, partial) => {
+        if (t.isIdentifier(current)) {
+            const binding = resolveSemanticBindingState(state, current, current.name);
+            if (binding !== undefined)
+                output.push({
+                    bindingId: binding.bindingId,
+                    identifier: current,
+                    projectionPath: path,
+                    resolution: partial ? "partial" : "complete",
+                });
+            return;
+        }
+        if (t.isAssignmentPattern(current))
+            return visit(current.left, path, true);
+        if (t.isRestElement(current))
+            return visit(current.argument, [...path, null], true);
+        if (t.isObjectPattern(current)) {
+            for (const property of current.properties) {
+                if (t.isRestElement(property))
+                    visit(property.argument, [...path, null], true);
+                else
+                    visit(property.value, [
+                        ...path,
+                        semanticStaticPropertyName(property.key, property.computed) ||
+                            null,
+                    ], partial ||
+                        semanticStaticPropertyName(property.key, property.computed) ===
+                            "");
+            }
+        }
+        else if (t.isArrayPattern(current)) {
+            current.elements.forEach((element, index) => {
+                if (element !== null)
+                    visit(element, [...path, index], partial);
+            });
+        }
+    };
+    visit(pattern, [], false);
+    return output;
+};
+export const semanticProjectedBindingFacts = (bindings) => bindings.map(({ identifier: _identifier, ...fact }) => fact);
+/** Return a scalar owner only for an unprojected identifier result. */
+export const scalarAssignedResultBinding = (bindings) => bindings.length === 1 && bindings[0]?.projectionPath.length === 0
+    ? (bindings[0]?.bindingId ?? null)
+    : null;
 /** Resolve a direct or namespace-imported built-in method. */
 export const builtinDataEffectMethod = (callee, state, specifiers) => {
     if (t.isIdentifier(callee)) {
@@ -38,23 +127,7 @@ export const isSemanticProcessObject = (node, state) => {
 };
 /** Resolve the nearest direct variable/assignment owner before a callable. */
 export const outerDataEffectBinding = (node, context) => {
-    for (let index = context.ancestors.length - 1; index >= 0; index -= 1) {
-        const ancestor = context.ancestors[index];
-        if (ancestor === undefined)
-            continue;
-        if (t.isVariableDeclarator(ancestor) &&
-            t.isNode(ancestor.init) &&
-            containsSemanticNode(ancestor.init, node) &&
-            t.isIdentifier(ancestor.id))
-            return (resolveSemanticBindingState(context.state, ancestor.id, ancestor.id.name)?.bindingId ?? null);
-        if (t.isAssignmentExpression(ancestor) &&
-            containsSemanticNode(ancestor.right, node) &&
-            t.isIdentifier(ancestor.left))
-            return (resolveSemanticBindingState(context.state, ancestor.left, ancestor.left.name)?.bindingId ?? null);
-        if (semanticCallableIdForNode(ancestor) !== null)
-            return null;
-    }
-    return null;
+    return scalarAssignedResultBinding(assignedSemanticResultBindings(node, context.ancestors, context.state));
 };
 /** Traverse with exact callable and ancestor stacks. */
 export const traverseDataEffects = (program, context, visit) => {

package/dist/domain/javascriptSemanticDataEffects.js

@@ -1,8 +1,8 @@
 import * as t from "@babel/types";
 import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
-import { compareCodePoints, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { compareCodePoints, range } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover configuration, request, and boundary candidates from inert syntax. */
 export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
     const context = {
@@ -126,6 +126,7 @@ const collectRequests = (program, context) => {
                 location: range(node),
                 ownerCallableId: context.callableStack.at(-1) ?? null,
                 resultBindingId: outerAssignedBinding(node, context),
+                projectedResultBindings: semanticProjectedBindingFacts(assignedSemanticResultBindings(node, context.ancestors, context.state).filter(({ projectionPath }) => projectionPath.length > 0)),
                 linkedRequestIds: [],
                 endpoint,
                 fields: requestFields(node, method, context.state),
@@ -138,12 +139,17 @@ const collectRequests = (program, context) => {
 const collectResponseConsumers = (program, context, requests) => {
     const requestsByBinding = new Map();
     for (const request of requests) {
-        const bindingId = request.operation.resultBindingId;
-        if (bindingId === null)
-            continue;
-        const existing = requestsByBinding.get(bindingId) ?? [];
-        existing.push(request);
-        requestsByBinding.set(bindingId, existing);
+        const bindingIds = [
+            ...(request.operation.resultBindingId === null
+                ? []
+                : [request.operation.resultBindingId]),
+            ...request.operation.projectedResultBindings.map(({ bindingId }) => bindingId),
+        ];
+        for (const bindingId of bindingIds) {
+            const existing = requestsByBinding.get(bindingId) ?? [];
+            existing.push(request);
+            requestsByBinding.set(bindingId, existing);
+        }
     }
     const output = [];
     traverseWithContext(program, context, (node) => {
@@ -168,12 +174,16 @@ const collectResponseConsumers = (program, context, requests) => {
             location: range(node),
             ownerCallableId: context.callableStack.at(-1) ?? null,
             resultBindingId: outerAssignedBinding(node, context),
+            projectedResultBindings: semanticProjectedBindingFacts(assignedSemanticResultBindings(node, context.ancestors, context.state).filter(({ projectionPath }) => projectionPath.length > 0)),
             linkedRequestIds: linked
                 .map(({ operation }) => operation.requestId)
                 .sort(compareCodePoints),
             endpoint: null,
             fields: [],
-            resolution: linked.length === 1 ? "complete" : "partial",
+            resolution: linked.length === 1 &&
+                !linked[0]?.operation.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
+                ? "complete"
+                : "partial",
         });
     });
     return output;
@@ -256,7 +266,9 @@ const requestFields = (node, method, state) => {
     return candidate.properties.flatMap((property) => {
         if (!t.isObjectProperty(property))
             return [];
-        const name = propertyName(property.key);
+        // `{[key]: 1}` sends no knowable field name; reporting `key` would invent
+        // a request field that may not exist.
+        const name = semanticStaticPropertyName(property.key, property.computed);
         if (name.length === 0)
             return [];
         return [