fix(javascript): preserve runtime path bytes and Electron ownership (#4941)

* fix(javascript): preserve literal percent runtime paths

* fix(javascript): ignore resolve prefixes before the final anchor

* fix(electron): retain application roots for loadFile declarations

* fix(electron): resolve loadFile from enclosing application package

* fix(electron): retain outer application root across package scopes

* fix(electron): derive application ownership from inventoried packages

* fix(electron): retain resolved package entrypoint ownership

* fix(electron): preserve competing application ownership

* fix(electron): retain invalid and omitted runtime ownership

* fix(electron): preserve omitted module ownership and runtime paths

* fix(electron): preserve proven roots before confining page paths

* fix(electron): retain possible owners behind missing imports

* fix(electron): distinguish absent imports and owned page candidates

* fix(electron): keep unavailable JSON out of owner gaps

* fix(electron): retain exact loader formats and default entry status

* fix(electron): retain unavailable entrypoint ownership candidates

* test(ghidra): preserve Windows Node probe prerequisites

* test(ghidra): assert cancellation during profile shutdown

* fix(electron): separate examined imports from frontend ownership

* fix(electron): retain unavailable directory entrypoint owners

* test(jeb): retain Linux ownership prerequisite in isolation

* fix(javascript): retain unchecked loader ownership and literal main paths

* fix(javascript): preserve runtime paths and call-site module aliases

* fix(javascript): bound module alias traversal and preserve projections

* fix(javascript): retain host module and nested artifact path boundaries

* fix(javascript): preserve ESM and archive module loader provenance

* test(javascript): distinguish unmapped containers from missing exports

* fix: retain default module aliases and Electron builtin imports

* fix: preserve host file URL and inward ASAR ownership

* fix: preserve CommonJS file URL classification in CI fixtures

* fix: retain bound module loaders and Windows entrypoint uncertainty

* fix: retain ASAR uncertainty and invalidate changed Electron app roots

* fix(javascript): retain ownership uncertainty across loader boundaries

* fix(javascript): preserve loader sources and bound alias queries

* fix(javascript): retain destructured loader sources

* fix(javascript): preserve loader uncertainty at resolution boundaries

* fix(javascript): preserve callable and package launch ownership

* fix(javascript): preserve captured values across member reads

* test(process): assert tagged filesystem cancellation failures

* fix(javascript): preserve inventory bases and invocation read timing

* fix(javascript): preserve ownership across indirect and unread loads

* test(javascript): order fixture directory creation on Windows

* test(javascript): share ordered filesystem fixture writer

* fix(javascript): unify loader provenance and package validation

* fix(javascript): preserve captured Node require loader values

* fix(javascript): preserve loader invocation authority

* fix(javascript): verify generic loader invocation authority

* fix(javascript): preserve conditional loader method alternatives

* fix(javascript): require proven factories for source association

* fix(javascript): honor replaced Electron app path setters

* fix(javascript): prove path and assignment source ownership

* fix(javascript): retain native delegate eligibility through shared writes

* fix(process): settle stale baseline errors after confirmed absence

* fix(javascript): preserve assignment and path boundary evidence

* fix(javascript): prove source-directory resolve anchors

* fix: preserve application path provenance and portable schemas

* fix(javascript): retain CommonJS exported setter effects

* fix: isolate Linux identity observations and retain native module exports

* fix(javascript): preserve published app and helper provenance

* fix(javascript): normalize typed stores and native path fixtures

src/domain/javascript/javascriptSemanticAmbientWrites.ts

@@ -22,6 +22,11 @@ import {
   type SemanticIterationSource,
 } from "./javascriptSemanticIterationSources.js";
 import { createSemanticReturnedReferences } from "./javascriptSemanticReturnedReferences.js";
+import {
+  semanticCopiedReferencePath,
+  semanticReferenceIterationUnknown,
+  semanticReferenceSourcesInactive,
+} from "./javascriptSemanticReferenceSources.js";
 
 const GLOBAL_OBJECT_NAMES = ["globalThis", "global", "window", "self"];
 
@@ -236,30 +241,44 @@ export const createAmbientPathResolver = (
         }
         const binding = resolveSemanticBindingState(state, root, root.name);
         if (binding === undefined) continue;
-        const stable = semanticStableInitializer(binding, state);
+        const stable = possibleWrites
+          ? undefined
+          : semanticStableInitializer(binding, state);
         const readAt = current.readsAtSelf ? root : capture;
-        const initializers = possibleWrites
-          ? readAt === undefined
-            ? binding.initializers
+        const selected =
+          !possibleWrites || readAt === undefined
+            ? binding
             : semanticBindingAtRead(binding, readAt, state.parentsByNode)
-                .binding.initializers
+                .binding;
+        const initializers = possibleWrites
+          ? [...selected.initializers, ...selected.referenceInitializers]
           : stable === undefined
             ? []
             : [stable];
-        for (const initializer of initializers)
+        for (const initializer of initializers) {
+          if (semanticReferenceSourcesInactive(initializer, state)) continue;
+          // Pattern assignments share the source selection owner with member
+          // effects: copying a container preserves its children, not itself.
+          const path = semanticCopiedReferencePath(
+            initializer,
+            suffix ?? [null],
+            escapedContents ? "escape" : "identity",
+          );
+          if (path === null) continue;
           pending.push({
             node: initializer.node,
             readsAtSelf: true,
             suffix:
-              suffix === undefined
+              suffix === undefined ||
+              semanticReferenceIterationUnknown(initializer, state)
                 ? undefined
-                : [
-                    ...initializer.projection.map((key) =>
-                      key === null ? null : String(key),
-                    ),
-                    ...suffix,
-                  ],
+                : path.map((key) =>
+                    key === null || typeof key === "object"
+                      ? null
+                      : String(key),
+                  ),
           });
+        }
         continue;
       }
       if (
@@ -332,7 +351,8 @@ export const createAmbientPathResolver = (
         if (t.isObjectExpression(root)) {
           for (const property of root.properties)
             if (t.isSpreadElement(property))
-              continueWith(property.argument, []);
+              // A fresh copy exposes selected children, not its source container.
+              continueWith(property.argument, [null]);
             else if (
               t.isObjectProperty(property) &&
               t.isExpression(property.value)
@@ -433,6 +453,7 @@ export function* indexJavaScriptAmbientWritesSteps(
   program: t.Program,
   state: JavaScriptSemanticAnalysisState,
   observeOpaqueInvocation?: (node: t.Node) => void,
+  observeWriteSite?: (node: t.Node) => void,
 ): Generator<void> {
   const ambientReads = createAmbientPathResolver(state, false);
   const browserReceiverMethods = new Set<string>();
@@ -482,6 +503,7 @@ export function* indexJavaScriptAmbientWritesSteps(
     program,
     (root, kind, writeSite) => {
       if (kind === "opaque-call") return [];
+      observeWriteSite?.(writeSite);
       // Reassigning a local alias changes the binding, not the referenced object.
       if (kind === "binding")
         return t.isIdentifier(root) &&
@@ -626,8 +648,11 @@ export function* indexJavaScriptAmbientWritesSteps(
   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]);
+      if (!(browserReceiver && path.length === 1 && path[0] === "global")) {
+        const escaped = [...path, null];
+        state.ambientEscapes.retain(escaped);
+        state.ambientEscapeEffects.push({ path: escaped, node });
+      }
   // A function may call a browser method replaced later in source order.
   if (
     [...browserReceiverMethods].some((method) =>