fix(javascript): prove namespace interop before attributing Electron APIs (#1857)

* fix(javascript): prove Electron module namespace conversion

* refactor(javascript): share AST child field metadata

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>

* fix(javascript): retain destructured intrinsic writes

Share one pattern-target walker across lexical definitions, member mutation
tracking and Electron identity writes. Keep overwritten globals unresolved
without treating property keys or shadowed locals as global replacements.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>

* fix(javascript): preserve intrinsic projections and fresh target identity

Resolve known mutators through static binding projections and prove stable
identifier chains to fresh literals before widening unknown mutation targets.
Keep reassigned, uninitialized and member-projected targets conservative.
Cover both review regressions through source tests and inert CLI/MCP fixtures.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>

* fix(javascript): retain fresh function and class target identity

Recognize stable local function, undecorated class and RegExp targets before
widening intrinsic mutations. Keep decorated classes opaque because their
binding value can be replaced, and preserve class-initialization writes.
Cover fresh targets and replacement decorators in inert CLI/MCP fixtures.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>

* fix(javascript): preserve intrinsic alias capture timing

Validate each alias read after initialization and retain the original function capture across copies. Share declaration initializer facts with RPC and Electron analysis, including class declarations used for fresh-target identity. Accept single-statement control blocks while keeping lexical roles and added operations checked. Cover the capture regressions through inert source and public CLI/MCP workflows.

* fix(javascript): respect hoisted fresh function declarations

Function declarations provide fresh targets before their textual position. Retain initialization-order checks for variable and class values, including aliases. Cover the reviewed regression with source controls and the public CLI/MCP fixture.

* fix(javascript): preserve proven interop result projections

* fix(javascript): retain stable declarations and bound intrinsic writes

Keep repeated variable declarations with one unconditional initializer while
rejecting assignments, conditional initialization and multiple values.
Normalize known intrinsic calls, aliases and bound argument prefixes at the
semantic owner, retaining opaque targets without tainting unused bindings or
fresh local objects. Cover both regressions through source and CLI/MCP tests.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>

* fix(javascript): retain bound intrinsic mutation effects

* fix(javascript): preserve bound receivers for intrinsic invocation

* fix(javascript): prove generic binding and invocation effects

* fix(javascript): retain Reflect set receiver effects

---------

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
Co-authored-by: Kaoru0822 <208281322+kaoru0822-kitauji@users.noreply.github.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>

src/domain/javascript/javascriptElectronMemberWrites.ts

@@ -2,10 +2,9 @@ import * as t from "@babel/types";
 
 import {
   semanticStaticPropertyKey,
-  semanticMemberWriteTargets,
+  semanticWriteTargets,
   unwrapJavaScriptExpression,
 } from "./javascriptAstValues.js";
-import { SemanticPropertyPathCoverage } from "./javascriptSemanticPropertyPaths.js";
 import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";
 
 /** Match Electron's supported module entry points. */
@@ -24,7 +23,7 @@ export const electronExportPath = (
 
 /** Static identity recovery cannot establish the absence of Electron usage. */
 export const ELECTRON_IDENTITY_LIMITATION =
-  "Electron API identity follows proven lexical module aliases, including results of namespace interop helpers (__toESM, __importStar, _interopRequireWildcard) recognized by name and a single program-scope function definition; helper bodies are not evaluated. Other reassigned bindings, dynamic selections, and visibly overwritten namespace members are unresolved; missing findings do not establish absence. Arbitrary call side effects and runtime registration are not evaluated.";
+  "Electron API identity follows proven lexical module aliases and structurally verified module-namespace interop. Other reassignments, dynamic selections, and visibly overwritten namespace members are unresolved; missing findings do not establish absence. Arbitrary call side effects and runtime registration are not evaluated.";
 
 /** Preserve exact property segments instead of flattening literal dotted keys. */
 export const electronMemberPath = (
@@ -42,14 +41,98 @@ export const electronMemberPath = (
   return { root, members: members.toReversed() };
 };
 
-/** Index visible writes through proven Electron aliases, without executing them. */
-export function* collectElectronMemberWritesSteps(
+/** A known intrinsic callable and its examined positional arguments. */
+export interface JavaScriptIntrinsicInvocation {
+  readonly kind: "known" | "opaque";
+  /** The original bound receiver; rebinding cannot replace it. */
+  readonly receiver?: t.Node;
+  readonly path: readonly string[];
+  readonly arguments:
+    | readonly t.CallExpression["arguments"][number][]
+    | undefined;
+}
+
+/** Index member and binding writes through caller-proven lexical identities. */
+export function* collectJavaScriptIdentityWritesSteps(
   program: t.Program,
-  origin: (root: t.Node) => readonly string[] | undefined,
-): Generator<void, SemanticPropertyPathCoverage> {
-  const writes = new SemanticPropertyPathCoverage();
+  origin: (
+    root: t.Node,
+    kind: "binding" | "member" | "opaque-call",
+  ) => readonly string[] | undefined,
+  intrinsicInvocation: (
+    node: t.CallExpression | t.OptionalCallExpression,
+  ) => JavaScriptIntrinsicInvocation | undefined,
+  staticString: (node: t.Node | undefined) => string | undefined,
+  freshObject: (node: t.Node) => boolean,
+  retain: (node: t.Node, path: readonly (string | null)[]) => void,
+): Generator<void> {
+  const objectMutators = new Set([
+    "defineProperty",
+    "defineProperties",
+    "assign",
+    "setPrototypeOf",
+  ]);
+  const reflectMutators = new Set([
+    "set",
+    "deleteProperty",
+    "defineProperty",
+    "setPrototypeOf",
+  ]);
+  const keyedMutators = new Set(["set", "deleteProperty", "defineProperty"]);
   yield* traverseJavaScriptAstSteps(program, {
     enter: (node) => {
+      if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+        const invocation = intrinsicInvocation(node);
+        if (invocation?.kind === "opaque") {
+          const scope = origin(node, "opaque-call");
+          if (scope !== undefined) retain(node, scope);
+          return;
+        }
+        const callee = invocation?.path;
+        const arguments_ = invocation?.arguments;
+        const method = callee?.at(-1);
+        const owner = callee?.length === 3 ? callee[1] : undefined;
+        if (
+          (owner === "Object" && objectMutators.has(method ?? "")) ||
+          (owner === "Reflect" && reflectMutators.has(method ?? ""))
+        ) {
+          // Reflect.set can write through its explicit receiver as well as
+          // dispatching through its target. Both identities need examination.
+          const targets =
+            owner === "Reflect" &&
+            method === "set" &&
+            arguments_ !== undefined &&
+            (arguments_.length >= 4 || arguments_.some(t.isSpreadElement))
+              ? [
+                  arguments_[0],
+                  arguments_.some(t.isSpreadElement)
+                    ? undefined
+                    : arguments_[3],
+                ]
+              : [arguments_?.[0]];
+          for (const target of targets) {
+            // A known mutator with an opaque argument list can overwrite any
+            // captured intrinsic. Do not turn an unexamined target into proof.
+            if (target === undefined || t.isSpreadElement(target)) {
+              const scope = origin(node, "opaque-call");
+              if (scope !== undefined) retain(node, scope);
+            }
+            if (t.isNode(target) && !t.isSpreadElement(target)) {
+              const { root, members } = electronMemberPath(target);
+              const exported = origin(root, "member");
+              if (exported !== undefined) {
+                const key = keyedMutators.has(method ?? "")
+                  ? [staticString(arguments_?.[1]) ?? null]
+                  : [];
+                retain(node, [...exported, ...members, ...key]);
+              } else if (!freshObject(target)) {
+                const scope = origin(node, "opaque-call");
+                if (scope !== undefined) retain(node, scope);
+              }
+            }
+          }
+        }
+      }
       const target = t.isAssignmentExpression(node)
         ? node.left
         : t.isUpdateExpression(node)
@@ -60,12 +143,16 @@ export function* collectElectronMemberWritesSteps(
               ? node.left
               : undefined;
       if (target === undefined) return;
-      for (const member of semanticMemberWriteTargets(target)) {
-        const { root, members } = electronMemberPath(member);
-        const exported = origin(root);
-        if (exported !== undefined) writes.retain([...exported, ...members]);
+      for (const leaf of semanticWriteTargets(target)) {
+        if (t.isIdentifier(leaf)) {
+          const exported = origin(leaf, "binding");
+          if (exported !== undefined) retain(node, exported);
+          continue;
+        }
+        const { root, members } = electronMemberPath(leaf);
+        const exported = origin(root, "member");
+        if (exported !== undefined) retain(node, [...exported, ...members]);
       }
     },
   });
-  return writes;
 }