rea-agents 6.5.0 → 6.7.0

package/dist/domain/javascript/javascriptRuntimeLoadState.js

@@ -15,15 +15,18 @@ const classifyLayer = (layer, runtimeEntities, matches, options) => {
     const nodes = layer.graph.nodes.filter(isLoadStateNode);
     const direct = new Map();
     const ambiguous = new Set();
+    const incomplete = new Set();
     for (const match of matches)
         if (match.status === "matched" &&
             match.static_layer_id === layer.layerId &&
             match.static_node_id !== null)
             append(direct, match.static_node_id, match.runtime_node_id);
-        else if (match.status === "ambiguous")
+        else if (match.status === "ambiguous" || match.status === "unknown") {
+            const uncertain = match.status === "ambiguous" ? ambiguous : incomplete;
             for (const candidate of match.candidate_static_nodes)
                 if (candidate.static_layer_id === layer.layerId)
-                    ambiguous.add(candidate.static_node_id);
+                    uncertain.add(candidate.static_node_id);
+        }
     const resident = residentNodes(layer, new Set(direct.keys()));
     const runtimeScope = createStaticRuntimeScope(layer, runtimeEntities);
     const scopedEntities = runtimeEntities.filter((entity) => mappedRuntimePaths(layer, entity).length > 0);
@@ -45,11 +48,13 @@ const classifyLayer = (layer, runtimeEntities, matches, options) => {
                 runtimeNodeIds: [],
                 reason: "containing-asset-was-loaded",
             });
-        if (ambiguous.has(node.node_id))
+        if (incomplete.has(node.node_id) || ambiguous.has(node.node_id))
             return state(layer, node, {
                 status: "unknown",
                 runtimeNodeIds: [],
-                reason: "ambiguous-runtime-candidate",
+                reason: incomplete.has(node.node_id)
+                    ? "static-or-runtime-coverage-incomplete"
+                    : "ambiguous-runtime-candidate",
             });
         const nodeWithinScope = staticNodeWithinRuntimeScope(node, runtimeScope);
         if (layerComplete && nodeWithinScope)

package/dist/domain/javascript/javascriptRuntimeReconciliationCaptureParsing.js

@@ -142,8 +142,10 @@ const normalizeV8Inspection = (result) => ({
         })),
     },
     workers: [],
