rea-agents 6.4.0 → 6.5.0

package/dist/domain/javascript/javascriptSemanticFingerprints.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
+import { runtimeFunctionParameters } from "./javascriptAstValues.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";
@@ -22,7 +23,7 @@ export function* collectJavaScriptSemanticFingerprintsSteps(input) {
         if (node === undefined)
             continue;
         yield;
-        const syntax = yield* fingerprintSyntaxSteps(node, callable.callableId);
+        const syntax = yield* fingerprintSyntaxSteps(node);
         const promiseEffects = promiseEffectsByOwner.get(callable.callableId) ?? [];
         const eventEffects = eventEffectsByOwner.get(callable.callableId) ?? [];
         const timerEffects = timerEffectsByOwner.get(callable.callableId) ?? [];
@@ -83,18 +84,13 @@ const countByOwner = (values, getOwner) => {
     }
     return counts;
 };
-function* fingerprintSyntaxSteps(root, targetCallableId) {
+function* fingerprintSyntaxSteps(root) {
     const normalizedTokens = [];
     const controlFlowTokens = [];
     const literals = [];
-    const callableStack = [];
     yield* traverseJavaScriptAstSteps(root, {
+        skip: (node) => semanticCallableIdForNode(node) !== null,
         enter: (node, parent) => {
-            const callableId = semanticCallableIdForNode(node);
-            if (callableId !== null)
-                callableStack.push(callableId);
-            if (callableStack.at(-1) !== targetCallableId)
-                return;
             normalizedTokens.push(normalizedNodeToken(node, parent));
             const control = controlFlowToken(node);
             if (control !== null)
@@ -103,11 +99,6 @@ function* fingerprintSyntaxSteps(root, targetCallableId) {
             if (literal !== null)
                 literals.push(literal);
         },
-        exit: (node) => {
-            const callableId = semanticCallableIdForNode(node);
-            if (callableId !== null && callableStack.at(-1) === callableId)
-                callableStack.pop();
-        },
     });
     return { normalizedTokens, controlFlowTokens, literals };
 }
@@ -127,6 +118,8 @@ const normalizedNodeToken = (node, parent) => {
         primitiveAttribute(node, "optional"),
         primitiveAttribute(node, "async"),
         primitiveAttribute(node, "generator"),
+        primitiveAttribute(node, "delegate"),
+        primitiveAttribute(node, "prefix"),
     ].filter((value) => value !== null);
     return [node.type, ...attributes].join(":");
 };
@@ -170,6 +163,10 @@ const controlFlowToken = (node) => {
     return operator === null ? node.type : `${node.type}:${operator}`;
 };
 const semanticLiteral = (node) => {
+    // Babel retains directive escapes in value; decoding them would erase the
+    // distinction between a strict-mode directive and an escaped lookalike.
+    if (t.isDirectiveLiteral(node))
+        return `directive:${node.value}`;
     if (t.isStringLiteral(node))
         return `string:${node.value}`;
     if (t.isNumericLiteral(node))
@@ -192,6 +189,6 @@ const relationShape = (callable, callSites, captureCount, promises) => [
     `captures:${String(captureCount)}`,
     ...promises.map(({ kind, method, ownership, sourceResolution }) => `promise:${kind}:${method}:${ownership}:${sourceResolution}`),
 ];
-const callableParameterArity = (node) => t.isFunction(node) ? node.params.length : 0;
+const callableParameterArity = (node) => t.isFunction(node) ? runtimeFunctionParameters(node).length : 0;
 const isAsyncCallable = (node) => t.isFunction(node) && node.async;
 const digest = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");

package/dist/domain/javascript/javascriptSemanticGraph.js

@@ -185,10 +185,12 @@ function* checkCoverageSteps(graph, context) {
         relationsByFamily.set(family, (relationsByFamily.get(family) ?? 0) + 1);
     }
     const unknownsById = new Map();
+    const unknownFamilies = new Set();
     for (const [index, unknown] of graph.unknowns.entries()) {
         if (index % 256 === 0)
             yield;
         unknownsById.set(unknown.unknown_id, unknown);
+        unknownFamilies.add(unknown.family);
     }
     for (const [index, family] of graph.coverage.families.entries()) {
         if (family.retained_relations !== relationsByFamily.get(family.family))
@@ -204,7 +206,9 @@ function* checkCoverageSteps(graph, context) {
                 message: "Family coverage references an unknown from another family",
             });
         if (family.status === "complete" &&
-            (family.omitted_relations !== 0 || family.unknown_ids.length > 0))
+            (family.omitted_relations !== 0 ||
+                family.unknown_ids.length > 0 ||
+                unknownFamilies.has(family.family)))
             context.addIssue({
                 code: "custom",
                 path: ["coverage", "families", index],

package/dist/domain/javascript/javascriptSemanticGraphSchemas.js

@@ -163,7 +163,6 @@ const relativePathSchema = z
     .string()
     .min(1)
     .refine((path) => !path.startsWith("/") &&
-    !path.includes("\\") &&
     path.split("/").every((part) => !["", ".", ".."].includes(part)), "Expected a normalized relative POSIX path without traversal");
 const sourcePointSchema = z.strictObject({
     line: z.number().int().min(1),

package/dist/domain/javascript/javascriptSemanticIterationSources.js

@@ -1,5 +1,5 @@
 import * as t from "@babel/types";
-import { semanticObjectPatternKeys, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
+import { semanticObjectPatternKeys, runtimeFunctionParameters, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
 import { semanticArrayIndex, } from "./javascriptSemanticPropertyPaths.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 const add = (sources, source, mutation, guards, kind = "iteration") => {
@@ -133,7 +133,7 @@ export const semanticIterationSources = (node, parent) => {
     else if (t.isYieldExpression(node) && node.delegate && node.argument != null)
         add(sources, { node: node.argument, projection: [] }, node, {});
     else if (t.isFunction(node))
-        for (const parameter of node.params)
+        for (const parameter of runtimeFunctionParameters(node))
             visit(context, parameter, undefined);
     return sources;
 };

package/dist/domain/javascript/javascriptSemanticMemberMutations.js

@@ -1,25 +1,100 @@
 import * as t from "@babel/types";
+import { semanticGlobalProcessOrigin, semanticGlobalProcessPathOrigin, semanticOriginalGlobalProcessAt, semanticMutableBuiltinOrigin, semanticRequireExportsIdentity, semanticRequireOrigin, } from "./javascriptSemanticRequireOrigin.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
-import { clearSemanticPrimitiveBindingValues, evaluateSemanticBinding, evaluateSemanticExpression, } from "./javascriptSemanticValues.js";
-import { semanticContainer, semanticSlotAtPath, } from "./javascriptSemanticSlots.js";
+import { clearSemanticValueCaches, evaluateSemanticBinding, evaluateSemanticExpression, } from "./javascriptSemanticValues.js";
+import { semanticContainer } from "./javascriptSemanticSlots.js";
 import { semanticClassCandidates, semanticClassPropertyReferences, semanticObjectPropertyReferences, } from "./javascriptSemanticObjectReferences.js";
 import { semanticIterationSources } from "./javascriptSemanticIterationSources.js";
 import { semanticCallableResultExpressions } from "./javascriptSemanticCallableResults.js";
 import { createSemanticReturnedReferences } from "./javascriptSemanticReturnedReferences.js";
 import { semanticMutationInitializers } from "./javascriptSemanticMutationInitializers.js";
+import { semanticReferenceSourcesInactive, semanticSelectedReferenceSlot, } from "./javascriptSemanticReferenceSources.js";
 import { semanticArrayIndex, SemanticPropertyPathCoverage, semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";
-import { semanticStaticPropertyKey, semanticMemberWriteTargets, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey, semanticWriteSiteTarget, semanticWriteTargets, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 /** Preserve uncertainty from property writes and references exposed to calls, yielding during traversal and fixpoint iteration. */
 export function* collectSemanticMemberMutationsSteps(program, state) {
     const parents = state.parentsByNode;
-    const normalizePath = observableMutationPaths(state);
+    const observablePaths = observableMutationPaths(state);
     const returnedReferences = createSemanticReturnedReferences(state);
-    const recordedEffects = new Set();
+    const recordedRequiredEffects = new Set();
+    let recordedEffectCount = 0;
+    const recordRequiredEffect = (specifier, path, effect, node) => {
+        const identity = semanticRequireExportsIdentity(specifier, path);
+        // Node stores process.env values and process.argv entries as strings, so
+        // passing one to a call exposes no object that the callee could mutate.
+        // Replacing an entry records its own write or receiver escape.
+        if (effect === "escape" &&
+            identity.specifier === "process" &&
+            identity.path.length === 2 &&
+            (identity.path[0] === "env" || identity.path[0] === "argv"))
+            return;
+        const key = JSON.stringify([
+            "required",
+            identity.specifier,
+            effect,
+            identity.path,
+            node?.start,
+            node?.end,
+        ]);
+        if (recordedRequiredEffects.has(key))
+            return;
+        recordedRequiredEffects.add(key);
+        recordedEffectCount += 1;
+        const effects = state.requiredModuleEffects.get(identity.specifier) ?? [];
+        effects.push({ path: identity.path, node, kind: effect });
+        state.requiredModuleEffects.set(identity.specifier, effects);
+    };
+    // Ambient indexing owns aliases of global objects. Consume its canonical
+    // writes instead of reparsing qualified or aliased process assignments.
+    for (const { path, node } of state.ambientWriteEffects)
+        if (path[0] === "global" &&
+            path[1] === "process" &&
+            path.length > 2 &&
+            node !== undefined &&
+            semanticOriginalGlobalProcessAt(node, state))
+            recordRequiredEffect("node:process", path.slice(2), "write", node);
     const selections = new Map();
     const coveringPaths = new Map();
     let arrayIterationUnknown = false;
+    // Definition collection finishes before this phase, so a scope's bindings no
+    // longer change and one node resolves to one binding. Repeated visits of the
+    // same node otherwise repeat the same scope walk.
+    const resolvedBindings = new WeakMap();
+    const resolveBinding = (node, name) => {
+        const cached = resolvedBindings.get(node);
+        if (cached !== undefined)
+            return cached ?? undefined;
+        const resolved = resolveSemanticBindingState(state, node, name);
+        resolvedBindings.set(node, resolved ?? null);
+        return resolved;
+    };
+    // One capture tuple recurs across every alias it reaches. Re-encoding it
+    // would rebuild the same long key and force a fresh string hash per lookup.
+    const captureKeys = new WeakMap();
+    const captureKeyOf = (binding, originAt, ownerInitializer) => {
+        let byPosition = captureKeys.get(binding);
+        if (byPosition === undefined) {
+            byPosition = new Map();
+            captureKeys.set(binding, byPosition);
+        }
+        const positionKey = `${originAt?.start ?? "u"}:${originAt?.end ?? "u"}:${ownerInitializer?.start ?? "u"}:${ownerInitializer?.end ?? "u"}`;
+        const cached = byPosition.get(positionKey);
+        if (cached !== undefined)
+            return cached;
+        const created = JSON.stringify([
+            binding.bindingId,
+            originAt?.start,
+            originAt?.end,
+            ownerInitializer?.start,
+            ownerInitializer?.end,
+        ]);
+        byPosition.set(positionKey, created);
+        return created;
+    };
+    // A capture key already ends the array; a path stays one nested element.
+    const lifetimeKey = (captureKey, path) => `${captureKey.slice(0, -1)},${JSON.stringify(path)}]`;
     const pendingReferences = [];
     const iterableReferences = [];
     const iterableReferenceKeys = new WeakMap();
@@ -53,8 +128,16 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
         iterableReferenceKeys.set(reference.node, keys);
         iterableReferences.push(reference);
     };
-    const markValue = (node, path, bindings, effect = "write", mutation, originAt = mutation) => {
-        const pending = [{ node, path, bindings, originAt }];
+    const markValue = (node, path, bindings, effect = "write", mutation, originAt = mutation, ownerInitializer) => {
+        const pending = [
+            {
+                node,
+                path,
+                bindings,
+                originAt,
+                ...(ownerInitializer === undefined ? {} : { ownerInitializer }),
+            },
+        ];
         // Visit shallower alias traversals first so their exact prefixes suppress
         // longer loop paths before those paths enumerate every assignment order.
         for (let cursor = 0; cursor < pending.length; cursor++) {
@@ -62,9 +145,22 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
             if (current === undefined)
                 break;
             const expression = unwrapJavaScriptExpression(current.node).node;
+            const required = semanticRequireOrigin(expression, state);
+            if (required !== undefined) {
+                recordRequiredEffect(required.origin.specifier, [...required.origin.importedPath, ...current.path], effect, mutation);
+                continue;
+            }
+            const globalProcess = semanticGlobalProcessPathOrigin(expression, state);
+            if (globalProcess !== undefined) {
+                recordRequiredEffect(globalProcess.specifier, [...globalProcess.importedPath, ...current.path], effect, mutation);
+                continue;
+            }
             if (t.isIdentifier(expression)) {
-                const binding = resolveSemanticBindingState(state, expression, expression.name);
+                const binding = resolveBinding(expression, expression.name);
                 if (binding === undefined) {
+                    const processOrigin = semanticGlobalProcessOrigin(expression, state);
+                    if (processOrigin !== undefined)
+                        recordRequiredEffect(processOrigin.specifier, current.path, effect, mutation);
                     if ((expression.name === "Array" &&
                         (current.path[0] === "prototype" || current.path[0] === null)) ||
                         (["globalThis", "global", "window", "self"].includes(expression.name) &&
@@ -76,19 +172,34 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                 // An alias restored from a saved reference can revisit the same binding
                 // at an earlier capture or a shorter getter-receiver path. Only a
                 // repeated capture and path closes a cycle.
-                const lifetime = JSON.stringify([
-                    binding.bindingId,
-                    current.originAt?.start,
-                    current.originAt?.end,
-                    current.path,
-                ]);
+                const captureKey = captureKeyOf(binding, current.originAt, current.ownerInitializer);
+                const lifetime = lifetimeKey(captureKey, current.path);
                 if (current.bindings.has(lifetime))
                     continue;
+                // A self alias such as `node = node[key]` revisits its capture with the
+                // same prefix added on every cycle, so exact paths never repeat. When
+                // that prefix can never be pruned, escaping it once covers every longer
+                // effect, including writes below shared children.
+                // Only a capture already on this alias chain can repeat a prefix.
+                const revisited = current.bindings.has(captureKey);
+                let repeatedPrefix;
+                for (let start = 1; revisited && start <= current.path.length; start++) {
+                    const suffix = current.path.slice(start);
+                    if (!current.bindings.has(lifetimeKey(captureKey, suffix)))
+                        continue;
+                    repeatedPrefix = current.path.slice(0, start);
+                    break;
+                }
+                if (repeatedPrefix !== undefined &&
+                    observablePaths.repeatsUnpruned(binding.bindingId, repeatedPrefix)) {
+                    markValue(current.node, repeatedPrefix, new Set(), "escape", mutation, current.originAt, current.ownerInitializer);
+                    continue;
+                }
                 // Union compatible copied-slot selections at each binding. Carrying every
                 // combination of exclusions through branch diamonds is exponential.
                 // Preserve paths that can change observed slots or Array prototype
                 // effects; canonicalize suffixes that cannot distinguish lattice facts.
-                let path = normalizePath(binding.bindingId, current.path, effect);
+                let path = observablePaths.normalize(binding.bindingId, current.path, effect);
                 if (path === null)
                     continue;
                 const selectorIndex = path.findIndex((key) => key !== null && typeof key === "object");
@@ -104,6 +215,8 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                         mutation?.end,
                         current.originAt?.start,
                         current.originAt?.end,
+                        current.ownerInitializer?.start,
+                        current.ownerInitializer?.end,
                     ]);
                     const previous = selections.get(selectionIdentity);
                     const excludedKeys = previous === undefined
@@ -114,19 +227,23 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                     selections.set(selectionIdentity, excludedKeys);
                     path = path.map((key, index) => index === selectorIndex ? { ...selector, excludedKeys } : key);
                 }
+                const origins = current.ownerInitializer !== undefined
+                    ? {
+                        initializers: binding.initializers.filter(({ node }) => node === current.ownerInitializer),
+                        referenceInitializers: [],
+                        directOrigins: [],
+                    }
+                    : current.originAt === undefined
+                        ? binding
+                        : semanticMutationInitializers(binding, current.originAt, parents);
                 // Keep an antichain of exact paths. Widening distinct member keys would
                 // also invalidate unrelated siblings that never reach this effect.
-                const pathState = JSON.stringify([
-                    binding.bindingId,
-                    effect,
-                    // Short writes stop at owned literal slots, whereas longer writes
-                    // reach shared children. Only equal-depth writes cover one another.
-                    effect === "write" ? path.length : null,
-                    mutation?.start,
-                    mutation?.end,
-                    current.originAt?.start,
-                    current.originAt?.end,
-                ]);
+                // This map is local to the file scan. Escaping the binding id keeps a
+                // field separator injective while avoiding a fresh JSON array encode.
+                const pathState = `${JSON.stringify(binding.bindingId)}\u0001${effect}\u0001${
+                // Short writes stop at owned literal slots, whereas longer writes
+                // reach shared children. Only equal-depth writes cover one another.
+                effect === "write" ? path.length : -1}\u0001${mutation?.start ?? -1}\u0001${mutation?.end ?? -1}\u0001${current.originAt?.start ?? -1}\u0001${current.originAt?.end ?? -1}\u0001${current.ownerInitializer?.start ?? -1}\u0001${current.ownerInitializer?.end ?? -1}`;
                 let covering = coveringPaths.get(pathState);
                 if (covering === undefined) {
                     covering = new SemanticPropertyPathCoverage();
@@ -134,35 +251,31 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                 }
                 if (!covering.retain(path))
                     continue;
-                const identity = JSON.stringify([
-                    binding.bindingId,
-                    effect,
-                    path,
-                    mutation?.start,
-                    mutation?.end,
-                    current.originAt?.start,
-                    current.originAt?.end,
-                ]);
-                if (recordedEffects.has(identity))
-                    continue;
                 // A recorded write invalidates the binding to a non-primitive value, so
                 // only its first write can target a primitive. Re-evaluating it would
                 // replay every earlier write and make repeated writes superlinear.
-                const value = effect === "write" && binding.mutatedPaths.length === 0
+                const value = effect === "write" && binding.memberWrites.length === 0
                     ? evaluateSemanticBinding(binding, state)
                     : undefined;
                 const primitiveWrite = value?.status === "literal" || value?.status === "union";
-                recordedEffects.add(identity);
-                const nested = new Set([...current.bindings, lifetime]);
-                const origins = current.originAt === undefined
-                    ? binding
-                    : semanticMutationInitializers(binding, current.originAt, parents);
+                // The coverage index already owns binding-effect deduplication.
+                recordedEffectCount += 1;
+                const nested = new Set(current.bindings);
+                nested.add(lifetime);
+                nested.add(captureKey);
+                // Returning a literal's receiver reaches that allocation, not the
+                // binding's older values read while evaluating its initializer.
                 if (!primitiveWrite) {
+                    for (const origin of origins.directOrigins) {
+                        const shared = semanticMutableBuiltinOrigin(origin, path);
+                        if (shared !== undefined)
+                            recordRequiredEffect(shared.specifier, shared.path, effect, mutation);
+                    }
                     if (effect === "escape")
                         binding.escapedPaths.push({ path, node: mutation });
                     else
-                        binding.mutatedPaths.push(path);
-                    clearSemanticPrimitiveBindingValues(state);
+                        binding.memberWrites.push({ path, node: mutation });
+                    clearSemanticValueCaches(state);
                     for (const initializer of origins.initializers)
                         pending.push({
                             node: initializer.node,
@@ -201,7 +314,9 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                 for (const value of effect === "escape"
                     ? escapedReferenceLeaves(expression, current.path)
                     : expandedValues(expression, current.path, effect)) {
-                    if (value.iterableFallbackPath !== undefined)
+                    if (value.escapes && effect !== "escape")
+                        markValue(value.node, value.path, new Set(), "escape", mutation, current.originAt, value.ownerInitializer);
+                    else if (value.iterableFallbackPath !== undefined)
                         deferIterable({
                             node: value.node,
                             projection: [],
@@ -257,11 +372,13 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                 continue;
             const pathKey = JSON.stringify(value.path);
             if (t.isIdentifier(node) && value.iterableFallbackPath === undefined) {
-                const binding = resolveSemanticBindingState(state, node, node.name);
+                const binding = resolveBinding(node, node.name);
                 const identity = JSON.stringify([
                     binding === undefined ? null : binding.bindingId,
                     binding === undefined ? node.name : null,
                     pathKey,
+                    value.ownerInitializer?.start,
+                    value.ownerInitializer?.end,
                 ]);
                 if (leafIdentities.has(identity))
                     continue;
@@ -295,8 +412,9 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
             markEscaped(expression.object, mutation);
     };
     const markTarget = (node, mutation) => {
-        for (const target of semanticMemberWriteTargets(node))
-            markValue(target.object, [semanticStaticPropertyKey(target.property, target.computed)], new Set(), "write", mutation);
+        for (const target of semanticWriteTargets(node))
+            if (!t.isIdentifier(target))
+                markValue(target.object, [semanticStaticPropertyKey(target.property, target.computed)], new Set(), "write", mutation);
     };
     yield* traverseJavaScriptAstSteps(program, {
         enter: (node, parent) => {
@@ -310,14 +428,9 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                     originAt: source.mutation,
                     iterationOnly: source.kind === "iteration",
                 });
-            if (t.isAssignmentExpression(node))
-                markTarget(node.left, node);
-            else if (t.isUpdateExpression(node))
-                markTarget(node.argument, node);
-            else if (t.isUnaryExpression(node, { operator: "delete" }))
-                markTarget(node.argument, node);
-            else if (t.isForOfStatement(node) || t.isForInStatement(node))
-                markTarget(node.left, node);
+            const writeTarget = semanticWriteSiteTarget(node);
+            if (writeTarget !== null)
+                markTarget(writeTarget, node);
             else if (t.isCallExpression(node) ||
                 t.isOptionalCallExpression(node) ||
                 t.isNewExpression(node)) {
@@ -351,14 +464,14 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
     // A later effect can make a previously defined destructuring source uncertain.
     // Reconsider defaults and iterable origins until their effects are stable.
     while (pendingReferences.length > 0 || iterableReferences.length > 0) {
-        const effectsBefore = recordedEffects.size;
+        const effectsBefore = recordedEffectCount;
         const iterablesBefore = iterableReferences.length;
         const iterationBefore = arrayIterationUnknown;
         for (const [index, reference] of pendingReferences.splice(0).entries()) {
             if (index % 64 === 0)
                 yield;
             const { initializer } = reference;
-            if (referenceSourcesInactive(initializer, state))
+            if (semanticReferenceSourcesInactive(initializer, state))
                 pendingReferences.push(reference);
             else if (t.isForOfStatement(initializer.node))
                 deferIterable({
@@ -396,7 +509,7 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
         for (const [index, reference] of [...iterableReferences].entries()) {
             if (index % 64 === 0)
                 yield;
-            if (referenceSourcesInactive(reference, state))
+            if (semanticReferenceSourcesInactive(reference, state))
                 continue;
             if (reference.iterationOnly) {
                 const expanded = expandedIterationReferences(reference, state);
@@ -406,7 +519,7 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                     continue;
                 }
             }
-            const slot = selectedReferenceSlot(reference, state);
+            const slot = semanticSelectedReferenceSlot(reference, state);
             // Custom iteration can yield the iterable itself as well as any child.
             // Treat its root as escaped, including writes through yielded references.
             const knownArray = !arrayIterationUnknown &&
@@ -416,26 +529,15 @@ export function* collectSemanticMemberMutationsSteps(program, state) {
                 continue;
             markValue(reference.node, knownArray ? reference.path : reference.fallbackPath, reference.bindings, knownArray ? reference.effect : "escape", reference.mutation, reference.originAt);
         }
-        if (recordedEffects.size === effectsBefore &&
+        if (recordedEffectCount === effectsBefore &&
             iterableReferences.length === iterablesBefore &&
             arrayIterationUnknown === iterationBefore)
             break;
     }
     // Gathering effects can evaluate a primitive projection before its object
     // escapes. Final values must use the completed mutation state.
-    clearSemanticPrimitiveBindingValues(state);
+    clearSemanticValueCaches(state);
 }
-const referenceSourcesInactive = (reference, state) => reference.requiredSources?.some((source) => selectedReferenceSlot(source, state, source.node)?.presence === "absent") === true ||
-    reference.fallbackSources?.some((source) => {
-        // Selection precedes effects through the chosen reference. A later escape
-        // cannot make a fallback that was excluded at destructuring reachable.
-        const slot = selectedReferenceSlot(source, state, source.node);
-        return (slot?.presence === "present" &&
-            (slot.value.status === "literal" ||
-                slot.value.status === "union" ||
-                slot.value.status === "object" ||
-                slot.value.status === "array"));
-    }) === true;
 const expandedIterationReferences = (reference, state) => {
     if (!t.isForOfStatement(reference.mutation))
         return null;
@@ -449,7 +551,7 @@ const expandedIterationReferences = (reference, state) => {
     ].find((source) => source.node === iterable && source.projection[0] === null);
     if (source === undefined)
         return null;
-    const slot = selectedReferenceSlot({ node: iterable, projection: [] }, state);
+    const slot = semanticSelectedReferenceSlot({ node: iterable, projection: [] }, state);
     const container = slot === undefined ? null : semanticContainer(slot.value);
     if (container?.coverage.status !== "complete")
         return null;
@@ -587,12 +689,14 @@ const observableMutationPaths = (state) => {
         const observer = bindingNodes.get(binding.bindingId);
         if (observer === undefined)
             continue;
+        // Imported values are external objects with observable member slots even
+        // when their syntax has no local object-allocation node (for example a
+        // CommonJS namespace from `require("node:fs")`). Keep those writes at their
+        // exact member paths instead of widening the first path to a wildcard.
+        const hasParsedRequireOrigin = binding.initializers.some(({ node }) => semanticRequireOrigin(node, state) !== undefined);
+        if (binding.directOrigins.length > 0 || hasParsedRequireOrigin)
+            (observer.origins ??= new Set()).add("opaque");
         for (const initializer of binding.initializers) {
-            const expression = unwrapJavaScriptExpression(initializer.node).node;
-            // Preserve member paths through class values and local instances so
-            // getter-result aliases can be resolved at the accessor boundary.
-            if (t.isClass(expression) || t.isNewExpression(expression))
-                (observer.origins ??= new Set()).add("opaque");
             link(project(expressionNode(initializer.node), initializer.projection), observer);
         }
         // Preserve exact paths where copies, defaults or iteration need their
@@ -615,7 +719,12 @@ const observableMutationPaths = (state) => {
                 if (selected === undefined)
                     break;
                 const { expression, observer } = selected;
-                if (t.isObjectExpression(expression) || t.isArrayExpression(expression))
+                // Keep class/getter projections distinct so cycle pruning does not
+                // discard observable escapes through a shared getter result.
+                if (t.isObjectExpression(expression) ||
+                    t.isArrayExpression(expression) ||
+                    t.isClass(expression) ||
+                    t.isNewExpression(expression))
                     (observer.origins ??= new Set()).add(expression);
                 else if (t.isIdentifier(expression)) {
                     const binding = resolveSemanticBindingState(state, expression, expression.name);
@@ -689,7 +798,7 @@ const observableMutationPaths = (state) => {
         }
     };
     settle();
-    return (bindingId, path, effect) => {
+    const normalize = (bindingId, path, effect) => {
         let observer = bindingNodes.get(bindingId);
         if (observer === undefined)
             return path;
@@ -713,6 +822,39 @@ const observableMutationPaths = (state) => {
         }
         return path;
     };
+    // A projection's origins depend only on its source origins and key. Once
+    // repeating a prefix revisits an origin set, every longer repetition stays
+    // observable and normalization can never prune it. The answer depends only
+    // on the binding and prefix, so every revisit of a long chain shares it.
+    const repeated = new Map();
+    const repeatsUnpruned = (bindingId, prefix) => {
+        const key = JSON.stringify([bindingId, prefix]);
+        const cached = repeated.get(key);
+        if (cached !== undefined)
+            return cached;
+        let observer = bindingNodes.get(bindingId);
+        const signatures = new Set();
+        let result = false;
+        while (observer !== undefined && prefix.length > 0) {
+            observer = project(observer, prefix);
+            settle();
+            if ((observer.origins?.size ?? 0) === 0)
+                break;
+            const signature = JSON.stringify([...(observer.origins ?? [])]
+                .map((origin) => typeof origin === "string"
+                ? origin
+                : `${String(origin.start)}:${String(origin.end)}`)
+                .sort(compareUnicodeCodePoints));
+            if (signatures.has(signature)) {
+                result = true;
+                break;
+            }
+            signatures.add(signature);
+        }
+        repeated.set(key, result);
+        return result;
+    };
+    return { normalize, repeatsUnpruned };
 };
 const arrayReferencedValues = (node, path) => {
     const [key, ...remaining] = path;
@@ -800,12 +942,3 @@ const copiedReferencePath = (initializer, path, effect) => {
     }
     return [...initializer.projection.slice(0, offset), key, ...remaining];
 };
-const selectedReferenceSlot = (source, state, capturePoint) => {
-    const path = [];
-    for (const key of source.projection) {
-        if (key === null || typeof key === "object")
-            return undefined;
-        path.push(String(key));
-    }
-    return semanticSlotAtPath(evaluateSemanticExpression(source.node, state, capturePoint), path);
-};