rea-agents 6.5.0 → 6.7.0

package/dist/domain/javascript/javascriptSemanticAsyncEffects.js

@@ -2,6 +2,7 @@ import * as t from "@babel/types";
 import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";
 import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
+import { semanticBindingAtRead } from "./javascriptSemanticMutationInitializers.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { builtinDataEffectMethod, dataEffectLiteralString, dataEffectMemberCallee, assignedSemanticResultBindings, scalarAssignedResultBinding, semanticProjectedBindingFacts, } from "./javascriptSemanticDataEffectHelpers.js";
@@ -145,6 +146,27 @@ const collectTimer = (input) => {
         ? "schedule"
         : "cancel";
     const projectedResultBindings = assignedSemanticResultBindings(node, ancestors, state);
+    const handle = kind === "cancel" && t.isIdentifier(node.arguments[0])
+        ? resolveSemanticBindingState(state, node.arguments[0], node.arguments[0].name)
+        : undefined;
+    const handleRead = handle === undefined || !t.isIdentifier(node.arguments[0])
+        ? null
+        : (() => {
+            const snapshot = semanticBindingAtRead(handle, node.arguments[0], state.parentsByNode);
+            // A const handle has the same value inside a later closure even
+            // when the source positions belong to different function bodies.
+            const stableClosureCapture = !handle.mutable &&
+                handle.initializers.length === 1 &&
+                handle.referenceInitializers.length === 0;
+            const origins = [
+                ...snapshot.binding.initializers,
+                ...snapshot.binding.referenceInitializers,
+            ];
+            return {
+                origins: origins.map(({ node: origin }) => origin),
+                complete: snapshot.status === "ordered" || stableClosureCapture,
+            };
+        })();
     output.push({
         node,
         method,
@@ -156,29 +178,22 @@ const collectTimer = (input) => {
         projectedResultBindings: kind === "schedule"
             ? semanticProjectedBindingFacts(projectedResultBindings.filter(({ projectionPath }) => projectionPath.length > 0))
             : [],
+        handleRead,
     });
 };
 const resolveTimers = (candidates) => {
-    const schedulesByBinding = new Map();
-    for (const candidate of candidates) {
-        if (candidate.kind !== "schedule")
-            continue;
-        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);
-        }
-    }
+    const schedules = new Map(candidates
+        .filter(({ kind }) => kind === "schedule")
+        .map((candidate) => [candidate.node, candidate]));
     return candidates.map((candidate) => {
-        const linked = candidate.kind === "cancel" && candidate.handleBindingId !== null
-            ? (schedulesByBinding.get(candidate.handleBindingId) ?? [])
-            : [];
+        // Unordered reads retain possible initializers as candidate edges. Only an
+        // ordered or immutable read can establish one complete cancellation link.
+        const linked = candidate.handleRead?.origins.flatMap((origin) => {
+            const schedule = schedules.get(origin);
+            return schedule === undefined ? [] : [schedule];
+        }) ?? [];
+        const incompleteOrigins = candidate.handleRead !== null &&
+            candidate.handleRead.origins.length !== linked.length;
         return {
             timerId: timerId(candidate),
             kind: candidate.kind,
@@ -194,9 +209,11 @@ const resolveTimers = (candidates) => {
             resolution: candidate.kind === "schedule"
                 ? "complete"
                 : linked.length === 1 &&
+                    candidate.handleRead?.complete &&
+                    !incompleteOrigins &&
                     !linked[0]?.projectedResultBindings.some(({ bindingId }) => bindingId === candidate.handleBindingId)
                     ? "complete"
-                    : linked.length > 1
+                    : linked.length > 0
                         ? "partial"
                         : "unresolved",
         };

package/dist/domain/javascript/javascriptSemanticCallResolution.js

@@ -1,14 +1,15 @@
 import * as t from "@babel/types";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { semanticBindingAtRead } from "./javascriptSemanticMutationInitializers.js";
 import { unwrapJavaScriptExpression, runtimeFunctionParameters, } from "./javascriptAstValues.js";
-import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { resolveSemanticBindingState, semanticStableInitializer, } from "./javascriptSemanticState.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 /** Resolve local callable candidates without following dynamic properties. */
 export const resolveLocalCallables = (input) => resolveCallables(input.node, {
     state: input.state,
     callableById: input.callableById,
-    seenBindings: input.seenBindings,
+    seenInitializers: input.seenInitializers,
     bindingCache: input.bindingCache,
 });
 const resolveCallables = (node, context) => {
@@ -35,14 +36,35 @@ const resolveCallables = (node, context) => {
     };
 };
 const resolveIdentifier = (node, context) => {
+    const cached = context.bindingCache.get(node);
+    if (cached !== undefined)
+        return cached;
     const binding = resolveSemanticBindingState(context.state, node, node.name);
-    return binding === undefined
-        ? {
+    if (binding === undefined)
+        return {
             callableIds: [],
             complete: false,
             reason: `Unresolved call target ${node.name}.`,
+        };
+    const read = semanticBindingAtRead(binding, node, context.state.parentsByNode);
+    const candidates = resolveBindingCallables(read.binding, context);
+    // Knowing every local candidate does not prove that any write replaced the
+    // incoming value, or that a write in another activation precedes this read.
+    const covered = read.hasDefiniteInitializer ||
+        semanticStableInitializer(binding, context.state) !== undefined;
+    const resolution = candidates.complete && !covered
+        ? {
+            ...candidates,
+            complete: false,
+            reason: `Call target ${binding.name} may retain an incoming value or an unordered assignment.`,
         }
-        : resolveBindingCallables(binding, context);
+        : candidates;
+    // Key by the immutable read, not binding identity: before/after snapshots
+    // differ. Cache cycle-independent partial results too, keeping alias
+    // diamonds linear even when their shared leaf has an unknown incoming value.
+    if (!resolution.cycleDependent)
+        context.bindingCache.set(node, resolution);
+    return resolution;
 };
 const resolveAlternatives = (left, right, context) => {
     const candidates = [left, right].map((candidate) => resolveCallables(candidate, context));
@@ -50,31 +72,36 @@ const resolveAlternatives = (left, right, context) => {
         callableIds: uniqueCallableIds(candidates.flatMap(({ callableIds }) => callableIds)),
         complete: candidates.every(({ complete }) => complete),
         reason: "Conditional or logical call target has multiple candidates.",
+        ...(candidates.some((candidate) => candidate.cycleDependent)
+            ? { cycleDependent: true }
+            : {}),
     };
 };
 const resolveBindingCallables = (binding, context) => {
-    const cached = context.bindingCache.get(binding.bindingId);
-    if (cached !== undefined)
-        return cached;
-    if (context.seenBindings.has(binding.bindingId))
-        return {
-            callableIds: [],
-            complete: false,
-            reason: `Call target alias cycle at ${binding.name}.`,
-        };
     if (binding.initializers.length === 0)
         return missingBindingInitializer(binding);
-    const candidateContext = {
-        ...context,
-        seenBindings: new Set([...context.seenBindings, binding.bindingId]),
-    };
-    const candidates = binding.initializers.map(({ node, projection }) => projection.length === 0
-        ? resolveCallables(node, candidateContext)
-        : {
-            callableIds: [],
-            complete: false,
-            reason: `Projected call target ${binding.name} is unresolved.`,
-        });
+    const candidates = binding.initializers.map((initializer) => {
+        if (context.seenInitializers.has(initializer))
+            return {
+                callableIds: [],
+                complete: false,
+                cycleDependent: true,
+                reason: `Call target initializer cycle at ${binding.name}.`,
+            };
+        return initializer.projection.length === 0
+            ? resolveCallables(initializer.node, {
+                ...context,
+                seenInitializers: new Set([
+                    ...context.seenInitializers,
+                    initializer,
+                ]),
+            })
+            : {
+                callableIds: [],
+                complete: false,
+                reason: `Projected call target ${binding.name} is unresolved.`,
+            };
+    });
     const callableIds = uniqueCallableIds(candidates.flatMap((candidate) => candidate.callableIds));
     const resolution = {
         callableIds,
@@ -82,9 +109,10 @@ const resolveBindingCallables = (binding, context) => {
         reason: callableIds.length === 1 && candidates.every(({ complete }) => complete)
             ? "Unique local callable target."
             : `Call target ${binding.name} has ambiguous or unsupported assignments.`,
+        ...(candidates.some((candidate) => candidate.cycleDependent)
+            ? { cycleDependent: true }
+            : {}),
     };
-    if (resolution.complete)
-        context.bindingCache.set(binding.bindingId, resolution);
     return resolution;
 };
 const missingBindingInitializer = (binding) => ({

package/dist/domain/javascript/javascriptSemanticCalls.js

@@ -22,7 +22,7 @@ export const collectJavaScriptSemanticCalls = (program, state, callables) => {
         state,
         callableById,
         output,
-        bindingResolutionCache: new Map(),
+        bindingResolutionCache: new WeakMap(),
         parameterBindingCache: new Map(),
         ancestors: [],
     };
@@ -60,7 +60,7 @@ const collectCallSite = (node, parent, owner, context) => {
         node: node.callee,
         state,
         callableById,
-        seenBindings: new Set(),
+        seenInitializers: new Set(),
         bindingCache: context.bindingResolutionCache,
     });
     const callSiteId = semanticCallSiteId(node);
@@ -229,8 +229,8 @@ const collectDynamicProperty = (node, owner, state, output) => {
 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."
+        : state.opaqueEffects.sites.has(node)
+            ? "`eval` can change bindings and reachable objects at runtime; its effects are not statically resolvable."
             : null;
     if (reason === null)
         return;

package/dist/domain/javascript/javascriptSemanticChildProcesses.js

@@ -1,17 +1,20 @@
 import * as t from "@babel/types";
 import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";
-import { semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
-import { isUnshadowedGlobal, resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { createSemanticExpressionShapeResolver } from "./javascriptSemanticExpressionShapes.js";
+import { semanticStaticPropertyName, staticObjectProperty, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { isUnshadowedGlobal, resolveSemanticBindingState, semanticStableInitializer, } from "./javascriptSemanticState.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticBindingAtRead } from "./javascriptSemanticMutationInitializers.js";
 import { builtinDataEffectMethod, 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. */
 export const collectJavaScriptSemanticChildProcesses = (program, state, callables) => {
     const candidates = collectSpawns(program, state, callables);
-    const childProcessSpawns = candidates.map((candidate) => immutableSpawn(candidate));
+    const context = createSemanticExpressionShapeResolver(state);
+    const childProcessSpawns = candidates.map((candidate) => immutableSpawn(candidate, context));
     return {
         childProcessSpawns,
         childProcessInteractions: collectInteractions(program, state, callables, candidates),
@@ -47,8 +50,8 @@ const collectSpawns = (program, state, callables) => {
     });
     return output;
 };
-const immutableSpawn = (candidate) => {
-    const options = spawnOptions(candidate);
+const immutableSpawn = (candidate, context) => {
+    const { options, argvCount } = spawnArguments(candidate, context);
     const command = dataEffectLiteralString(candidate.node.arguments[0]);
     return {
         processId: spawnId(candidate),
@@ -58,9 +61,9 @@ const immutableSpawn = (candidate) => {
         resultBindingId: candidate.resultBindingId,
         projectedResultBindings: candidate.projectedResultBindings,
         command,
-        argvCount: spawnArgvCount(candidate),
+        argvCount,
         environmentSupplied: objectHasProperty(options, "env"),
-        stdioMode: stdioMode(options),
+        stdioMode: stdioMode(options, candidate.method, context),
         resolution: command === null ? "partial" : "complete",
     };
 };
@@ -102,18 +105,18 @@ const collectInteractions = (program, state, callables, spawns) => {
     return output;
 };
 const childInteraction = (node, ownerCallableId, context) => {
-    const { state, spawnByNode, spawnsByBinding } = context;
+    const { state } = context;
     const member = dataEffectMemberCallee(node);
     if (member === null)
         return null;
     const method = semanticStaticPropertyName(member.property, member.computed);
-    const binding = objectBinding(member.object, state);
-    const linked = resolveChildCandidates(member.object, binding, spawnByNode, spawnsByBinding);
-    if (linked.length === 0)
-        return null;
     const classification = classifyInteraction(method, node.arguments[0]);
     if (classification === null)
         return null;
+    const binding = objectBinding(member.object, state);
+    const { candidates: linked, complete } = resolveChildCandidates(member.object, context);
+    if (linked.length === 0)
+        return null;
     const { kind, interactionMethod, eventName } = classification;
     const listener = node.arguments[1];
     return {
@@ -129,10 +132,7 @@ const childInteraction = (node, ownerCallableId, context) => {
         eventName: kind === "listener" ? eventName : null,
         signalName: kind === "signal" ? killSignalName(node.arguments, state) : null,
         listenerLocation: kind === "listener" && t.isNode(listener) ? range(listener) : null,
-        resolution: linked.length === 1 &&
-            !linked[0]?.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
-            ? "complete"
-            : "partial",
+        resolution: complete ? "complete" : "partial",
     };
 };
 // Only an omitted argument or the unshadowed global undefined selects the
@@ -164,47 +164,131 @@ const childProcessMethod = (callee, state) => {
     ]);
     return (CHILD_PROCESS_METHODS.find((candidate) => candidate === method) ?? null);
 };
-const resolveChildCandidates = (node, binding, spawnByNode, spawnsByBinding) => {
-    const direct = spawnByNode.get(node);
-    if (direct !== undefined)
-        return [direct];
-    return binding === undefined
-        ? []
-        : (spawnsByBinding.get(binding.bindingId) ?? []);
+const resolveChildCandidates = (node, context) => {
+    const { state, spawnByNode, spawnsByBinding } = context;
+    const candidates = new Set();
+    const fallback = new Set();
+    const pending = [node];
+    const visited = new Set();
+    let complete = true;
+    while (pending.length > 0) {
+        const current = unwrapJavaScriptExpression(pending.pop()).node;
+        if (visited.has(current)) {
+            complete = false;
+            continue;
+        }
+        visited.add(current);
+        // Spawn-result assignment already admits await as an identity wrapper.
+        if (t.isAwaitExpression(current)) {
+            pending.push(current.argument);
+            continue;
+        }
+        const direct = spawnByNode.get(current);
+        if (direct !== undefined) {
+            candidates.add(direct);
+            continue;
+        }
+        const binding = t.isIdentifier(current)
+            ? resolveSemanticBindingState(state, current, current.name)
+            : undefined;
+        if (binding === undefined) {
+            complete = false;
+            continue;
+        }
+        for (const candidate of spawnsByBinding.get(binding.bindingId) ?? [])
+            fallback.add(candidate);
+        // An alias captures its source at its initializer read, not at the later
+        // interaction. The shared selector retains all sources across uncertain
+        // control flow, loops and writes in other activations.
+        const snapshot = semanticBindingAtRead(binding, current, state.parentsByNode);
+        const selected = snapshot.binding;
+        const initializers = [
+            ...selected.initializers,
+            ...selected.referenceInitializers,
+        ];
+        // Defaults and other reference sources do not exclude a caller-supplied
+        // value, even when they are the binding's only retained source.
+        if (initializers.length !== 1 || selected.referenceInitializers.length > 0)
+            complete = false;
+        const stable = semanticStableInitializer(binding, state);
+        for (const initializer of initializers) {
+            if (state.conditionallySkippedExpressions.has(initializer.node))
+                complete = false;
+            if (initializer.projection.length > 0) {
+                complete = false;
+                continue;
+            }
+            // A lone assignment can still be later or belong to another activation.
+            // Only initialized lexical declarations exclude an earlier undefined value
+            // without a same-body ordering proof.
+            if (!(stable === initializer && !binding.declarationKinds.has("var")) &&
+                snapshot.status !== "ordered")
+                complete = false;
+            pending.push(initializer.node);
+        }
+    }
+    // Preserve historical candidates with explicit uncertainty when the selected
+    // value cannot be established; a binding inventory alone never proves identity.
+    if (!complete)
+        for (const candidate of fallback)
+            candidates.add(candidate);
+    return {
+        candidates: [...candidates],
+        complete: complete && candidates.size === 1,
+    };
 };
-const spawnOptions = (candidate) => {
+const spawnArguments = (candidate, context) => {
     const args = candidate.node.arguments;
-    const value = candidate.method === "exec"
-        ? args[1]
-        : t.isObjectExpression(args[1])
-            ? args[1]
-            : args[2];
-    return t.isObjectExpression(value) ? value : null;
-};
-const spawnArgvCount = (candidate) => {
-    if (candidate.method === "exec")
-        return null;
-    const args = candidate.node.arguments[1];
-    return t.isArrayExpression(args) &&
-        !args.elements.some((element) => t.isSpreadElement(element))
-        ? args.elements.length
-        : null;
+    if (t.isSpreadElement(args[0]))
+        return { options: args[0], argvCount: null };
+    const second = args[1] && unwrapJavaScriptExpression(args[1]).node;
+    const third = args[2] && unwrapJavaScriptExpression(args[2]).node;
+    const expressionShape = context;
+    const argv = candidate.method !== "exec" && t.isArrayExpression(second)
+        ? second
+        : undefined;
+    // Only a proven argv array or nullish placeholder admits third-slot options.
+    // Otherwise the second argument may itself be options, ignoring the third.
+    const options = candidate.method === "exec" || second === undefined
+        ? second
+        : argv !== undefined ||
+            expressionShape.isArray(second) ||
+            expressionShape.isNullish(second)
+            ? third
+            : second;
+    return {
+        options,
+        argvCount: argv !== undefined &&
+            !argv.elements.some((element) => t.isSpreadElement(element))
+            ? argv.elements.length
+            : null,
+    };
 };
-const objectHasProperty = (object, name) => objectProperty(object, name) !== null;
-const stdioMode = (options) => {
-    const property = objectProperty(options, "stdio");
-    if (property === null || !t.isObjectProperty(property))
+const objectHasProperty = (object, name) => t.isObjectExpression(object) &&
+    object.properties.some((property) => !t.isSpreadElement(property) &&
+        semanticStaticPropertyName(property.key, property.computed) === name);
+const stdioMode = (options, method, context) => {
+    if (options === undefined)
+        return "default";
+    const expression = unwrapJavaScriptExpression(options).node;
+    if (context.isNullish(expression) ||
+        ((method === "exec" || method === "execFile") &&
+            context.isCallback(expression)))
+        return "default";
+    const lookup = staticObjectProperty(expression, "stdio", context.isNullish);
+    if (lookup.status === "missing")
+        return "default";
+    if (lookup.status !== "explicit")
+        return "dynamic";
+    const value = unwrapJavaScriptExpression(lookup.property.value).node;
+    if (context.isNullish(value))
         return "default";
-    if (t.isStringLiteral(property.value))
-        return property.value.value;
-    if (t.isArrayExpression(property.value))
+    if (t.isStringLiteral(value))
+        return value.value;
+    if (t.isArrayExpression(value))
         return "array";
     return "dynamic";
 };
-const objectProperty = (object, name) => object?.properties.find((property) => (t.isObjectMethod(property) || t.isObjectProperty(property)) &&
-    // `{[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;

package/dist/domain/javascript/javascriptSemanticCoverage.js

@@ -1,4 +1,4 @@
-import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT, } from "./javascriptSemanticResourceLimits.js";
+import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_GETTER_EXPANSION_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT, } from "./javascriptSemanticResourceLimits.js";
 /** Classify whole-file semantic coverage from parsing and value bounds. */
 export const semanticCoverage = (parserPartial, resourceLimits = []) => resourceLimits.length > 0
     ? { status: "partial", omittedCount: null, resourceLimits }
@@ -18,6 +18,10 @@ const semanticResourceBounds = {
         value: SEMANTIC_EXPRESSION_DEPTH_LIMIT,
         unit: "depth",
     },
+    "getter-expansion": {
+        value: SEMANTIC_GETTER_EXPANSION_LIMIT,
+        unit: "items",
+    },
 };
 /** Map semantic evaluator bounds to their caller-visible application coverage. */
 export const semanticResourceLimitCoverage = (resourceLimits) => resourceLimits.map((resourceLimit) => ({

package/dist/domain/javascript/javascriptSemanticDataEffectHelpers.js

@@ -553,23 +553,17 @@ export const traverseDataEffects = (program, context, visit) => {
 export const dataEffectArgumentBindingId = (node, state) => t.isIdentifier(node)
     ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
     : null;
-/** Read one JSON primitive default without evaluating code. */
-export const dataEffectPrimitive = (node) => {
-    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
-        return node.value;
-    if (t.isBooleanLiteral(node))
-        return node.value;
-    return null;
-};
-/** Read one static string or expression-free template. */
+/**
+ * Read one static string or expression-free template. A template recovered
+ * with an invalid escape has no cooked value; its raw spelling is not a
+ * JavaScript string, so it stays dynamic.
+ */
 export const dataEffectLiteralString = (node) => {
     if (node === undefined)
         return null;
     const literal = readExactJavaScriptLiteral(node);
-    if (literal.found && typeof literal.value === "string")
-        return literal.value;
-    return t.isTemplateLiteral(node) && node.expressions.length === 0
-        ? (node.quasis[0]?.value.raw ?? null)
+    return literal.found && typeof literal.value === "string"
+        ? literal.value
         : null;
 };
 /** Read a member callee from call or construction syntax. */

package/dist/domain/javascript/javascriptSemanticDataEffects.js

@@ -1,9 +1,11 @@
 import * as t from "@babel/types";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
-import { semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
-import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { recordSemanticValueLimit, resolveSemanticBindingState, semanticResolutionBlocked, semanticStableInitializer, } from "./javascriptSemanticState.js";
+import { semanticBindingAtRead } from "./javascriptSemanticMutationInitializers.js";
+import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticPrimitiveSet } from "./javascriptSemanticPrimitives.js";
 /** Recover configuration, request, and boundary candidates from inert syntax. */
 export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
     const context = {
@@ -103,6 +105,11 @@ const collectDefaults = (program, context, configurations) => {
         const candidate = configurationsByNode.get(source);
         if (candidate === undefined)
             return;
+        const literal = readExactJavaScriptLiteral(node.right);
+        const value = literal.found
+            ? semanticPrimitiveSet([literal.value])
+            : { status: "unknown", reason: "Default is not an exact primitive." };
+        recordSemanticValueLimit(context.state, value);
         output.push({
             configId: `config:default:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: "default",
@@ -111,8 +118,11 @@ const collectDefaults = (program, context, configurations) => {
             resultBindingId: outerAssignedBinding(node, context),
             key: candidate.operation.key,
             sourceConfigId: candidate.operation.configId,
-            value: primitiveValue(node.right),
-            resolution: primitiveValue(node.right) === null ? "partial" : "complete",
+            value: value.status === "literal" ? value.value : null,
+            ...(value.status === "unknown" && value.resourceLimit !== undefined
+                ? { valueResourceLimit: value.resourceLimit }
+                : {}),
+            resolution: value.status === "literal" ? "complete" : "partial",
         });
     });
     return output;
@@ -147,6 +157,15 @@ const collectRequests = (program, context) => {
     });
     return output;
 };
+/**
+ * Any other write (assignment, update, loop or destructuring target) can
+ * replace the response before this read. A sole write that can be skipped or
+ * runs after the read leaves an incoming value possible.
+ */
+const soleWriteReachesRead = (binding, read, context) => binding?.initializers.length === 1 &&
+    (semanticStableInitializer(binding, context.state) !== undefined ||
+        semanticBindingAtRead(binding, read, context.state.parentsByNode)
+            .hasDefiniteInitializer);
 const collectResponseConsumers = (program, context, requests) => {
     const requestsByBinding = new Map();
     for (const request of requests) {
@@ -178,6 +197,13 @@ const collectResponseConsumers = (program, context, requests) => {
             : (requestsByBinding.get(binding.bindingId) ?? []);
         if (linked.length === 0)
             return;
+        // A consumer of exactly one request through its own result binding
+        // reads that request's response, so it keeps the request's endpoint.
+        const uniqueRequest = linked.length === 1 &&
+            !linked[0]?.operation.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
+            ? linked[0]
+            : undefined;
+        const soleWrite = soleWriteReachesRead(binding, member.object, context);
         output.push({
             requestId: `response:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
             kind: "response-consumer",
@@ -189,12 +215,9 @@ const collectResponseConsumers = (program, context, requests) => {
             linkedRequestIds: linked
                 .map(({ operation }) => operation.requestId)
                 .sort(compareUnicodeCodePoints),
-            endpoint: null,
+            endpoint: soleWrite ? (uniqueRequest?.operation.endpoint ?? null) : null,
             fields: [],
-            resolution: linked.length === 1 &&
-                !linked[0]?.operation.projectedResultBindings.some(({ bindingId }) => bindingId === binding?.bindingId)
-                ? "complete"
-                : "partial",
+            resolution: uniqueRequest === undefined ? "partial" : "complete",
         });
     });
     return output;

package/dist/domain/javascript/javascriptSemanticDerivedAnalysis.js

@@ -11,7 +11,7 @@ import { collectJavaScriptSemanticResources } from "./javascriptSemanticResource
  * Collect derived semantics with a yield between collectors. Each collector
  * completes before the next starts, so results equal the synchronous form.
  */
-export function* collectJavaScriptDerivedSemanticsSteps(program, state, callables, parserPartial) {
+export function* collectJavaScriptDerivedSemanticsSteps(program, state, callables, references, parserPartial) {
     const calls = collectJavaScriptSemanticCalls(program, state, callables);
     yield;
     const promiseOperations = collectJavaScriptSemanticPromises(program, state, callables);