+    // Route exclusions as CdpCaptureCompleteness does: denied locations are
+    // policy filtered, while invalid protocol values leave scripts unavailable.
     completeness: classifyBrowserCompleteness({
-        policyFilteredSections: new Set(excludedV8Scripts(result) > 0 ? ["scripts"] : []),
+        policyFilteredSections: new Set(result.scripts.excluded.unsupported_location > 0 ? ["scripts"] : []),
         attachLimitedSections: new Set([
             "frames",
             "scripts",
@@ -151,16 +153,15 @@ const normalizeV8Inspection = (result) => ({
             "workers",
         ]),
         truncatedSections: new Set(result.capture.truncated ? ["scripts"] : []),
-        unavailableSections: new Set(["frames", "script_sources", "workers"]),
-        excluded: excludedV8Scripts(result) === 0
-            ? []
-            : [
-                {
-                    section: "scripts",
-                    reason: "out_of_target_scope",
-                    count: excludedV8Scripts(result),
-                },
-            ],
+        unavailableSections: new Set([
+            "frames",
+            "script_sources",
+            "workers",
+            ...(result.scripts.excluded.invalid_protocol_value > 0
+                ? ["scripts"]
+                : []),
+        ]),
+        excluded: v8ScriptExclusions(result),
         droppedEvents: {
             scripts: result.capture.events_dropped,
             network_requests: 0,
@@ -181,7 +182,29 @@ const runtimeLocation = (location) => {
         return { url: location.sanitized_url };
     return { url: location.specifier };
 };
-const excludedV8Scripts = (result) => Object.values(result.scripts.excluded).reduce((total, count) => total + count, 0);
+const v8ScriptExclusions = (result) => {
+    const { unsupported_location, invalid_protocol_value } = result.scripts.excluded;
+    return [
+        ...(unsupported_location > 0
+            ? [
+                {
+                    section: "scripts",
+                    reason: "out_of_target_scope",
+                    count: unsupported_location,
+                },
+            ]
+            : []),
+        ...(invalid_protocol_value > 0
+            ? [
+                {
+                    section: "scripts",
+                    reason: "invalid_protocol_value",
+                    count: invalid_protocol_value,
+                },
+            ]
+            : []),
+    ];
+};
 const assertRuntimeParameters = (evidence, expected, path) => {
     const common = {
         target_id: z.string().trim().min(1),

package/dist/domain/javascript/javascriptRuntimeReconciliationMatching.js

@@ -23,51 +23,8 @@ const reconcileEntity = (entity, index, layers) => {
             candidates: [],
         });
     const locations = candidatesWithLocation(entity, index, layers);
-    if (entity.sourceSha256 !== null) {
-        const content = index.byCategoryDigest.get(categoryDigestKey(entity.staticKind, entity.sourceSha256)) ?? [];
-        const locatedKeys = new Set(locations.map(({ candidate }) => candidateKey(candidate)));
-        const combined = content.filter((candidate) => locatedKeys.has(candidateKey(candidate)));
-        const combinedCandidate = combined.at(0);
-        if (combined.length === 1 && combinedCandidate !== undefined)
-            return matched(entity, combinedCandidate, {
-                basis: "content-and-location",
-                confidence: "high",
-                reason: "content-and-location-match",
-            });
-        const contentCandidate = content.at(0);
-        if (content.length === 1 && contentCandidate !== undefined) {
-            const candidate = contentCandidate;
-            const digestBasis = candidate.digests.find(({ sha256 }) => sha256 === entity.sourceSha256)?.basis;
-            return matched(entity, candidate, {
-                basis: digestBasis ?? "content-sha256",
-                confidence: "high",
-                reason: "unique-content-match",
-            });
-        }
-        if (content.length > 1)
-            return unresolved(entity, {
-                status: "ambiguous",
-                basis: "none",
-                confidence: "unknown",
-                reason: "ambiguous-static-candidates",
-                candidates: content,
-            });
-        if (locations.length > 0)
-            return unresolved(entity, {
-                status: "unmatched",
-                basis: strongestLocationBasis(locations),
-                confidence: "high",
-                reason: "captured-content-disagrees-with-static-location",
-                candidates: locations.map(({ candidate }) => candidate),
-            });
-        return unresolved(entity, {
-            status: "unmatched",
-            basis: "none",
-            confidence: "high",
-            reason: "no-static-content-match",
-            candidates: [],
-        });
-    }
+    if (entity.sourceSha256 !== null)
+        return reconcileCapturedSource(entity, entity.sourceSha256, locations, index);
     const location = locations.at(0);
     if (locations.length === 1 && location !== undefined) {
         const located = location;
@@ -96,6 +53,54 @@ const reconcileEntity = (entity, index, layers) => {
         candidates: [],
     });
 };
+const reconcileCapturedSource = (entity, sourceSha256, locations, index) => {
+    // A known mapped candidate owns the comparison. Unrelated equal bytes cannot
+    // repair a disagreement or establish the content of a candidate without a digest.
+    const content = locations.length > 0
+        ? locations
+            .map(({ candidate }) => candidate)
+            .filter(({ digests }) => digests.some(({ sha256 }) => sha256 === sourceSha256))
+        : (index.byCategoryDigest.get(categoryDigestKey(entity.staticKind, sourceSha256)) ?? []);
+    const candidate = content.at(0);
+    if (content.length === 1 && candidate !== undefined)
+        return matched(entity, candidate, {
+            basis: locations.length > 0
+                ? "content-and-location"
+                : (candidate.digests.find(({ sha256 }) => sha256 === sourceSha256)
+                    ?.basis ?? "content-sha256"),
+            confidence: "high",
+            reason: locations.length > 0
+                ? "content-and-location-match"
+                : "unique-content-match",
+        });
+    if (content.length > 1)
+        return unresolved(entity, {
+            status: "ambiguous",
+            basis: locations.length > 0 ? "content-and-location" : "none",
+            confidence: "unknown",
+            reason: "ambiguous-static-candidates",
+            candidates: content,
+        });
+    if (locations.length > 0) {
+        const digestUnavailable = locations.some(({ candidate: { digests } }) => digests.length === 0);
+        return unresolved(entity, {
+            status: digestUnavailable ? "unknown" : "unmatched",
+            basis: strongestLocationBasis(locations),
+            confidence: digestUnavailable ? "unknown" : "high",
+            reason: digestUnavailable
+                ? "static-or-runtime-coverage-incomplete"
+                : "captured-content-disagrees-with-static-location",
+            candidates: locations.map(({ candidate: located }) => located),
+        });
+    }
+    return unresolved(entity, {
+        status: "unmatched",
+        basis: "none",
+        confidence: "high",
+        reason: "no-static-content-match",
+        candidates: [],
+    });
+};
 const candidatesWithLocation = (entity, index, layers) => {
     const located = new Map();
     for (const layer of layers)

package/dist/domain/javascript/javascriptSemanticAmbientWrites.js

@@ -4,7 +4,9 @@ import { collectJavaScriptIdentityWritesSteps, electronMemberPath, } from "./jav
 import { createSemanticModuleInterop } from "./javascriptModuleInterop.js";
 import { isUnshadowedGlobal, resolveSemanticBindingState, semanticStableInitializer, } from "./javascriptSemanticState.js";
 import { isImportMetaUrl } from "./javascriptStaticAnalysisHelpers.js";
-import { semanticMutationInitializers } from "./javascriptSemanticMutationInitializers.js";
+import { semanticBindingAtRead } from "./javascriptSemanticMutationInitializers.js";
+import { semanticIterationSources, } from "./javascriptSemanticIterationSources.js";
+import { createSemanticReturnedReferences } from "./javascriptSemanticReturnedReferences.js";
 const GLOBAL_OBJECT_NAMES = ["globalThis", "global", "window", "self"];
 const globalObjectName = (node, state) => GLOBAL_OBJECT_NAMES.find((name) => isUnshadowedGlobal(node, state, name));
 /** Global self references retain object identity, rather than adding a property. */
@@ -16,21 +18,25 @@ const canonicalAmbientPath = (path) => {
         firstProperty += 1;
     return ["global", ...path.slice(firstProperty)];
 };
+const joinAmbientProjection = (left, right) => left === undefined || right === undefined || left.length !== right.length
+    ? undefined
+    : left.map((key, index) => (key === right[index] ? key : null));
 /**
  * Follow local object identities without equating shallow copies with their
- * sources. Write lookup retains every visible initializer: reassigning an alias
- * later cannot erase a possible earlier mutation. Intrinsic reads stay strict.
+ * sources. Writes select aliases at their capture; uncertain execution order
+ * retains possible initializers. Intrinsic reads stay strict.
  */
-const createAmbientPathResolver = (state, possibleWrites) => {
+export const createAmbientPathResolver = (state, possibleWrites, facts) => {
     const cached = new WeakMap();
-    return (node, capture) => {
+    const returnedReferences = createSemanticReturnedReferences(state);
+    return (node, capture, escapedContents = false, projection = [], localIdentity) => {
         const prior = possibleWrites ? undefined : cached.get(node);
         if (prior !== undefined)
             return prior;
         const result = new Map();
         // The caller's write site selects initializers for the written target.
         // Reads reached through an initializer occur at their own position.
-        const pending = [{ node, suffix: [] }];
+        const pending = [{ node, suffix: projection }];
         // Join projections at their producing expression, rather than enumerating
         // alias histories. Each key can only widen to a wildcard, and conflicting
         // depths widen to unknown, so diamonds and cycles have finite state.
@@ -39,6 +45,13 @@ const createAmbientPathResolver = (state, possibleWrites) => {
             let canonical = canonicalAmbientPath(path);
             for (;;) {
                 result.set(JSON.stringify(canonical), canonical);
+                if (possibleWrites &&
+                    canonical[0] === "global" &&
+                    canonical[2] === "prototype" &&
+                    canonical[3] === "constructor") {
+                    canonical = ["global", canonical[1] ?? null, ...canonical.slice(4)];
+                    continue;
+                }
                 // An unknown key may select a global self reference as well as a
                 // distinct property. Retain both possible object identities for writes.
                 if (!possibleWrites ||
@@ -82,6 +95,49 @@ const createAmbientPathResolver = (state, possibleWrites) => {
                 suffix: path,
                 ...(current.readsAtSelf && { readsAtSelf: true }),
             });
+            const continueReturned = (callee, path) => {
+                for (const source of returnedReferences(callee))
+                    continueWith(source.node, path === undefined
+                        ? undefined
+                        : [
+                            ...source.projection.map((key) => key === null || typeof key === "object"
+                                ? null
+                                : String(key)),
+                            ...path,
+                        ]);
+            };
+            if (!t.isIdentifier(root) && facts?.freshObject(root)) {
+                localIdentity?.(root, suffix);
+                for (const [source, path] of facts?.stores.get(root) ?? []) {
+                    const selected = suffix === undefined ||
+                        path === undefined ||
+                        path.every((key, index) => index >= suffix.length ||
+                            key === null ||
+                            suffix[index] === null ||
+                            key === suffix[index]);
+                    if (!selected ||
+                        (suffix !== undefined &&
+                            path !== undefined &&
+                            suffix.length < path.length &&
+                            !escapedContents))
+                        continue;
+                    const remaining = suffix === undefined || path === undefined
+                        ? undefined
+                        : suffix.slice(path.length);
+                    pending.push({
+                        node: source.node,
+                        readsAtSelf: true,
+                        suffix: remaining === undefined
+                            ? undefined
+                            : [
+                                ...source.projection.map((key) => key === null || typeof key === "object"
+                                    ? null
+                                    : String(key)),
+                                ...remaining,
+                            ],
+                    });
+                }
+            }
             if (t.isMetaProperty(root) &&
                 root.meta.name === "import" &&
                 root.property.name === "meta") {
@@ -89,6 +145,12 @@ const createAmbientPathResolver = (state, possibleWrites) => {
                 continue;
             }
             if (t.isIdentifier(root)) {
+                // The wrapper module object is distinct from globalThis.module. Keep
+                // its identity through the same alias/projection owner used for writes.
+                if (isUnshadowedGlobal(root, state, "module")) {
+                    retain(["commonjs-module", ...(suffix ?? [])]);
+                    continue;
+                }
                 if (globalObjectName(root, state) !== undefined) {
                     retain(["global", ...(suffix ?? [])]);
                     continue;
@@ -105,8 +167,8 @@ const createAmbientPathResolver = (state, possibleWrites) => {
                 const initializers = possibleWrites
                     ? readAt === undefined
                         ? binding.initializers
-                        : semanticMutationInitializers(binding, readAt, state.parentsByNode)
-                            .initializers
+                        : semanticBindingAtRead(binding, readAt, state.parentsByNode)
+                            .binding.initializers
                     : stable === undefined
                         ? []
                         : [stable];
@@ -123,6 +185,34 @@ const createAmbientPathResolver = (state, possibleWrites) => {
                     });
                 continue;
             }
+            if (possibleWrites &&
+                t.isNewExpression(root) &&
+                (suffix?.[0] === "__proto__" || suffix?.[0] === "constructor")) {
+                continueWith(root.callee, suffix[0] === "__proto__"
+                    ? ["prototype", ...suffix.slice(1)]
+                    : suffix.slice(1));
+                continue;
+            }
+            const prototypeTarget = possibleWrites
+                ? facts?.prototypeTarget(root)
+                : undefined;
+            if (prototypeTarget !== undefined) {
+                continueWith(prototypeTarget, suffix === undefined ? undefined : ["__proto__", ...suffix]);
+                continue;
+            }
+            if (possibleWrites &&
+                (t.isCallExpression(root) ||
+                    t.isOptionalCallExpression(root) ||
+                    t.isNewExpression(root) ||
+                    t.isTaggedTemplateExpression(root) ||
+                    (escapedContents && (t.isFunction(root) || t.isClass(root))))) {
+                continueReturned(t.isFunction(root) || t.isClass(root)
+                    ? root
+                    : t.isTaggedTemplateExpression(root)
+                        ? root.tag
+                        : root.callee, suffix);
+                continue;
+            }
             if (possibleWrites && t.isConditionalExpression(root)) {
                 continueWith(root.consequent);
                 continueWith(root.alternate);
@@ -133,7 +223,41 @@ const createAmbientPathResolver = (state, possibleWrites) => {
                 continueWith(root.right);
                 continue;
             }
+            if (possibleWrites && t.isSequenceExpression(root)) {
+                const value = root.expressions.at(-1);
+                if (value !== undefined)
+                    continueWith(value);
+                continue;
+            }
+            if (possibleWrites &&
+                t.isAssignmentExpression(root) &&
+                root.operator === "=") {
+                continueWith(root.right);
+                continue;
+            }
             const key = suffix?.[0];
+            // Container escapes reuse the finite worklist, including alias cycles.
+            if (escapedContents && suffix?.length === 0) {
+                if (t.isObjectExpression(root)) {
+                    for (const property of root.properties)
+                        if (t.isSpreadElement(property))
+                            continueWith(property.argument, []);
+                        else if (t.isObjectProperty(property) &&
+                            t.isExpression(property.value))
+                            continueWith(property.value, []);
+                        else if (t.isObjectMethod(property) && property.kind === "get")
+                            continueReturned(property, []);
+                    continue;
+                }
+                if (t.isArrayExpression(root)) {
+                    for (const element of root.elements)
+                        if (t.isSpreadElement(element))
+                            continueWith(element.argument, []);
+                        else if (t.isExpression(element))
+                            continueWith(element, []);
+                    continue;
+                }
+            }
             if (suffix !== undefined && key === undefined)
                 continue;
             if (t.isObjectExpression(root)) {
@@ -141,14 +265,18 @@ const createAmbientPathResolver = (state, possibleWrites) => {
                     for (const property of root.properties) {
                         if (t.isSpreadElement(property))
                             continueWith(property.argument);
-                        else if (t.isObjectProperty(property) &&
-                            t.isExpression(property.value)) {
+                        else if ((t.isObjectProperty(property) &&
+                            t.isExpression(property.value)) ||
+                            (t.isObjectMethod(property) && property.kind === "get")) {
                             const ownKey = semanticStaticPropertyKey(property.key, property.computed);
                             if (suffix === undefined ||
                                 key === null ||
                                 ownKey === null ||
                                 ownKey === key)
-                                continueWith(property.value, suffix?.slice(1));
+                                if (t.isObjectMethod(property))
+                                    continueReturned(property, suffix?.slice(1));
+                                else if (t.isExpression(property.value))
+                                    continueWith(property.value, suffix?.slice(1));
                         }
                     }
                 }
@@ -202,9 +330,15 @@ const createAmbientPathResolver = (state, possibleWrites) => {
  * literal argument spreads. Runtime reachability and arbitrary call effects
  * remain unevaluated; a visible possible write is sufficient.
  */
-export function* indexJavaScriptAmbientWritesSteps(program, state) {
+export function* indexJavaScriptAmbientWritesSteps(program, state, observeOpaqueInvocation) {
     const ambientReads = createAmbientPathResolver(state, false);
-    const ambientWrites = createAmbientPathResolver(state, true);
+    const browserReceiverMethods = new Set();
+    const storedSites = new WeakSet();
+    const storedReferences = [];
+    const writes = [];
+    const targets = [];
+    const escapes = [];
+    const stores = new WeakMap();
     const interop = createSemanticModuleInterop(state, {
         intrinsicPath: (node) => {
             const [path] = ambientReads(node);
@@ -213,6 +347,24 @@ export function* indexJavaScriptAmbientWritesSteps(program, state) {
                 : undefined;
         },
     });
+    const ambientWrites = createAmbientPathResolver(state, true, {
+        stores,
+        freshObject: interop.isFreshObject,
+        prototypeTarget: (node) => {
+            if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))
+                return undefined;
+            const invocation = interop.intrinsicInvocation(node);
+            if (invocation?.kind !== "known" ||
+                invocation.path.length !== 3 ||
+                !["Object", "Reflect"].includes(invocation.path[1] ?? "") ||
+                invocation.path[2] !== "getPrototypeOf")
+                return undefined;
+            const target = invocation.arguments?.[0];
+            return t.isNode(target) && !t.isSpreadElement(target)
+                ? target
+                : undefined;
+        },
+    });
     yield* collectJavaScriptIdentityWritesSteps(program, (root, kind, writeSite) => {
         if (kind === "opaque-call")
             return [];
@@ -222,29 +374,137 @@ export function* indexJavaScriptAmbientWritesSteps(program, state) {
                 isUnshadowedGlobal(root, state, root.name)
                 ? [["global", root.name]]
                 : [];
-        return ambientWrites(root, writeSite);
+        if (!storedSites.has(writeSite)) {
+            storedSites.add(writeSite);
+            for (const source of semanticIterationSources(writeSite, state.parentsByNode.get(writeSite) ?? null)) {
+                if (source.kind === "reference-store")
+                    storedReferences.push(source);
+            }
+        }
+        // Resolve identities after the traversal has collected every local store.
+        const id = targets.push({ node: root, capture: writeSite }) - 1;
+        return [["pending-target", String(id)]];
     }, interop.intrinsicInvocation, interop.staticString, interop.isFreshObject, (node, path) => {
-        state.ambientWrites.retain(path);
-        state.ambientWriteEffects.push({ path, node });
+        writes.push({ node, path });
+    }, (node, invocation) => {
+        observeOpaqueInvocation?.(node);
+        // Escaping objects can change contents without replacing their identity.
+        const retainEscape = (target, browserReceiver = false) => {
+            escapes.push({ target, node, browserReceiver });
+        };
+        for (const argument of t.isTaggedTemplateExpression(node)
+            ? node.quasi.expressions
+            : node.arguments)
+            if (t.isNode(argument))
+                retainEscape(t.isSpreadElement(argument) ? argument.argument : argument);
+        const callee = unwrapJavaScriptExpression(t.isTaggedTemplateExpression(node) ? node.tag : node.callee).node;
+        const browserMethod = invocation?.kind === "known" &&
+            invocation.path.length === 2 &&
+            ["open", "fetch"].includes(invocation.path[1] ?? "")
+            ? invocation.path[1]
+            : undefined;
+        if (!t.isNewExpression(node) &&
+            (t.isMemberExpression(callee) ||
+                t.isOptionalMemberExpression(callee)) &&
+            !(invocation?.kind === "known" &&
+                ["Object", "Reflect"].includes(invocation.path[1] ?? ""))) {
+            if (browserMethod !== undefined)
+                browserReceiverMethods.add(browserMethod);
+            retainEscape(callee.object, browserMethod !== undefined);
+        }
     });
+    const pendingStores = new Set(storedReferences);
+    const dependents = new WeakMap();
+    while (pendingStores.size > 0) {
+        const source = pendingStores.values().next().value;
+        if (source === undefined)
+            break;
+        pendingStores.delete(source);
+        if (source.target === undefined)
+            continue;
+        const identities = new Map();
+        ambientWrites(source.target, source.mutation, false, [], (node, path) => {
+            const users = dependents.get(node) ?? new Set();
+            users.add(source);
+            dependents.set(node, users);
+            identities.set(node, identities.has(node)
+                ? joinAmbientProjection(identities.get(node), path)
+                : path);
+        });
+        // Publish only completed queries; each source/root projection can only widen.
+        for (const [node, path] of identities) {
+            const entries = stores.get(node) ??
+                new Map();
+            const previous = entries.get(source);
+            const joined = entries.has(source)
+                ? joinAmbientProjection(previous, path)
+                : path;
+            if (entries.has(source) &&
+                (previous === undefined ||
+                    (joined !== undefined &&
+                        previous.every((key, index) => key === joined[index]))))
+                continue;
+            entries.set(source, joined);
+            stores.set(node, entries);
+            for (const dependent of dependents.get(node) ?? [])
+                pendingStores.add(dependent);
+        }
+        yield;
+    }
+    for (const source of storedReferences) {
+        if (source.target === undefined)
+            continue;
+        let local = false;
+        const ambient = ambientWrites(source.target.object, source.mutation, false, [], () => {
+            local = true;
+        });
+        if (!local || ambient.length > 0)
+            escapes.push({
+                node: source.mutation,
+                target: source.node,
+                browserReceiver: false,
+                projection: source.projection.map((key) => key === null || typeof key === "object" ? null : String(key)),
+            });
+    }
+    for (const { node, path } of writes) {
+        const target = path[0] === "pending-target" ? targets[Number(path[1])] : undefined;
+        const paths = target === undefined
+            ? [path]
+            : ambientWrites(target.node, target.capture).map((identity) => [
+                ...identity,
+                ...path.slice(2),
+            ]);
+        for (const resolved of paths) {
+            state.ambientWrites.retain(resolved);
+            state.ambientWriteEffects.push({ path: resolved, node });
+        }
+    }
+    for (const { node, target, browserReceiver, projection } of escapes)
+        for (const path of ambientWrites(target, node, true, projection))
+            // Only proven browser APIs keep their global receiver from user code.
+            if (!(browserReceiver && path.length === 1 && path[0] === "global"))
+                state.ambientEscapes.retain([...path, null]);
+    // A function may call a browser method replaced later in source order.
+    if ([...browserReceiverMethods].some((method) => state.ambientWrites.covers(["global", method])))
+        state.ambientEscapes.retain(["global", null]);
 }
 /**
- * Recognize an ambient name or direct global-object property without a visible
+ * Recognize an ambient property path, optionally through a global object, without a visible
  * source-local overwrite. This is a syntax-local identity fact, not proof that
  * the runtime's globals have never been patched by other code.
  */
 export const isUnmodifiedGlobalReference = (callee, state, name) => {
-    const node = unwrapJavaScriptExpression(callee).node;
-    if (state.ambientWrites.covers(["global", name]))
+    const path = typeof name === "string" ? [name] : name;
+    if (state.ambientWrites.covers(["global", ...path]))
         return false;
-    if (isUnshadowedGlobal(node, state, name))
+    const { root, members } = electronMemberPath(callee);
+    const matches = (expected) => members.length === expected.length &&
+        members.every((key, index) => key === expected[index]);
+    if (isUnshadowedGlobal(root, state, path[0]) && matches(path.slice(1)))
         return true;
-    if (!t.isMemberExpression(node) ||
-        semanticStaticPropertyKey(node.property, node.computed) !== name)
-        return false;
-    const root = unwrapJavaScriptExpression(node.object).node;
     const namespace = globalObjectName(root, state);
     return (namespace !== undefined &&
+        matches(path) &&
         !state.ambientWrites.covers(["global", namespace]));
 };
 /** A module URL base is known only while its property has no visible write. */