rea-agents 6.4.0 → 6.7.0

package/dist/domain/javascript/javascriptSemanticValues.js

@@ -1,22 +1,47 @@
+import { semanticBindingMayHaveOpaqueEffect, semanticBindingCanBeRebound, semanticOpaqueBindingReadMayHaveChanged, } from "./javascriptSemanticOpaqueEffects.js";
 import * as t from "@babel/types";
-import { semanticCapturePosition, semanticEscapeFollowsCapture, semanticBindingPrecedesCapture, } from "./javascriptSemanticMutationInitializers.js";
+import { SemanticDependencyProofs, } from "./javascriptSemanticDependencies.js";
+import { semanticCapturePosition, semanticEscapeFollowsCapture, semanticBindingPrecedesCapture, semanticBindingAtRead, } from "./javascriptSemanticMutationInitializers.js";
 import { semanticSlotAtPath } from "./javascriptSemanticSlots.js";
 import { invalidateSemanticEscapedPath, invalidateSemanticMutationPaths, } from "./javascriptSemanticMutationValues.js";
-import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { recordSemanticValueLimit, resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { readExactJavaScriptLiteral, semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { semanticAmbiguousProvenance, semanticLocalProvenance, semanticOriginsProvenance, semanticUnresolvedProvenance, uniqueSemanticOrigins, } from "./javascriptSemanticProvenance.js";
 import { semanticPrimitiveCandidates as primitiveCandidates, semanticPrimitiveSet as primitiveSet, } from "./javascriptSemanticPrimitives.js";
 import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveAdditionByteBudget, exceedsSemanticTemplateByteBudget, semanticResourceLimitUnknown, semanticResourceLimitReason, } from "./javascriptSemanticResourceLimits.js";
+// Indexing owns stable binding identities; effects invalidate values, not this
+// identity-only layout. No query result or dependency closure is retained here.
+const dependencyProofsByState = new WeakMap();
+const createEvaluationMemo = (state) => {
+    let dependencies = dependencyProofsByState.get(state);
+    if (dependencies === undefined) {
+        dependencies = new SemanticDependencyProofs(state.bindingsById.keys());
+        dependencyProofsByState.set(state, dependencies);
+    }
+    return { provenance: new Map(), dependencyFrames: [], dependencies };
+};
+const CALLER_INDEPENDENT = Number.POSITIVE_INFINITY;
+const EVERY_CALLER = -1;
+const callerIndependentBindingValuesByState = new WeakMap();
 const primitiveBindingValuesByState = new WeakMap();
 const primitiveExpressionValuesByState = new WeakMap();
 const capturedBindingValuesByState = new WeakMap();
-/** Discard primitive projections evaluated before mutation collection finished. */
-export const clearSemanticPrimitiveBindingValues = (state) => {
+/** Discard every state-owned value derived before the effects boundary changed. */
+export const clearSemanticValueCaches = (state) => {
     primitiveBindingValuesByState.delete(state);
     capturedBindingValuesByState.delete(state);
     primitiveExpressionValuesByState.delete(state);
+    callerIndependentBindingValuesByState.delete(state);
+};
+const callerIndependentBindingValuesFor = (state) => {
+    const existing = callerIndependentBindingValuesByState.get(state);
+    if (existing !== undefined)
+        return existing;
+    const values = new Map();
+    callerIndependentBindingValuesByState.set(state, values);
+    return values;
 };
 const primitiveBindingValuesFor = (state) => {
     const existing = primitiveBindingValuesByState.get(state);
@@ -29,35 +54,137 @@ const primitiveBindingValuesFor = (state) => {
 // Cap expression recursion independently from graph nodes and primitive unions.
 const isSemanticResourceLimit = (value) => value.status === "unknown" && value.resourceLimit !== undefined;
 /** Evaluate one binding in the bounded constant-value lattice. */
-export const evaluateSemanticBinding = (binding, state) => evaluateBinding(binding, {
-    state,
-    bindings: new Set(),
-    expressionDepth: 0,
-    primitiveBindingValues: primitiveBindingValuesFor(state),
-});
+export const evaluateSemanticBinding = (binding, state) => semanticBindingCanBeRebound(binding) &&
+    semanticBindingMayHaveOpaqueEffect(binding, state)
+    ? {
+        status: "unknown",
+        reason: "Direct eval may have changed this lexical binding.",
+    }
+    : evaluateBinding(binding, {
+        state,
+        bindings: new Map(),
+        expressionDepth: 0,
+        primitiveBindingValues: primitiveBindingValuesFor(state),
+        dependence: { lowest: CALLER_INDEPENDENT },
+        memo: createEvaluationMemo(state),
+    });
 /** Evaluate an inert expression, optionally at an earlier reference capture. */
 export const evaluateSemanticExpression = (node, state, capturePoint) => {
     const context = {
         state,
-        bindings: new Set(),
+        bindings: new Map(),
         expressionDepth: 0,
         primitiveBindingValues: primitiveBindingValuesFor(state),
+        dependence: { lowest: CALLER_INDEPENDENT },
+        memo: createEvaluationMemo(state),
     };
     return evaluateExpression(node, capturePoint === undefined
         ? context
         : (captureContextAt(capturePoint, context) ?? context));
 };
+/** Resolve an expression using the same alias and module provenance owner. */
+export const evaluateSemanticExpressionProvenance = (node, state) => provenanceForExpression(node, {
+    state,
+    bindings: new Map(),
+    expressionDepth: 0,
+    primitiveBindingValues: primitiveBindingValuesFor(state),
+    dependence: { lowest: CALLER_INDEPENDENT },
+    memo: createEvaluationMemo(state),
+});
 /** Follow module provenance through destructuring, members, and aliases. */
-export const evaluateSemanticProvenance = (binding, state) => provenanceForBinding(binding, {
+export const evaluateSemanticProvenance = (binding, state) => {
+    const provenance = provenanceForBinding(binding, {
+        state,
+        bindings: new Map(),
+        expressionDepth: 0,
+        primitiveBindingValues: primitiveBindingValuesFor(state),
+        dependence: { lowest: CALLER_INDEPENDENT },
+        memo: createEvaluationMemo(state),
+    });
+    return semanticBindingCanBeRebound(binding) &&
+        semanticBindingMayHaveOpaqueEffect(binding, state)
+        ? semanticAmbiguousProvenance(provenance.origins, "Direct eval may have changed this runtime value.")
+        : provenance;
+};
+/** Follow a namespace binding as it was read at a specific source position. */
+export const evaluateSemanticProvenanceAtRead = (binding, read, state) => provenanceForBindingAtRead(binding, read, {
     state,
-    bindings: new Set(),
+    bindings: new Map(),
     expressionDepth: 0,
     primitiveBindingValues: primitiveBindingValuesFor(state),
+    dependence: { lowest: CALLER_INDEPENDENT },
+    memo: createEvaluationMemo(state),
 });
-const evaluateBinding = (binding, context) => {
-    if (context.bindings.has(binding.bindingId))
+const readMemoizedEvaluation = (entry, context) => {
+    if (entry === undefined ||
+        context.memo.dependencies.intersects(entry.dependencies, context.bindings))
+        return undefined;
+    retainDependencyProof(entry.dependencies, context);
+    return entry.value;
+};
+const retainDependencyProof = (proof, context) => {
+    const parent = context.memo.dependencyFrames.at(-1);
+    if (parent !== undefined)
+        parent.proof = context.memo.dependencies.union(parent.proof, proof);
+};
+const recordBindingDependency = (binding, context) => retainDependencyProof(context.memo.dependencies.binding(binding.bindingId), context);
+const collectEvaluationDependencies = (binding, context, evaluate) => {
+    const frame = { proof: context.memo.dependencies.binding(binding.bindingId) };
+    context.memo.dependencyFrames.push(frame);
+    try {
+        return { value: evaluate(), dependencies: frame.proof };
+    }
+    finally {
+        context.memo.dependencyFrames.pop();
+        retainDependencyProof(frame.proof, context);
+    }
+};
+/**
+ * A value snapshot consumes its sole initializer plus its source binding's
+ * effects. Key the parsed initializer fact (including projection), binding ID
+ * and capture point, rather than an ephemeral snapshot object or the whole ID.
+ * Query ownership prevents reuse across effect changes. Exact expression-depth
+ * keys also bound failed speculative evaluations without skipping their budget.
+ */
+const readSnapshotValuesFor = (binding, context) => {
+    const initializer = binding.initializers[0];
+    if (binding.initializers.length !== 1 || initializer === undefined)
+        return undefined;
+    let values;
+    if (context.capturePoint === undefined)
+        values = context.memo.snapshotValues ??= new WeakMap();
+    else {
+        const captures = (context.memo.capturedSnapshotValues ??= new WeakMap());
+        let captured = captures.get(context.capturePoint);
+        if (captured === undefined) {
+            captured = new WeakMap();
+            captures.set(context.capturePoint, captured);
+        }
+        values = captured;
+    }
+    let entries = values.get(initializer);
+    if (entries === undefined) {
+        entries = new Map();
+        values.set(initializer, entries);
+    }
+    let depths = entries.get(binding.bindingId);
+    if (depths === undefined) {
+        depths = new Map();
+        entries.set(binding.bindingId, depths);
+    }
+    return depths;
+};
+const evaluateBinding = (binding, context, 
+// Temporal read facts use a query-owned cache separate from whole bindings.
+wholeBinding = true) => {
+    recordBindingDependency(binding, context);
+    const cycleHead = context.bindings.get(binding.bindingId);
+    if (cycleHead !== undefined) {
+        context.dependence.lowest = Math.min(context.dependence.lowest, cycleHead);
         return { status: "cycle", reason: `Alias cycle at ${binding.name}.` };
-    if (context.capturePoint !== undefined &&
+    }
+    if (wholeBinding &&
+        context.capturePoint !== undefined &&
         !semanticBindingPrecedesCapture(binding, context.capturePoint, context.state.parentsByNode)) {
         const { capturePoint: _capturePoint, ...liveContext } = context;
         return evaluateBinding(binding, {
@@ -65,13 +192,43 @@ const evaluateBinding = (binding, context) => {
             primitiveBindingValues: primitiveBindingValuesFor(context.state),
         });
     }
-    const cached = context.primitiveBindingValues.get(binding.bindingId);
+    const cached = wholeBinding
+        ? context.primitiveBindingValues.get(binding.bindingId)
+        : undefined;
     if (cached !== undefined)
         return cached;
+    // Each closure that aliases an outer binding evaluates it both live and at
+    // its capture point, so re-deriving it doubles the work at every level of
+    // nesting. A deeper reader derives it again: the retained value would carry
+    // more nesting than the remaining depth budget allows it to observe.
+    const snapshots = wholeBinding
+        ? undefined
+        : readSnapshotValuesFor(binding, context);
+    const snapshot = snapshots?.get(context.expressionDepth);
+    const snapshotValue = readMemoizedEvaluation(snapshot, context);
+    if (snapshotValue !== undefined) {
+        // A result limited by this budget must not become caller-independent when
+        // reused inside another binding evaluated at the same remaining depth.
+        if (snapshot?.depthDependent === true)
+            context.dependence.lowest = EVERY_CALLER;
+        return snapshotValue;
+    }
+    const independent = wholeBinding && context.capturePoint === undefined
+        ? callerIndependentBindingValuesFor(context.state)
+        : undefined;
+    const retained = independent?.get(binding.bindingId);
+    if (retained !== undefined &&
+        context.expressionDepth <= retained.expressionDepth) {
+        const reusable = readMemoizedEvaluation(retained, context);
+        if (reusable !== undefined)
+            return reusable;
+    }
     if (binding.initializers.length === 0)
         return {
             status: "unknown",
-            reason: `Binding ${binding.name} has no constant initializer.`,
+            reason: wholeBinding
+                ? `Binding ${binding.name} has no constant initializer.`
+                : `Binding ${binding.name} has no proven initializer at this read.`,
         };
     if (binding.initializers.some(({ node }) => t.isUpdateExpression(node) ||
         (t.isAssignmentExpression(node) &&
@@ -91,24 +248,46 @@ const evaluateBinding = (binding, context) => {
     const initializer = binding.initializers[0];
     if (initializer === undefined)
         return { status: "unknown", reason: "Missing binding initializer." };
-    context.bindings.add(binding.bindingId);
+    if (context.state.conditionallySkippedExpressions.has(initializer.node))
+        return {
+            status: "unknown",
+            reason: `Binding ${binding.name} may remain uninitialized.`,
+        };
+    const position = context.bindings.size;
+    const callerDependence = context.dependence.lowest;
+    context.dependence.lowest = CALLER_INDEPENDENT;
+    context.bindings.set(binding.bindingId, position);
     let value;
+    let callerIndependent = false;
+    let depthDependent = false;
+    let evaluated;
     try {
-        const nested = nestedContext(context);
-        value = projectValue(evaluateExpression(initializer.node, nested), initializer.projection);
-        if (!isPrimitive(value)) {
-            const captureContext = primitiveCaptureContext(initializer.node, nested);
-            if (captureContext !== undefined) {
-                const captured = projectValue(evaluateExpression(initializer.node, captureContext), initializer.projection);
-                if (isPrimitive(captured))
-                    value = captured;
+        evaluated = collectEvaluationDependencies(binding, context, () => {
+            const nested = nestedContext(context);
+            let value = projectValue(evaluateExpression(initializer.node, nested), initializer.projection);
+            if (canCapturePrimitive(value)) {
+                const captureContext = primitiveCaptureContext(initializer.node, nested);
+                if (captureContext !== undefined) {
+                    const captured = projectValue(evaluateExpression(initializer.node, captureContext), initializer.projection);
+                    if (isPrimitive(captured))
+                        value = captured;
+                }
             }
-        }
+            return value;
+        });
+        value = evaluated.value;
+        // A cycle among bindings this one reads is part of its value. A cycle
+        // through this binding is cut elsewhere when a caller holds another member.
+        callerIndependent = context.dependence.lowest > position;
+        depthDependent = context.dependence.lowest === EVERY_CALLER;
     }
     finally {
         context.bindings.delete(binding.bindingId);
+        context.dependence.lowest = callerIndependent
+            ? callerDependence
+            : Math.min(callerDependence, context.dependence.lowest);
     }
-    let projected = invalidateSemanticMutationPaths(value, binding.mutatedPaths);
+    let projected = invalidateSemanticMutationPaths(value, binding.memberWrites.map(({ path }) => path));
     for (const escape of binding.escapedPaths) {
         // Escapes only invalidate object references; other lattice values survive.
         if (projected.status !== "object" && projected.status !== "array")
@@ -118,25 +297,60 @@ const evaluateBinding = (binding, context) => {
             continue;
         projected = invalidateSemanticEscapedPath(projected, escape.path);
     }
+    if ((projected.status === "object" || projected.status === "array") &&
+        semanticBindingMayHaveOpaqueEffect(binding, context.state, context.capturePoint, "reference"))
+        projected = {
+            status: "unknown",
+            reason: "Direct eval may have mutated this object reference.",
+        };
+    if (callerIndependent &&
+        independent !== undefined &&
+        (retained === undefined ||
+            retained.expressionDepth < context.expressionDepth))
+        independent.set(binding.bindingId, {
+            value: projected,
+            dependencies: evaluated.dependencies,
+            expressionDepth: context.expressionDepth,
+        });
+    // A cycle through an active caller is not reusable. Depth-dependent partial
+    // values are reusable at this exact budget, with their dependence preserved.
+    if (snapshots !== undefined &&
+        (callerIndependent || depthDependent) &&
+        !context.memo.dependencies.intersects(evaluated.dependencies, context.bindings))
+        snapshots.set(context.expressionDepth, {
+            value: projected,
+            dependencies: evaluated.dependencies,
+            depthDependent,
+        });
     // Point-local memoization also bounds failed speculative captures. Only a
     // primitive result is allowed back into ordinary value evaluation.
-    if (context.capturePoint !== undefined ||
-        projected.status === "literal" ||
-        projected.status === "union" ||
-        (isSemanticResourceLimit(projected) &&
-            (projected.resourceLimit === "primitive-bytes" ||
-                projected.resourceLimit === "primitive-candidates")))
+    if (wholeBinding &&
+        (context.capturePoint !== undefined ||
+            projected.status === "literal" ||
+            projected.status === "union" ||
+            (isSemanticResourceLimit(projected) &&
+                (projected.resourceLimit === "primitive-bytes" ||
+                    projected.resourceLimit === "primitive-candidates"))))
         context.primitiveBindingValues.set(binding.bindingId, projected);
     return projected;
 };
 const evaluateExpression = (node, context) => {
-    if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+    const value = evaluateExpressionValue(node, context);
+    recordSemanticValueLimit(context.state, value);
+    return value;
+};
+const evaluateExpressionValue = (node, context) => {
+    if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT) {
+        context.dependence.lowest = EVERY_CALLER;
         return semanticResourceLimitUnknown("expression-depth");
+    }
     const unwrapped = unwrapJavaScriptExpression(node);
     if (unwrapped.depth > 0) {
         if (context.expressionDepth + unwrapped.depth >
-            SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+            SEMANTIC_EXPRESSION_DEPTH_LIMIT) {
+            context.dependence.lowest = EVERY_CALLER;
             return semanticResourceLimitUnknown("expression-depth");
+        }
         return evaluateExpression(unwrapped.node, {
             ...context,
             expressionDepth: context.expressionDepth + unwrapped.depth,
@@ -144,14 +358,33 @@ const evaluateExpression = (node, context) => {
     }
     const literal = readExactJavaScriptLiteral(node);
     if (literal.found)
-        return typeof literal.value === "number"
-            ? primitiveSet([literal.value])
-            : { status: "literal", value: literal.value };
+        return primitiveSet([literal.value]);
     if (t.isIdentifier(node)) {
         const binding = resolveSemanticBindingState(context.state, node, node.name);
-        return binding === undefined
-            ? { status: "unknown", reason: `Unbound identifier ${node.name}.` }
-            : evaluateBinding(binding, nestedContext(context));
+        if (binding === undefined)
+            return { status: "unknown", reason: `Unbound identifier ${node.name}.` };
+        const read = binding.mutable &&
+            binding.definitions.some(({ kind }) => kind === "assignment")
+            ? semanticBindingAtRead(binding, node, context.state.parentsByNode)
+            : undefined;
+        if (read?.status === "unresolved") {
+            const value = evaluateBinding(binding, nestedContext(context));
+            if (value.status === "unknown" ||
+                value.status === "ambiguous" ||
+                value.status === "cycle")
+                return value;
+            return {
+                status: "unknown",
+                reason: `Binding ${binding.name} has unresolved ordering at this read.`,
+            };
+        }
+        const atRead = read?.binding ?? binding;
+        if (semanticOpaqueBindingReadMayHaveChanged(binding, context.capturePoint ?? node, context.state))
+            return {
+                status: "unknown",
+                reason: "Direct eval may have changed this lexical binding.",
+            };
+        return evaluateBinding(atRead, nestedContext(context), atRead === binding);
     }
     if (t.isTemplateLiteral(node))
         return evaluateTemplate(node, context);
@@ -395,11 +628,13 @@ const evaluateUnary = (node, context) => {
     return { status: "unknown", reason: `Unsupported unary ${node.operator}.` };
 };
 const projectValue = (value, projection) => {
+    if (isSemanticResourceLimit(value))
+        return value;
     if (projection.includes(null))
         return { status: "unknown", reason: "Cannot project a dynamic property." };
     const path = projection.map((key) => String(key));
     const slot = semanticSlotAtPath(value, path);
-    return slot.presence === "present"
+    return slot.presence === "present" || isSemanticResourceLimit(slot.value)
         ? slot.value
         : {
             status: "unknown",
@@ -407,21 +642,61 @@ const projectValue = (value, projection) => {
         };
 };
 const provenanceForBinding = (binding, context) => {
+    recordBindingDependency(binding, context);
+    const cycleHead = context.bindings.get(binding.bindingId);
+    if (cycleHead !== undefined) {
+        context.dependence.lowest = Math.min(context.dependence.lowest, cycleHead);
+        return semanticUnresolvedProvenance("cycle", `Alias cycle at ${binding.name}.`);
+    }
+    let depths = context.memo.provenance.get(binding.bindingId);
+    const prior = readMemoizedEvaluation(depths?.get(context.expressionDepth), context);
+    if (prior !== undefined)
+        return prior;
+    const position = context.bindings.size;
+    const callerDependence = context.dependence.lowest;
+    context.dependence.lowest = CALLER_INDEPENDENT;
+    let result;
+    let callerIndependent = false;
+    try {
+        result = collectEvaluationDependencies(binding, context, () => provenanceForBindingUncached(binding, context));
+        callerIndependent = context.dependence.lowest > position;
+    }
+    finally {
+        context.dependence.lowest = callerIndependent
+            ? callerDependence
+            : Math.min(callerDependence, context.dependence.lowest);
+    }
+    if (callerIndependent) {
+        if (depths === undefined) {
+            depths = new Map();
+            context.memo.provenance.set(binding.bindingId, depths);
+        }
+        depths.set(context.expressionDepth, result);
+    }
+    return result.value;
+};
+const provenanceForBindingUncached = (binding, context) => {
     const provenance = provenanceForBindingValue(binding, context);
     const assigned = binding.definitions.some(({ kind }) => kind === "assignment");
-    const conditionallyInitialized = binding.initializers.some(({ node }) => context.state.conditionalInitializers.has(node));
+    const conditionallyInitialized = binding.initializers.some(({ node }) => context.state.conditionallySkippedExpressions.has(node));
     if (provenance.status !== "module" ||
         (!assigned && !conditionallyInitialized))
         return provenance;
     return semanticAmbiguousProvenance(provenance.origins, assigned
         ? `Binding ${binding.name} may be reassigned.`
-        : `Binding ${binding.name} is conditionally initialized.`);
+        : `Binding ${binding.name} may remain uninitialized.`);
 };
 const provenanceForBindingValue = (binding, context) => {
-    if (context.bindings.has(binding.bindingId))
-        return semanticUnresolvedProvenance("cycle", `Alias cycle at ${binding.name}.`);
+    if (binding.kind === "parameter" || binding.kind === "catch")
+        return semanticUnresolvedProvenance("unknown", binding.kind === "parameter"
+            ? "Parameter provenance depends on caller arguments."
+            : "Catch binding provenance depends on the thrown value.");
     if (binding.directOrigins.length > 0)
-        return semanticOriginsProvenance(binding.directOrigins);
+        return binding.kind === "import" &&
+            !binding.runtimeImport &&
+            binding.directOrigins.every(({ resolutionMode }) => resolutionMode !== "require")
+            ? semanticAmbiguousProvenance(binding.directOrigins, "A type-only import does not establish a runtime module value.")
+            : semanticOriginsProvenance(binding.directOrigins);
     if (binding.initializers.length === 0)
         return semanticLocalProvenance();
     if (binding.initializers.length > 1)
@@ -431,7 +706,7 @@ const provenanceForBindingValue = (binding, context) => {
         return semanticUnresolvedProvenance("unknown", "Missing binding initializer.");
     if (initializer.projection.includes(null))
         return semanticUnresolvedProvenance("unknown", "Dynamic provenance projection.");
-    context.bindings.add(binding.bindingId);
+    context.bindings.set(binding.bindingId, context.bindings.size);
     let resolved;
     try {
         resolved = provenanceForExpression(initializer.node, nestedContext(context));
@@ -450,13 +725,17 @@ const provenanceForBindingValue = (binding, context) => {
     })));
 };
 const provenanceForExpression = (node, context) => {
-    if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+    if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT) {
+        context.dependence.lowest = EVERY_CALLER;
         return semanticUnresolvedProvenance("unknown", semanticResourceLimitReason("expression-depth"));
+    }
     const unwrapped = unwrapJavaScriptExpression(node);
     if (unwrapped.depth > 0) {
         if (context.expressionDepth + unwrapped.depth >
-            SEMANTIC_EXPRESSION_DEPTH_LIMIT)
+            SEMANTIC_EXPRESSION_DEPTH_LIMIT) {
+            context.dependence.lowest = EVERY_CALLER;
             return semanticUnresolvedProvenance("unknown", semanticResourceLimitReason("expression-depth"));
+        }
         return provenanceForExpression(unwrapped.node, {
             ...context,
             expressionDepth: context.expressionDepth + unwrapped.depth,
@@ -464,12 +743,20 @@ const provenanceForExpression = (node, context) => {
     }
     const required = semanticRequireOrigin(node, context.state);
     if (required !== undefined)
-        return semanticOriginsProvenance([required]);
+        return semanticOriginsProvenance([required.origin]);
+    if (t.isSequenceExpression(node)) {
+        const finalExpression = node.expressions.at(-1);
+        return finalExpression === undefined
+            ? semanticUnresolvedProvenance("unknown", "Empty sequence expression.")
+            : provenanceForExpression(finalExpression, nestedContext(context));
+    }
+    if (t.isAssignmentExpression(node) && node.operator === "=")
+        return provenanceForExpression(node.right, nestedContext(context));
     if (t.isIdentifier(node)) {
         const binding = resolveSemanticBindingState(context.state, node, node.name);
         return binding === undefined
             ? semanticUnresolvedProvenance("unknown", `Unbound identifier ${node.name}.`)
-            : provenanceForBinding(binding, nestedContext(context));
+            : provenanceForBindingAtRead(binding, node, nestedContext(context));
     }
     if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
         const members = [];
@@ -510,8 +797,39 @@ const provenanceForExpression = (node, context) => {
                 : "Conditional provenance includes a non-module alternative.")
             : semanticUnresolvedProvenance("unknown", "Conditional provenance is unresolved.");
     }
-    return semanticLocalProvenance();
+    if (isLocallyCreatedValue(node))
+        return semanticLocalProvenance();
+    return semanticUnresolvedProvenance("unknown", `Unsupported ${node.type} provenance.`);
+};
+/** Resolve an alias from the value visible at this read, before later rebinds. */
+const provenanceForBindingAtRead = (binding, read, context) => {
+    if (semanticOpaqueBindingReadMayHaveChanged(binding, read, context.state))
+        return semanticAmbiguousProvenance(provenanceForBinding(binding, context).origins, "Direct eval may have changed this runtime value.");
+    const { binding: snapshot } = semanticBindingAtRead(binding, read, context.state.parentsByNode);
+    if (snapshot === binding)
+        return provenanceForBinding(binding, context);
+    if (context.bindings.has(binding.bindingId))
+        return semanticUnresolvedProvenance("cycle", `Alias cycle at ${binding.name}.`);
+    context.bindings.set(binding.bindingId, context.bindings.size);
+    try {
+        return provenanceForBindingValue(snapshot, context);
+    }
+    finally {
+        context.bindings.delete(binding.bindingId);
+    }
 };
+const isLocallyCreatedValue = (node) => readExactJavaScriptLiteral(node).found ||
+    t.isObjectExpression(node) ||
+    t.isArrayExpression(node) ||
+    t.isFunctionExpression(node) ||
+    t.isFunctionDeclaration(node) ||
+    t.isArrowFunctionExpression(node) ||
+    t.isClassExpression(node) ||
+    t.isClassDeclaration(node) ||
+    t.isTemplateLiteral(node) ||
+    t.isUnaryExpression(node) ||
+    t.isBinaryExpression(node) ||
+    t.isUpdateExpression(node);
 const mergeValues = (values) => {
     const resourceLimit = values.find(isSemanticResourceLimit);
     if (resourceLimit !== undefined)
@@ -529,8 +847,13 @@ const nestedContext = (context) => ({
         : { capturePoint: context.capturePoint }),
     expressionDepth: context.expressionDepth + 1,
     bindings: context.bindings,
+    dependence: context.dependence,
+    memo: context.memo,
 });
 const isPrimitive = (value) => value.status === "literal" || value.status === "union";
+/** Capturing cannot restore an exhausted expression-depth budget. */
+const canCapturePrimitive = (value) => !isPrimitive(value) &&
+    !(isSemanticResourceLimit(value) && value.resourceLimit === "expression-depth");
 const primitiveCaptureContext = (node, context) => {
     if (t.isObjectExpression(node) || t.isArrayExpression(node))
         return undefined;
@@ -560,7 +883,7 @@ const evaluateCapturedExpression = (node, context) => {
     if (cached !== undefined)
         return cached;
     let value = evaluateExpression(node, context);
-    if (!isPrimitive(value)) {
+    if (canCapturePrimitive(value)) {
         const captureContext = primitiveCaptureContext(node, context);
         if (captureContext !== undefined) {
             const captured = evaluateExpression(node, captureContext);