Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

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

Ysopwnable9b3e59804db7
diff --git a/docs/javascript-artifact-reconstruction.md b/docs/javascript-artifact-reconstruction.md
index 82e2cef99..7442fc746 100644
--- a/docs/javascript-artifact-reconstruction.md
+++ b/docs/javascript-artifact-reconstruction.md
@@ -323,15 +323,42 @@ substitute version-dependent Electron defaults for omitted `webPreferences`.
Dynamic option objects, bridge keys, API objects, and IPC channel expressions
remain unknown and make coverage partial.
-Electron API identity follows proven lexical module aliases. Bundled CommonJS
-namespace imports are also followed through the interop helpers that bundlers
-and compilers emit (`__toESM`, `__importStar`, `_interopRequireWildcard`),
-including the `electron = __toESM(electron)` rewrap that Rolldown emits. This
-step is inferred: a helper is recognized by its emitted name and a single
-program-scope function definition, and its body is not evaluated, so a local
-function that reuses one of these names is trusted to pass the module through.
-Other reassigned bindings, dynamic selections, and visibly overwritten namespace
-members are unresolved.
+Electron API identity follows proven lexical module aliases. Namespace interop
+also preserves identity when the complete Rolldown helper operations, lexical
+roles, live getters, and captured intrinsic origins match, or when a stable
+helper simply returns its module parameter. Harmless single-statement control
+blocks preserve recognition; added operations still require proof. Literal
+member and destructuring projections are retained from proven results.
+Omitted or literal node-mode arguments preserve named exports; a module-valued
+default projection requires a truthy literal node mode. Computed or extra
+arguments remain unresolved.
+Recognition uses structure rather than emitted names; other helper bodies and ambiguous
+runtime fallbacks remain unresolved. Captured function identities survive later global-property
+replacement, including copies through initialized aliases. Reads before an
+alias initializer remain unresolved. Visible intrinsic writes before capture or
+conversion are checked in their owning callable scope, including identifier leaves in nested/default/rest
+destructuring and loop targets. Property keys and shadowed local bindings do not
+overwrite the global intrinsic identity. Cross-call side effects, including
+writes inside directly invoked local functions, are not evaluated. Other
+reassignments, dynamic selections, and visibly overwritten namespace members
+are unresolved.
+Known Object/Reflect mutators remain recognizable through literal destructuring
+of intrinsic objects and stable bound-function aliases. Calls retain bound
+argument prefixes and the original bound receiver through `call`, `apply`, and
+`Reflect.apply`, including generic `Function.prototype` invocation and binding
+creation. Visibly replaced invocation intrinsics produce unknown effects instead
+of using their former call semantics; captured function aliases retain their
+earlier identity. Unexamined
+targets remain unresolved. `Reflect.set` examines its explicit receiver as well
+as its target, retaining unknown receiver effects. Creating an unused binding does not itself mutate
+an intrinsic. Variable redeclarations retain a single unconditional initializer
+when they introduce no assignment or second initializer.
+Stable identifier chains to fresh object, array, function,
+undecorated class or RegExp syntax keep those targets separate from intrinsic
+objects when initialized before use; opaque, decorated, reassigned or
+not-yet-initialized targets remain unresolved. Writes during class initialization
+are still retained. Function declarations are available before their textual
+position; variable and class initializers must precede use.
Direct and destructuring assignment, loop, update, and delete targets are checked
through namespace aliases; unrelated member writes do not discard observed API
identity. This static check does
diff --git a/src/domain/javascript/electronModuleInterop.test.ts b/src/domain/javascript/electronModuleInterop.test.ts
new file mode 100644
index 000000000..bdaf113bf
--- /dev/null
+++ b/src/domain/javascript/electronModuleInterop.test.ts
@@ -0,0 +1,618 @@
+import { describe, expect, it } from "vitest";
+
+import { analyzeJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";
+import { ROLLDOWN_MODULE_INTEROP } from "./javascriptModuleInterop.fixture.js";
+
+const WINDOW =
+ 'new electron.BrowserWindow({webPreferences:{preload:"./preload.js"}});';
+const IMPORT = 'let electron = require("electron");';
+const WRAP = "electron = __toESM(electron, 1);";
+// The upstream runtime uses control-body braces that its bundled printer omits.
+// https://github.com/rolldown/rolldown/blob/22a0ab13732d81f2559ad2b7064b688699324889/crates/rolldown/src/runtime/runtime-base.js
+const BLOCK_MODULE_INTEROP = ROLLDOWN_MODULE_INTEROP.replace(
+ 'if (from && typeof from === "object" || typeof from === "function") for',
+ 'if (from && typeof from === "object" || typeof from === "function") { for',
+)
+ .replace(
+ "if (!__hasOwnProp.call(to, key) && key !== except) __defProp",
+ "if (!__hasOwnProp.call(to, key) && key !== except) { __defProp",
+ )
+ .replace(" });", " });\n }")
+ .replace(" return to;", " }\n return to;");
+
+describe("Electron module interop identity", () => {
+ it("preserves named APIs through the released Rolldown namespace conversion", () => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ ${IMPORT} ${WRAP} ${WINDOW}
+ new electron.BrowserWindow({webPreferences:{preload:runtimePath}});
+ electron.ipcMain.handle("ping", () => "pong");
+ electron.contextBridge.exposeInMainWorld("api", {ping:true});
+ `);
+ expect(analysis.electron.browser_windows).toMatchObject([
+ { preload_path: "./preload.js" },
+ { preload_path: null },
+ ]);
+ expect(analysis.electron.ipc).toMatchObject([
+ { channel: "ping", side: "main" },
+ ]);
+ expect(analysis.electron.context_bridge_apis).toMatchObject([
+ { api_key: "api" },
+ ]);
+ });
+
+ it("follows lexical identities when helper and parameter names change", () => {
+ const source = `${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP} ${WINDOW}`
+ .replaceAll("__toESM", "namespaceOf")
+ .replaceAll("__copyProps", "copyNamed")
+ .replaceAll("mod", "inputModule")
+ .replaceAll("isNodeMode", "nodeMode")
+ .replaceAll("target", "namespaceTarget")
+ .replaceAll("from", "sourceObject");
+ expect(
+ analyzeJavaScriptStaticSource(source).electron.browser_windows,
+ ).toMatchObject([{ preload_path: "./preload.js" }]);
+ });
+
+ it("preserves the same operations through control-body braces", () => {
+ expect(
+ analyzeJavaScriptStaticSource(
+ `${BLOCK_MODULE_INTEROP}\n${IMPORT} ${WRAP} ${WINDOW}`,
+ ).electron.browser_windows,
+ ).toMatchObject([{ preload_path: "./preload.js" }]);
+ });
+
+ it("keeps additional operations inside a control block unresolved", () => {
+ const altered = BLOCK_MODULE_INTEROP.replace(
+ "{ __defProp",
+ "{ from = unrelated; __defProp",
+ );
+ expect(
+ analyzeJavaScriptStaticSource(`${altered}\n${IMPORT} ${WRAP} ${WINDOW}`)
+ .electron.browser_windows,
+ ).toEqual([]);
+ });
+});
+
+const BOUND_INTRINSIC_MUTATIONS: [string, string][] = [
+ [
+ "intrinsic changed through aliased prebound arguments",
+ `const objectAlias = Object; const key = "create"; const define = Object.defineProperty; const mutate = define.bind(null, objectAlias, key); mutate({value:customCreate}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed through nested prebinding",
+ `const first = Object.defineProperty.bind(null, Object); const second = first.bind(null, "create"); second({value:customCreate}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "a replaced bound mutator bind method is unknown",
+ `const first = Object.defineProperty.bind(null, Object); first.bind = customBind; const second = first.bind(null, "create"); second({value:customCreate}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed through a computed prebound call",
+ `const mutate = Object.defineProperty.bind(null, Object, "create"); mutate["call"](null, {value:customCreate}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed through a computed prebound apply",
+ `const mutate = Object.defineProperty.bind(null, Object, "create"); mutate["apply"](null, [{value:customCreate}]); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "a replaced bind intrinsic makes a prebound mutator unknown",
+ `Function.prototype.bind = customBind; const mutate = Object.defineProperty.bind(null, Object, "create"); mutate({value:customCreate}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+];
+
+describe("Electron module interop uncertainty", () => {
+ it.each([
+ ...BOUND_INTRINSIC_MUTATIONS,
+ [
+ "intrinsic changed through an unresolved mutator target",
+ `Object.defineProperty(getTarget(), "create", {value:customCreate}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed via dynamic apply",
+ `const args = [Object, "getOwnPropertyNames", {value:() => []}]; Object.defineProperty.apply(null, args); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed via spread call",
+ `const args = [Object, "getOwnPropertyNames", {value:() => []}]; Object.defineProperty.call(null, ...args); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed via Reflect.apply",
+ `const args = [Object, "getOwnPropertyNames", {value:() => []}]; Reflect.apply(Object.defineProperty, null, args); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed via spread Reflect.apply",
+ `const args = [null, [Object, "create", {value:customCreate}]]; Reflect.apply(Object.defineProperty, ...args); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed via call",
+ `Object.defineProperty.call(null, Object, "getOwnPropertyNames", {value:() => []}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed via apply",
+ `Object.defineProperty.apply(null, [Object, "getOwnPropertyNames", {value:() => []}]); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed with defineProperty",
+ `Object.defineProperty(Object, "getOwnPropertyNames", {value:() => []}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed with Reflect.set",
+ `Reflect.set(Object, "getOwnPropertyNames", () => []); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed with an aliased mutator",
+ `const change = Object.defineProperty; change(Object, "create", {value:customCreate}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed with assign",
+ `Object.assign(Object, {getOwnPropertyNames:() => []}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "intrinsic changed with defineProperties",
+ `Object.defineProperties(Function.prototype, {bind:{value:customBind}}); ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "overwritten Object global",
+ `Object = customObject; ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "overwritten intrinsic through an alias",
+ `const objectAlias = Object; objectAlias.create = customCreate; ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "overwritten intrinsic through globalThis",
+ `globalThis.Object.create = customCreate; ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "helper called before initialization",
+ `${IMPORT} ${WRAP} ${ROLLDOWN_MODULE_INTEROP}`,
+ ],
+ [
+ "fake helper",
+ `${ROLLDOWN_MODULE_INTEROP}\n__toESM = (mod) => ({BrowserWindow:Fake}); ${IMPORT} ${WRAP}`,
+ ],
+ [
+ "changed getter",
+ `${ROLLDOWN_MODULE_INTEROP.replace("from[k]", "to[k]")}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "replaced copy helper",
+ `${ROLLDOWN_MODULE_INTEROP}\n__copyProps = () => ({}); ${IMPORT} ${WRAP}`,
+ ],
+ [
+ "replaced intrinsic alias",
+ `${ROLLDOWN_MODULE_INTEROP}\n__defProp = () => ({}); ${IMPORT} ${WRAP}`,
+ ],
+ [
+ "shadowed Object",
+ `const Object = customObject; ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "overwritten intrinsic",
+ `Object.create = customCreate; ${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP}`,
+ ],
+ [
+ "overwritten alias call",
+ `${ROLLDOWN_MODULE_INTEROP}\n__hasOwnProp.call = customCall; ${IMPORT} ${WRAP}`,
+ ],
+ [
+ "overwritten Function bind",
+ `${ROLLDOWN_MODULE_INTEROP}\nFunction.prototype.bind = customBind; ${IMPORT} ${WRAP}`,
+ ],
+ [
+ "conditional conversion",
+ `${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} if (flag) { ${WRAP} }`,
+ ],
+ [
+ "compound assignment",
+ `${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} electron ||= __toESM(electron, 1);`,
+ ],
+ [
+ "other input",
+ `${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} electron = __toESM(other, 1);`,
+ ],
+ [
+ "later overwrite",
+ `${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP} electron = unrelated;`,
+ ],
+ [
+ "overwritten constructor",
+ `${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP} electron.BrowserWindow = Fake;`,
+ ],
+ ])("does not infer Electron identity after %s", (_name, setup) => {
+ expect(
+ analyzeJavaScriptStaticSource(`${setup}\n${WINDOW}`).electron
+ .browser_windows,
+ ).toEqual([]);
+ });
+});
+
+describe("Electron module interop helper results", () => {
+ it.each([
+ 'const {BrowserWindow} = __toESM(require("electron"), 1); new BrowserWindow({});',
+ 'const {BrowserWindow: Window} = __toESM(require("electron"), 1); new Window({});',
+ 'const {default: {BrowserWindow}} = __toESM(require("electron"), 1); new BrowserWindow({});',
+ 'const Window = __toESM(require("electron"), 1).BrowserWindow; new Window({});',
+ ])("preserves a proven result projection: %s", (source) => {
+ expect(
+ analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}\n${source}`)
+ .electron.browser_windows,
+ ).toHaveLength(1);
+ });
+
+ it.each([
+ 'const {[key]: Window} = __toESM(require("electron"), 1); new Window({});',
+ 'const {...electron} = __toESM(require("electron"), 1); new electron.BrowserWindow({});',
+ 'let {BrowserWindow} = __toESM(require("electron"), 1); BrowserWindow = Fake; new BrowserWindow({});',
+ ])("keeps an uncertain result projection unresolved: %s", (source) => {
+ expect(
+ analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}\n${source}`)
+ .electron.browser_windows,
+ ).toEqual([]);
+ });
+
+ it.each([
+ "",
+ ", 0",
+ ", false",
+ ", true",
+ ", 1",
+ ', "node"',
+ ', ""',
+ ", null",
+ ])("preserves named exports with a literal node mode: %s", (mode) => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ const fresh = __toESM(require("electron")${mode});
+ new fresh.BrowserWindow({});
+ const {BrowserWindow} = __toESM(require("electron")${mode});
+ new BrowserWindow({});
+ let electron = require("electron");
+ electron = __toESM(electron${mode}); ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(3);
+ });
+
+ it.each(["", ", 0", ", false"])(
+ "does not assume a module-valued default with node mode: %s",
+ (mode) => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ const original = require("electron");
+ original.__esModule = true;
+ original.default = {BrowserWindow: Fake};
+ const {default: {BrowserWindow}} = __toESM(require("electron")${mode});
+ new BrowserWindow({});
+ const other = __toESM(require("electron")${mode}).default;
+ new other.BrowserWindow({});
+ new (__toESM(require("electron")${mode}).default.BrowserWindow)({});
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ },
+ );
+
+ it.each(["__toESM", "identity"])(
+ "rejects side-effecting extra arguments to %s",
+ (helper) => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ function identity(mod) { return mod; }
+ const electron = ${helper}(require("electron"), mutate()); ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ },
+ );
+
+ it.each([
+ "const __toESM = () => ({BrowserWindow:FakeWindow});",
+ "const __toESM = async (mod) => mod;",
+ "function* __toESM(mod) { return mod; }",
+ "const __toESM = (this && this.__toESM) || ((mod) => mod);",
+ ])("keeps an unproven fresh result unresolved: %s", (helper) => {
+ const analysis = analyzeJavaScriptStaticSource(`${helper}
+ const electron = __toESM(require("electron"), 1); ${WINDOW}
+ new (__toESM(require("electron"), 1)).BrowserWindow({});
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ });
+
+ it("preserves a proven fresh namespace and a pure identity helper", () => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ const electron = __toESM(require("electron"), 1); ${WINDOW}
+ new (__toESM(require("electron"), 1)).BrowserWindow({});
+ function passthrough(value) {return value;}
+ const plain = passthrough(require("electron"));
+ new plain.BrowserWindow({});
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(3);
+ });
+});
+
+describe("Electron module interop pattern writes", () => {
+ it.each([
+ "({Object} = replacements);",
+ "[Function] = replacements;",
+ "({nested:{Object}} = replacements);",
+ "({replacement:Object = customObject} = replacements);",
+ "({...Object} = replacements);",
+ "[...Function] = replacements;",
+ "for ({Object} of replacements) {}",
+ "for ([Function] in replacements) {}",
+ ])("rejects an intrinsic replaced through %s", (write) => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ ${write} ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.parse_error_count).toBe(0);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ });
+
+ it.each([
+ "({Object:unrelated} = replacements);",
+ "function decoy(Object) {({Object} = replacements);}",
+ ])("preserves intrinsic identity for an unrelated target: %s", (write) => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ ${write} ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.parse_error_count).toBe(0);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ });
+
+ it("preserves captured operations after later property destructuring", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ ${ROLLDOWN_MODULE_INTEROP} ({create:Object.create} = replacements);
+ ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ });
+});
+
+describe("Electron module interop intrinsic captures", () => {
+ it.each([
+ "var captured = Object.defineProperty;",
+ "const {defineProperty:captured} = Object;",
+ "var first = Object.defineProperty; const captured = first;",
+ ])("retains the original function capture through %s", (capture) => {
+ const runtime = ROLLDOWN_MODULE_INTEROP.replace(
+ "__defProp = Object.defineProperty",
+ "__defProp = captured",
+ );
+ const analysis = analyzeJavaScriptStaticSource(`
+ ${capture} Object.defineProperty = custom;
+ ${runtime} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ });
+
+ it.each(["var", "const"])(
+ "keeps an intrinsic alias read before its %s initializer unresolved",
+ (kind) => {
+ const runtime = ROLLDOWN_MODULE_INTEROP.replace(
+ "__defProp = Object.defineProperty",
+ "__defProp = later",
+ );
+ const analysis = analyzeJavaScriptStaticSource(`
+ ${runtime} ${kind} later = Object.defineProperty;
+ ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ },
+ );
+
+ it("requires the helper's intrinsic binding to initialize before conversion", () => {
+ const runtime = ROLLDOWN_MODULE_INTEROP.replace(
+ "var __defProp = Object.defineProperty;",
+ "",
+ );
+ const analysis = analyzeJavaScriptStaticSource(`
+ var captured = Object.defineProperty;
+ ${runtime} ${IMPORT} ${WRAP} ${WINDOW}
+ var __defProp = captured;
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ });
+});
+
+describe("Electron module interop capture and scope", () => {
+ it.each(["metadata", "alias"])(
+ "recognizes a hoisted function target through %s",
+ (target) => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ const alias = metadata;
+ Object.defineProperty(${target}, "x", {value:1});
+ function metadata() {}
+ ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ },
+ );
+
+ it.each([
+ "var metadata = function () {};",
+ "const metadata = () => {};",
+ "class metadata {}",
+ ])("does not hoist fresh targets from %s", (declaration) => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ Object.defineProperty(metadata, "x", {value:1});
+ ${declaration}
+ ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ });
+
+ it.each([
+ 'const {defineProperty:change} = Object; change(Object,"create",{value:customCreate});',
+ "const objectAlias = Object; const {assign:change} = objectAlias; change(Object,{create:customCreate});",
+ 'const {set:change} = Reflect; change(Object,"create",customCreate);',
+ 'const {Object:{defineProperty:change}} = globalThis; change(Object,"create",{value:customCreate});',
+ ])("rejects a projected intrinsic mutator alias: %s", (write) => {
+ const source = `${write} ${ROLLDOWN_MODULE_INTEROP}
+ ${IMPORT} ${WRAP} ${WINDOW}
+ `.replaceAll("__toESM", "namespaceOf");
+ const analysis = analyzeJavaScriptStaticSource(source);
+ expect(analysis.parse_error_count).toBe(0);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ });
+
+ it.each([
+ "const metadata = {};",
+ "const metadata = [];",
+ "const initial = {}; const metadata = initial;",
+ "const metadata = () => {};",
+ "const metadata = function () {};",
+ "const metadata = async () => {};",
+ "const metadata = function* () {};",
+ "const metadata = class {};",
+ "const metadata = /local/;",
+ "function metadata() {}",
+ "class metadata {}",
+ ])(
+ "keeps a fresh mutator target separate from intrinsic identity: %s",
+ (setup) => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ ${setup} Object.defineProperty(metadata,"x",{value:1});
+ ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ },
+ );
+
+ it.each([
+ "const metadata = getMetadata();",
+ "let metadata = {}; metadata = Object;",
+ "Object.defineProperty(metadata,'x',{value:1}); const metadata = {};",
+ "const metadata = {intrinsic:Object}; Object.defineProperty(metadata.intrinsic,'create',{value:customCreate});",
+ "const metadata = class {static {Object.create = customCreate;}};",
+ "@(() => Object) class metadata {}",
+ ])("keeps an unproven mutator target unresolved: %s", (setup) => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ ${setup} Object.defineProperty(metadata,"x",{value:1});
+ ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ });
+
+ it("does not reject unrelated intrinsic property definitions", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ Object.defineProperty(Object, "unrelated", {value:1});
+ ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ });
+
+ it("keeps opaque targets in a generic helper separate from outer module identity", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ function genericAssign() { Object.assign.apply(null, arguments); }
+ ${ROLLDOWN_MODULE_INTEROP} ${IMPORT} ${WRAP} ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ });
+
+ it("rejects an opaque intrinsic mutation in the namespace's own callable", () => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ function openWindow(args) {
+ Object.defineProperty.apply(null, args);
+ ${IMPORT} ${WRAP} ${WINDOW}
+ }
+ `);
+ expect(analysis.electron.browser_windows).toEqual([]);
+ });
+
+ it("preserves captured intrinsics across later vendor polyfills and callable writes", () => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ Object.create = customCreate;
+ ${IMPORT} ${WRAP}
+ function runLoop(key) { globalThis[key] = this; }
+ function polyfill() { Object.create = customCreate; }
+ ${WINDOW}
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ });
+
+ it("keeps a shadowed namespace separate from the converted module", () => {
+ const analysis = analyzeJavaScriptStaticSource(`${ROLLDOWN_MODULE_INTEROP}
+ ${IMPORT} ${WRAP} ${WINDOW}
+ function decoy(electron) { ${WINDOW} }
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+ });
+});
+
+describe("Electron module interop bound mutators", () => {
+ it.each([
+ 'const change = Object.defineProperty.bind(null); change(Object,"create",{value:customCreate});',
+ 'const change = Object.defineProperty.bind(null,Object,"create"); change({value:customCreate});',
+ 'const first = Object.defineProperty.bind(null,Object); const change = first; change("create",{value:customCreate});',
+ 'const change = Object.defineProperty.bind(null,Object); change.call(null,"create",{value:customCreate});',
+ 'const change = Object.defineProperty.bind(null,Object); change.apply(null,["create",{value:customCreate}]);',
+ 'const change = Object.defineProperty.bind(null,Object); Reflect.apply(change,null,["create",{value:customCreate}]);',
+ 'Object.defineProperty.bind(null,Object,"create")({value:customCreate});',
+ 'const change = Object.defineProperty.bind(null,...args); change(Object,"create",{value:customCreate});',
+ 'const metadata = {}; Object.defineProperty.call(...args,metadata,"x",{value:1});',
+ 'const metadata = {}; Object.defineProperty.apply(...args,[metadata,"x",{value:1}]);',
+ 'const change = Function.prototype.call.bind(Object.defineProperty,null); change(Object,"create",{value:customCreate});',
+ 'const first = Function.prototype.call.bind(Object.defineProperty,null); const change = first.bind(customReceiver,Object,"create"); change({value:customCreate});',
+ 'const change = Function.prototype.apply.bind(Object.defineProperty,null); change([Object,"create",{value:customCreate}]);',
+ 'Function.prototype.call.call(Object.defineProperty,null,Object,"create",{value:customCreate});',
+ 'Function.prototype.apply.call(Object.defineProperty,null,[Object,"create",{value:customCreate}]);',
+ 'const uncurry = Function.prototype.call.bind(Function.prototype.call); uncurry(Object.defineProperty,null,Object,"create",{value:customCreate});',
+ 'const change = Function.prototype.bind.call(Object.defineProperty,null); change(Object,"create",{value:customCreate});',
+ 'const bind = Function.prototype.call.bind(Function.prototype.bind); const change = bind(Object.defineProperty,null); change(Object,"create",{value:customCreate});',
+ 'const change = Function.prototype.bind.apply(Object.defineProperty,[null,Object,"create"]); change({value:customCreate});',
+ 'const change = Reflect.apply(Function.prototype.bind,Object.defineProperty,[null,Object,"create"]); change({value:customCreate});',
+ 'const first = Object.defineProperty.bind(null,Object); const change = Function.prototype.bind.call(first,null,"create"); change({value:customCreate});',
+ 'Reflect.apply = Object.defineProperty; Reflect.apply(Object,"create",{value:customCreate});',
+ 'const apply = Reflect.apply; Reflect.apply = Object.defineProperty; Reflect.apply(Object,"create",{value:customCreate});',
+ 'const change = Reflect.set.bind(null,Object,"create"); change(customCreate);',
+ 'Reflect.set({},"create",customCreate,Object);',
+ 'const metadata = {}; Reflect.set(metadata,"create",customCreate,Object);',
+ 'const change = Reflect.set.bind(null,{},"create",customCreate); change(Object);',
+ 'Reflect.apply(Reflect.set,null,[{},"create",customCreate,Object]);',
+ 'Reflect.set({},"create",customCreate,...receivers);',
+ 'Reflect.set({},"create",...valuesAndReceivers);',
+ "Reflect.set({},...keysValuesAndReceivers);",
+ 'Reflect.set({},"create",customCreate,receiver);',
+ 'const change = Object.defineProperty.call; change(null,Object,"create",{value:customCreate});',
+ 'const {apply:change} = Object.defineProperty; change(null,[Object,"create",{value:customCreate}]);',
+ 'const change = Reflect.apply.call; change(null,Object.defineProperty,null,[Object,"create",{value:customCreate}]);',
+ ])("rejects intrinsic writes through a bound mutator: %s", (write) => {
+ expect(
+ analyzeJavaScriptStaticSource(
+ `${write}\n${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP} ${WINDOW}`,
+ ).electron.browser_windows,
+ ).toEqual([]);
+ });
+
+ it.each([
+ 'const change = Object.defineProperty.bind(null); change(metadata,"x",{value:1});',
+ 'const change = Object.defineProperty.bind(null,metadata,"x"); change({value:1});',
+ 'const first = Object.defineProperty.bind(null,metadata); const change = first.bind(null,"x"); change({value:1});',
+ 'const change = Function.prototype.call.bind(Object.defineProperty,null); change(metadata,"x",{value:1});',
+ 'const change = Function.prototype.apply.bind(Object.defineProperty,null); change([metadata,"x",{value:1}]);',
+ 'const change = Function.prototype.bind.call(Object.defineProperty,null,metadata,"x"); change({value:1});',
+ 'const bind = Function.prototype.call.bind(Function.prototype.bind); const change = bind(Object.defineProperty,null,metadata,"x"); change({value:1});',
+ 'const change = Function.prototype.bind.apply(Object.defineProperty,[null,metadata,"x"]); change({value:1});',
+ 'const change = Reflect.apply(Function.prototype.bind,Object.defineProperty,[null,metadata,"x"]); change({value:1});',
+ 'const apply = Reflect.apply; Reflect.apply = replacement; apply(Object.defineProperty,null,[metadata,"x",{value:1}]);',
+ 'const change = Object.defineProperty.bind(null,Object,"create");',
+ 'Object.defineProperty.call(null,metadata,"x",{value:1});',
+ 'Object.defineProperty.apply(null,[metadata,"x",{value:1}]);',
+ 'const change = Object.defineProperty.call; change(null,metadata,"x",{value:1});',
+ 'const {apply:change} = Object.defineProperty; change(null,[metadata,"x",{value:1}]);',
+ 'Reflect.set(metadata,"x",1,{});',
+ 'const receiver = {}; Reflect.set({},"x",1,receiver);',
+ ])("keeps a fresh bound target or unused binding separate: %s", (write) => {
+ expect(
+ analyzeJavaScriptStaticSource(
+ `const metadata = {}; ${write}\n${ROLLDOWN_MODULE_INTEROP}\n${IMPORT} ${WRAP} ${WINDOW}`,
+ ).electron.browser_windows,
+ ).toHaveLength(1);
+ });
+});
+
+it("keeps unrelated exports after an aliased prebound key write", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ const electron = require("electron");
+ const key = "Unrelated";
+ const mutate = Object.defineProperty.bind(null, electron, key);
+ mutate({value: custom});
+ new electron.BrowserWindow({});
+ `);
+ expect(analysis.electron.browser_windows).toHaveLength(1);
+});
diff --git a/src/domain/javascript/electronStaticAnalysisIdentity.test.ts b/src/domain/javascript/electronStaticAnalysisIdentity.test.ts
index 99a3805e8..0005a1977 100644
--- a/src/domain/javascript/electronStaticAnalysisIdentity.test.ts
+++ b/src/domain/javascript/electronStaticAnalysisIdentity.test.ts
@@ -77,7 +77,7 @@ describe("Electron API identity", () => {
it("follows bundler namespace interop helpers without accepting other writes", () => {
const analysis = analyzeJavaScriptStaticSource(`
var __toESM = (mod) => mod;
- var __importStar = (this && this.__importStar) || ((mod) => mod);
+ var __importStar = (mod) => mod;
let electron = require("electron");
electron = __toESM(electron);
new electron.BrowserWindow({ webPreferences: { preload: "./rolldown.js" } });
@@ -120,4 +120,53 @@ describe("Electron API identity", () => {
expect(analysis.electron.browser_windows).toEqual([]);
});
+
+ it("follows stable declaration aliases but not an assigned default parameter", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ const direct = require("electron");
+ const constAlias = direct;
+ new constAlias.BrowserWindow({webPreferences:{preload:"./const.js"}});
+
+ let letAlias = require("electron");
+ new letAlias.BrowserWindow({webPreferences:{preload:"./let.js"}});
+
+ const { BrowserWindow } = require("electron");
+ new BrowserWindow({webPreferences:{preload:"./destructured.js"}});
+
+ function withDefault(electron = require("./not-electron")) {
+ if (flag) electron = require("electron");
+ new electron.BrowserWindow({webPreferences:{preload:"./default.js"}});
+ }
+ `);
+
+ expect(
+ analysis.electron.browser_windows.map(({ preload_path }) => preload_path),
+ ).toEqual(["./const.js", "./let.js", "./destructured.js"]);
+ });
+
+ it("preserves one initializer across variable redeclarations without accepting writes", () => {
+ const analysis = analyzeJavaScriptStaticSource(`
+ var electron;
+ var electron = require("electron");
+ var electron;
+ new electron.BrowserWindow({webPreferences:{preload:"./redeclared.js"}});
+
+ var replaced;
+ var replaced = require("electron");
+ replaced = fake;
+ new replaced.BrowserWindow({webPreferences:{preload:"./replaced.js"}});
+
+ var initializedTwice = require("electron");
+ var initializedTwice = fake;
+ new initializedTwice.BrowserWindow({});
+
+ var conditional;
+ if (flag) { var conditional = require("electron"); }
+ new conditional.BrowserWindow({});
+ `);
+
+ expect(
+ analysis.electron.browser_windows.map(({ preload_path }) => preload_path),
+ ).toEqual(["./redeclared.js"]);
+ });
});
diff --git a/src/domain/javascript/javascriptAstValues.ts b/src/domain/javascript/javascriptAstValues.ts
index f89eabb05..cb3a533fe 100644
--- a/src/domain/javascript/javascriptAstValues.ts
+++ b/src/domain/javascript/javascriptAstValues.ts
@@ -86,16 +86,20 @@ export const semanticObjectPatternKeys = (
return key === null ? [] : [key];
});
-/** Visit member write targets in direct and destructuring assignment forms. */
-export function* semanticMemberWriteTargets(
+/** Visit binding and member leaves in direct and destructuring write targets. */
+export function* semanticWriteTargets(
root: t.Node,
-): Generator<t.MemberExpression | t.OptionalMemberExpression> {
+): Generator<t.Identifier | t.MemberExpression | t.OptionalMemberExpression> {
const pending = [root];
while (pending.length > 0) {
const next = pending.pop();
if (next === undefined) break;
const node = unwrapJavaScriptExpression(next).node;
- if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
+ if (
+ t.isIdentifier(node) ||
+ t.isMemberExpression(node) ||
+ t.isOptionalMemberExpression(node)
+ )
yield node;
else if (t.isRestElement(node)) pending.push(node.argument);
else if (t.isAssignmentPattern(node)) pending.push(node.left);
diff --git a/src/domain/javascript/javascriptElectronMemberWrites.ts b/src/domain/javascript/javascriptElectronMemberWrites.ts
index 696bb68aa..003b495e0 100644
--- a/src/domain/javascript/javascriptElectronMemberWrites.ts
+++ b/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;
}
diff --git a/src/domain/javascript/javascriptIntrinsicInvocation.ts b/src/domain/javascript/javascriptIntrinsicInvocation.ts
new file mode 100644
index 000000000..e34efe04a
--- /dev/null
+++ b/src/domain/javascript/javascriptIntrinsicInvocation.ts
@@ -0,0 +1,123 @@
+import * as t from "@babel/types";
+
+import type { JavaScriptIntrinsicInvocation } from "./javascriptElectronMemberWrites.js";
+import {
+ semanticStaticPropertyKey,
+ unwrapJavaScriptExpression,
+} from "./javascriptAstValues.js";
+
+const arrayArguments = (array: t.Node | undefined) =>
+ t.isArrayExpression(array) &&
+ array.elements.every((element) => t.isExpression(element))
+ ? array.elements.filter((element): element is t.Expression =>
+ t.isExpression(element),
+ )
+ : undefined;
+
+const invocationArguments = (
+ method: "call" | "apply",
+ arguments_: JavaScriptIntrinsicInvocation["arguments"],
+) =>
+ t.isSpreadElement(arguments_?.[0])
+ ? undefined
+ : method === "apply"
+ ? arrayArguments(arguments_?.[1])
+ : arguments_?.slice(1);
+
+/**
+ * Normalize known invocation syntax once, retaining bound argument prefixes.
+ * Binding a function alone is not a write; only its eventual call is examined.
+ */
+export const resolveJavaScriptIntrinsicInvocation = (
+ node: t.CallExpression | t.OptionalCallExpression,
+ intrinsicPath: (node: t.Node) => readonly string[] | undefined,
+ boundIntrinsic: (node: t.Node) => JavaScriptIntrinsicInvocation | undefined,
+ intrinsicReadChanged: (node: t.Node, path: readonly string[]) => boolean,
+): JavaScriptIntrinsicInvocation | undefined => {
+ const visited = new Set<t.Node>();
+ let callee: t.Node = node.callee;
+ let arguments_: JavaScriptIntrinsicInvocation["arguments"] = node.arguments;
+ let receiver: t.Node | undefined;
+ for (;;) {
+ callee = unwrapJavaScriptExpression(callee).node;
+ if (visited.has(callee)) return undefined;
+ visited.add(callee);
+ let path = intrinsicPath(callee);
+ if (path !== undefined && intrinsicReadChanged(callee, path))
+ return { kind: "opaque", path, arguments: undefined };
+ if (path === undefined) {
+ if (
+ t.isMemberExpression(callee) ||
+ t.isOptionalMemberExpression(callee)
+ ) {
+ const method = semanticStaticPropertyKey(
+ callee.property,
+ callee.computed,
+ );
+ if (method === "call" || method === "apply") {
+ const bound = boundIntrinsic(callee.object);
+ if (
+ bound !== undefined &&
+ intrinsicReadChanged(callee, [...bound.path, method])
+ )
+ return { kind: "opaque", path: bound.path, arguments: undefined };
+ receiver = arguments_?.[0];
+ callee = callee.object;
+ arguments_ = invocationArguments(method, arguments_);
+ continue;
+ }
+ }
+ const bound = boundIntrinsic(callee);
+ if (bound === undefined) return undefined;
+ if (bound.kind === "opaque") return bound;
+ path = bound.path;
+ receiver = bound.receiver;
+ arguments_ =
+ bound.arguments === undefined
+ ? undefined
+ : [...bound.arguments, ...(arguments_ ?? [])];
+ }
+ // A projected .call/.apply invokes the preceding callable. The actual
+ // Function.prototype methods instead invoke their receiver, retained by bind.
+ while (path.length > 3 && !genericInvocationMethod(path)) {
+ const method = path.at(-1);
+ if (method !== "call" && method !== "apply") break;
+ receiver = arguments_?.[0];
+ arguments_ = invocationArguments(method, arguments_);
+ path = path.slice(0, -1);
+ }
+ const genericMethod = genericInvocationMethod(path);
+ if (genericMethod !== undefined) {
+ if (!t.isExpression(receiver)) return undefined;
+ callee = receiver;
+ receiver = arguments_?.[0];
+ arguments_ = invocationArguments(genericMethod, arguments_);
+ continue;
+ }
+ if (path.join(".") === "intrinsic.Reflect.apply") {
+ const callable = arguments_?.[0];
+ if (!t.isExpression(callable)) return undefined;
+ callee = callable;
+ receiver = arguments_?.[1];
+ arguments_ = arrayArguments(arguments_?.[2]);
+ continue;
+ }
+ return {
+ kind: "known",
+ path,
+ arguments: arguments_,
+ ...(receiver === undefined ? {} : { receiver }),
+ };
+ }
+};
+
+const genericInvocationMethod = (
+ path: readonly string[],
+): "call" | "apply" | undefined =>
+ path.length === 4 &&
+ path[0] === "intrinsic" &&
+ path[1] === "Function" &&
+ path[2] === "prototype" &&
+ (path[3] === "call" || path[3] === "apply")
+ ? path[3]
+ : undefined;
diff --git a/src/domain/javascript/javascriptModuleInterop.fixture.ts b/src/domain/javascript/javascriptModuleInterop.fixture.ts
new file mode 100644
index 000000000..1ed97af90
--- /dev/null
+++ b/src/domain/javascript/javascriptModuleInterop.fixture.ts
@@ -0,0 +1,24 @@
+// Rolldown runtime from the public T3 Code nightly 20261011.2967 main.cjs.
+// The input is inert source: none of these helpers or Electron APIs is executed.
+export const ROLLDOWN_MODULE_INTEROP = `
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+ key = keys[i];
+ if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+ get: ((k) => from[k]).bind(null, key),
+ enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+ });
+ }
+ return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+ value: mod,
+ enumerable: true
+}) : target, mod));
+`;
diff --git a/src/domain/javascript/javascriptModuleInterop.ts b/src/domain/javascript/javascriptModuleInterop.ts
new file mode 100644
index 000000000..35e1c9ef1
--- /dev/null
+++ b/src/domain/javascript/javascriptModuleInterop.ts
@@ -0,0 +1,774 @@
+import { parseExpression } from "@babel/parser";
+import * as t from "@babel/types";
+
+import type { JavaScriptModuleOrigin } from "./javascriptSemanticIr.js";
+import {
+ isUnshadowedGlobal,
+ resolveSemanticBindingState,
+ semanticScopeId,
+ semanticStableInitializer,
+ type JavaScriptSemanticAnalysisState,
+ type JavaScriptSemanticBindingState,
+} from "./javascriptSemanticState.js";
+import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
+import {
+ childNodes,
+ javaScriptAstChildKeys,
+} from "./javascriptSemanticTraversal.js";
+import {
+ electronMemberPath,
+ type JavaScriptIntrinsicInvocation,
+} from "./javascriptElectronMemberWrites.js";
+import { resolveJavaScriptIntrinsicInvocation } from "./javascriptIntrinsicInvocation.js";
+import { SemanticPropertyPathCoverage } from "./javascriptSemanticPropertyPaths.js";
+import {
+ readExactJavaScriptLiteral,
+ unwrapJavaScriptExpression,
+} from "./javascriptAstValues.js";
+
+// Match the complete Rolldown runtime operations, including its live getters.
+// Names and formatting are irrelevant; lexical roles, operators and keys are not.
+const TO_ESM = parseExpression(`(mod, isNodeMode, target) => (
+ target = mod != null ? __create(__getProtoOf(mod)) : {},
+ __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default")
+ ? __defProp(target, "default", {value: mod, enumerable: true}) : target, mod)
+)`);
+const COPY_PROPS = parseExpression(`(to, from, except, desc) => {
+ if (from && typeof from === "object" || typeof from === "function")
+ for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+ key = keys[i];
+ if (!__hasOwnProp.call(to, key) && key !== except)
+ __defProp(to, key, {
+ get: ((k) => from[k]).bind(null, key),
+ enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+ });
+ }
+ return to;
+}`);
+const INTRINSICS: Readonly<Record<string, readonly string[]>> = {
+ __create: ["Object", "create"],
+ __getProtoOf: ["Object", "getPrototypeOf"],
+ __defProp: ["Object", "defineProperty"],
+ __getOwnPropNames: ["Object", "getOwnPropertyNames"],
+ __getOwnPropDesc: ["Object", "getOwnPropertyDescriptor"],
+ __hasOwnProp: ["Object", "prototype", "hasOwnProperty"],
+};
+
+interface IntrinsicDependency {
+ readonly path: readonly string[];
+ readonly capturedAt?: t.Node;
+}
+
+interface InteropOrigin {
+ readonly origin: JavaScriptModuleOrigin;
+ readonly dependencies: readonly IntrinsicDependency[];
+ readonly defaultIsModule: boolean;
+}
+
+interface InteropHelper {
+ readonly dependencies: readonly IntrinsicDependency[];
+ readonly readyAfter: number;
+ readonly identity: boolean;
+}
+
+/** Prove one inert namespace conversion without relaxing general assignment semantics. */
+export const createSemanticModuleInterop = (
+ state: JavaScriptSemanticAnalysisState,
+) => {
+ const helpers = new Map<string, InteropHelper | null>();
+ const origins = new Map<string, InteropOrigin>();
+ const calls = new WeakMap<t.Node, InteropOrigin>();
+ const intrinsicBindings = new Map<string, readonly string[] | null>();
+ const writes: {
+ readonly scope: string;
+ readonly offset: number;
+ readonly coverage: SemanticPropertyPathCoverage;
+ }[] = [];
+ const invalidatedBindings = new Map<string, boolean>();
+ const invalidatedCalls = new WeakMap<t.Node, boolean>();
+ const opaqueMutationPath = (node: t.Node): readonly string[] => {
+ let current: t.Node | undefined = node;
+ while (current !== undefined) {
+ if (t.isFunction(current))
+ return ["opaque-intrinsic", semanticScopeId("function", current)];
+ current = state.parentsByNode.get(current);
+ }
+ return ["intrinsic"];
+ };
+
+ const intrinsicPath = (node: t.Node): readonly string[] | undefined => {
+ let current = node;
+ const visited = new Set<string>();
+ const pending: { id: string; suffixLength: number }[] = [];
+ let suffix: readonly string[] = [];
+ const finish = (
+ path: readonly string[] | undefined,
+ ): readonly string[] | undefined => {
+ for (const binding of pending)
+ intrinsicBindings.set(
+ binding.id,
+ path === undefined
+ ? null
+ : path.slice(0, path.length - binding.suffixLength),
+ );
+ return path;
+ };
+ for (;;) {
+ const { root, members } = electronMemberPath(current);
+ if (members.some((member) => member === null)) return finish(undefined);
+ suffix = [...(members as readonly string[]), ...suffix];
+ for (const global of ["Object", "Function", "Reflect"])
+ if (isUnshadowedGlobal(root, state, global))
+ return finish(["intrinsic", global, ...suffix]);
+ for (const global of ["globalThis", "global", "window", "self"])
+ if (isUnshadowedGlobal(root, state, global))
+ return finish(["intrinsic", ...suffix]);
+ if (!t.isIdentifier(root)) return finish(undefined);
+ const binding = resolveSemanticBindingState(state, root, root.name);
+ const cached =
+ binding === undefined
+ ? undefined
+ : intrinsicBindings.get(binding.bindingId);
+ if (cached !== undefined)
+ return finish(cached === null ? undefined : [...cached, ...suffix]);
+ const initializer = semanticStableInitializer(binding, state);
+ if (
+ binding === undefined ||
+ initializer === undefined ||
+ initializer.projection.some((segment) => segment === null) ||
+ visited.has(binding.bindingId)
+ )
+ return finish(undefined);
+ visited.add(binding.bindingId);
+ pending.push({ id: binding.bindingId, suffixLength: suffix.length });
+ suffix = [...initializer.projection.map(String), ...suffix];
+ current = initializer.node;
+ }
+ };
+
+ // A nominal alias path is sufficient for conservative mutation lookup, but
+ // helper proof also needs each read to follow initialization. An alias copy
+ // retains the earlier function capture; a member read captures it anew.
+ const capturedIntrinsic = (node: t.Node): IntrinsicDependency | undefined => {
+ const path = intrinsicPath(node);
+ if (path === undefined) return undefined;
+ const visited = new Set<string>();
+ let current = node;
+ let capturedAt = node;
+ let suffixLength = 0;
+ for (;;) {
+ const { root, members } = electronMemberPath(current);
+ suffixLength += members.length;
+ if (!t.isIdentifier(root)) return undefined;
+ const binding = resolveSemanticBindingState(state, root, root.name);
+ if (binding === undefined) return { path, capturedAt };
+ const initializer = semanticStableInitializer(binding, state);
+ if (
+ initializer === undefined ||
+ (initializer.node.end ?? Infinity) >= (root.start ?? -1) ||
+ visited.has(binding.bindingId)
+ )
+ return undefined;
+ visited.add(binding.bindingId);
+ if (suffixLength === 0) capturedAt = initializer.node;
+ suffixLength += initializer.projection.length;
+ current = initializer.node;
+ }
+ };
+
+ const staticString = (node: t.Node | undefined): string | undefined => {
+ if (node === undefined) return undefined;
+ const visited = new Set<string>();
+ let current = node;
+ for (;;) {
+ const literal = readExactJavaScriptLiteral(current);
+ if (literal.found)
+ return typeof literal.value === "string" ? literal.value : undefined;
+ const expression = unwrapJavaScriptExpression(current).node;
+ if (!t.isIdentifier(expression)) return undefined;
+ const binding = resolveSemanticBindingState(
+ state,
+ expression,
+ expression.name,
+ );
+ const initializer = semanticStableInitializer(binding, state);
+ if (
+ binding === undefined ||
+ initializer === undefined ||
+ initializer.projection.length !== 0 ||
+ (initializer.node.end ?? Infinity) >= (expression.start ?? -1) ||
+ visited.has(binding.bindingId)
+ )
+ return undefined;
+ visited.add(binding.bindingId);
+ current = initializer.node;
+ }
+ };
+
+ const intrinsicReadChanged = (
+ node: t.Node,
+ path: readonly string[],
+ ): boolean => {
+ const capture = capturedIntrinsic(node)?.capturedAt ?? node;
+ const scope = opaqueMutationPath(capture).join(".");
+ const method = path.at(-1);
+ const invocationMethod =
+ method === "bind" || method === "call" || method === "apply";
+ return writes.some(
+ (write) =>
+ (write.scope === scope || write.scope === "intrinsic") &&
+ write.offset < (capture.start ?? -1) &&
+ (write.coverage.covers(path) ||
+ (invocationMethod &&
+ write.coverage.covers([
+ "intrinsic",
+ "Function",
+ "prototype",
+ method,
+ ]))),
+ );
+ };
+
+ const resolveBoundIntrinsic = (
+ node: t.Node,
+ ): JavaScriptIntrinsicInvocation | undefined => {
+ const visited = new Set<string>();
+ const argumentGroups: t.CallExpression["arguments"][] = [];
+ const bindReads: t.Node[] = [];
+ let opaqueArguments = false;
+ let receiver: t.Node | undefined;
+ let current = node;
+ for (;;) {
+ current = unwrapJavaScriptExpression(current).node;
+ if (t.isIdentifier(current)) {
+ const binding = resolveSemanticBindingState(
+ state,
+ current,
+ current.name,
+ );
+ const initializer = semanticStableInitializer(binding, state);
+ if (
+ binding === undefined ||
+ initializer === undefined ||
+ initializer.projection.length !== 0 ||
+ (initializer.node.end ?? Infinity) >= (current.start ?? -1) ||
+ visited.has(binding.bindingId)
+ )
+ return undefined;
+ visited.add(binding.bindingId);
+ current = initializer.node;
+ continue;
+ }
+ if (!t.isCallExpression(current)) return undefined;
+ const { root, members } = electronMemberPath(current.callee);
+ let bindTarget = root;
+ let bindingArguments: JavaScriptIntrinsicInvocation["arguments"] =
+ current.arguments;
+ let captured = capturedIntrinsic(current.callee);
+ let terminal = captured?.path.at(-1) === "bind";
+ let path: readonly string[] | undefined = captured?.path.slice(0, -1);
+ if (members.at(-1) === "bind") {
+ // A direct .bind may continue a bound callable, without discarding members.
+ if (!terminal && members.length !== 1) return undefined;
+ bindReads.push(captured?.capturedAt ?? current.callee);
+ } else {
+ // Reuse the invocation owner for generic call/apply/Reflect.apply of bind.
+ const invocation = resolveJavaScriptIntrinsicInvocation(
+ current,
+ intrinsicPath,
+ boundIntrinsic,
+ intrinsicReadChanged,
+ );
+ if (
+ invocation?.kind !== "known" ||
+ invocation.path.join(".") !== "intrinsic.Function.prototype.bind" ||
+ invocation.receiver === undefined
+ )
+ return undefined;
+ bindTarget = invocation.receiver;
+ bindingArguments = invocation.arguments;
+ captured = capturedIntrinsic(bindTarget);
+ terminal = captured !== undefined;
+ path = captured?.path;
+ }
+ receiver = bindingArguments?.[0];
+ const ownArguments = bindingArguments?.slice(1) ?? [];
+ opaqueArguments ||=
+ bindingArguments === undefined || t.isSpreadElement(receiver);
+ opaqueArguments ||= ownArguments.some((argument) =>
+ t.isSpreadElement(argument),
+ );
+ argumentGroups.push(ownArguments);
+ if (!terminal || path === undefined) {
+ current = bindTarget;
+ continue;
+ }
+ const boundPath = [...path, "bind"];
+ const functionBind = ["intrinsic", "Function", "prototype", "bind"];
+ opaqueArguments ||= bindReads.some((capture) => {
+ const scope = opaqueMutationPath(capture).join(".");
+ return writes.some(
+ (write) =>
+ (write.scope === scope || write.scope === "intrinsic") &&
+ write.offset < (capture.start ?? -1) &&
+ (write.coverage.covers(boundPath) ||
+ write.coverage.covers(functionBind)),
+ );
+ });
+ return {
+ kind: opaqueArguments ? "opaque" : "known",
+ path,
+ ...(receiver === undefined ? {} : { receiver }),
+ // Rebinding appends arguments to the earlier bound argument list.
+ arguments: opaqueArguments
+ ? undefined
+ : argumentGroups.toReversed().flat(),
+ };
+ }
+ };
+
+ const activeBoundValues = new WeakSet<t.Node>();
+ const boundIntrinsic = (
+ node: t.Node,
+ ): JavaScriptIntrinsicInvocation | undefined => {
+ if (activeBoundValues.has(node)) return undefined;
+ activeBoundValues.add(node);
+ try {
+ return resolveBoundIntrinsic(node);
+ } finally {
+ activeBoundValues.delete(node);
+ }
+ };
+
+ const isFreshObject = (node: t.Node): boolean => {
+ const visited = new Set<string>();
+ let current = node;
+ for (;;) {
+ current = unwrapJavaScriptExpression(current).node;
+ if (
+ t.isObjectExpression(current) ||
+ t.isArrayExpression(current) ||
+ t.isFunction(current) ||
+ (t.isClass(current) && !current.decorators?.length) ||
+ t.isRegExpLiteral(current)
+ )
+ return true;
+ if (!t.isIdentifier(current)) return false;
+ const binding = resolveSemanticBindingState(state, current, current.name);
+ const initializer = unprojectedInitializer(binding, state);
+ if (
+ binding === undefined ||
+ initializer === undefined ||
+ (!t.isFunctionDeclaration(initializer) &&
+ (initializer.end ?? Infinity) >= (current.start ?? -1)) ||
+ visited.has(binding.bindingId)
+ )
+ return false;
+ visited.add(binding.bindingId);
+ current = initializer;
+ }
+ };
+
+ const helperProof = (
+ binding: JavaScriptSemanticBindingState,
+ ): InteropHelper | undefined => {
+ const cached = helpers.get(binding.bindingId);
+ if (cached !== undefined) return cached ?? undefined;
+ helpers.set(binding.bindingId, null);
+ if (state.scopesById.get(binding.scopeId)?.kind !== "program")
+ return undefined;
+ const wrapper = unprojectedInitializer(binding, state);
+ if (wrapper === undefined) return undefined;
+ if (identityFunction(wrapper, state)) {
+ const proof = {
+ dependencies: [],
+ readyAfter: t.isFunctionDeclaration(wrapper)
+ ? -1
+ : (wrapper.end ?? Infinity),
+ identity: true,
+ };
+ helpers.set(binding.bindingId, proof);
+ return proof;
+ }
+ const wrapperRoles = canonicalRoles(wrapper, TO_ESM, state);
+ const copyBinding = wrapperRoles?.get("__copyProps");
+ const copy = unprojectedInitializer(copyBinding, state);
+ const copyRoles =
+ copy === undefined ? undefined : canonicalRoles(copy, COPY_PROPS, state);
+ if (
+ wrapperRoles === undefined ||
+ copyRoles === undefined ||
+ copy === undefined
+ )
+ return undefined;
+ const dependencies: IntrinsicDependency[] = [];
+ let readyAfter = Math.max(wrapper.end ?? Infinity, copy.end ?? Infinity);
+ for (const roles of [wrapperRoles, copyRoles])
+ for (const [role, dependency] of roles) {
+ const expected = INTRINSICS[role];
+ if (expected === undefined) continue;
+ const initializer = unprojectedInitializer(dependency, state);
+ const captured =
+ initializer === undefined
+ ? undefined
+ : capturedIntrinsic(initializer);
+ if (
+ initializer === undefined ||
+ captured === undefined ||
+ JSON.stringify(captured.path) !==
+ JSON.stringify(["intrinsic", ...expected])
+ )
+ return undefined;
+ readyAfter = Math.max(readyAfter, initializer.end ?? Infinity);
+ dependencies.push(captured);
+ if (role === "__hasOwnProp")
+ dependencies.push({ path: [...captured.path, "call"] });
+ }
+ dependencies.push(
+ { path: ["intrinsic", "Function", "prototype", "bind"] },
+ { path: ["intrinsic", "Function", "prototype", "call"] },
+ );
+ const proof = {
+ dependencies,
+ identity: false,
+ readyAfter,
+ };
+ helpers.set(binding.bindingId, proof);
+ return proof;
+ };
+
+ const provenCall = (node: t.Node) => {
+ if (!t.isCallExpression(node) || !t.isIdentifier(node.callee))
+ return undefined;
+ const helper = resolveSemanticBindingState(
+ state,
+ node.callee,
+ node.callee.name,
+ );
+ const proof = helper === undefined ? undefined : helperProof(helper);
+ const input = node.arguments[0];
+ const mode = node.arguments[1];
+ const literalMode =
+ mode === undefined
+ ? { found: true, value: false }
+ : t.isExpression(mode)
+ ? readExactJavaScriptLiteral(mode)
+ : { found: false };
+ if (
+ proof === undefined ||
+ proof.readyAfter >= (node.start ?? -1) ||
+ !t.isExpression(input) ||
+ node.arguments.length > 2 ||
+ !literalMode.found
+ )
+ return undefined;
+ return {
+ input,
+ // A truthy node mode forces the module-valued default. Other modes
+ // preserve named exports without proving the source's default property.
+ defaultIsModule: !proof.identity && Boolean(literalMode.value),
+ dependencies: proof.dependencies.map((dependency) => ({
+ ...dependency,
+ capturedAt: dependency.capturedAt ?? node,
+ })),
+ };
+ };
+
+ const callOrigin = (node: t.Node): InteropOrigin | undefined => {
+ const cached = calls.get(node);
+ if (cached !== undefined) return cached;
+ const { root, members } = electronMemberPath(node);
+ if (!members.every((member): member is string => member !== null))
+ return undefined;
+ const converted = provenCall(root);
+ const required =
+ converted === undefined
+ ? undefined
+ : semanticRequireOrigin(converted.input, state)?.origin;
+ if (
+ converted === undefined ||
+ required === undefined ||
+ required.importedPath.length !== 0 ||
+ (members[0] === "default" && !converted.defaultIsModule)
+ )
+ return undefined;
+ const result = {
+ origin: { ...required, importedPath: members },
+ dependencies: converted.dependencies,
+ defaultIsModule: converted.defaultIsModule,
+ };
+ calls.set(node, result);
+ return result;
+ };
+
+ const origin = (
+ binding: JavaScriptSemanticBindingState,
+ ): InteropOrigin | undefined => {
+ const single = semanticStableInitializer(binding, state);
+ if (single !== undefined) {
+ if (
+ !single.projection.every(
+ (key): key is string => typeof key === "string",
+ )
+ )
+ return undefined;
+ const converted = callOrigin(single.node);
+ if (
+ converted?.origin.importedPath.length === 0 &&
+ single.projection[0] === "default" &&
+ !converted.defaultIsModule
+ )
+ return undefined;
+ const result =
+ converted === undefined
+ ? undefined
+ : {
+ ...converted,
+ origin: {
+ ...converted.origin,
+ importedPath: [
+ ...converted.origin.importedPath,
+ ...single.projection,
+ ],
+ },
+ };
+ if (result !== undefined) origins.set(binding.bindingId, result);
+ return result;
+ }
+ const [initial, converted] = binding.initializers;
+ if (
+ binding.definitions.length !== 2 ||
+ binding.definitions[0]?.kind !== "variable" ||
+ binding.definitions[1]?.kind !== "assignment" ||
+ binding.initializers.length !== 2 ||
+ initial === undefined ||
+ converted === undefined ||
+ initial.projection.length !== 0 ||
+ converted.projection.length !== 0 ||
+ state.conditionalInitializers.has(initial.node)
+ )
+ return undefined;
+ const call = converted.node;
+ const assignment = state.parentsByNode.get(call);
+ const statement =
+ assignment === undefined
+ ? undefined
+ : state.parentsByNode.get(assignment);
+ const declaration = state.parentsByNode.get(initial.node);
+ const declarationStatement =
+ declaration === undefined
+ ? undefined
+ : state.parentsByNode.get(declaration);
+ if (
+ !t.isCallExpression(call) ||
+ !t.isIdentifier(call.callee) ||
+ !t.isAssignmentExpression(assignment, { operator: "=" }) ||
+ assignment.right !== call ||
+ !t.isIdentifier(assignment.left, { name: binding.name }) ||
+ !t.isExpressionStatement(statement) ||
+ !t.isVariableDeclarator(declaration) ||
+ !t.isVariableDeclaration(declarationStatement) ||
+ state.parentsByNode.get(statement) !==
+ state.parentsByNode.get(declarationStatement) ||
+ (initial.node.start ?? Infinity) >= (call.start ?? -1)
+ )
+ return undefined;
+ const convertedCall = provenCall(call);
+ const input = convertedCall?.input;
+ if (
+ !t.isIdentifier(input) ||
+ resolveSemanticBindingState(state, input, input.name) !== binding
+ )
+ return undefined;
+ const required = semanticRequireOrigin(initial.node, state)?.origin;
+ if (required === undefined || required.importedPath.length !== 0)
+ return undefined;
+ if (convertedCall === undefined) return undefined;
+ const result = {
+ origin: required,
+ dependencies: convertedCall.dependencies,
+ defaultIsModule: convertedCall.defaultIsModule,
+ };
+ origins.set(binding.bindingId, result);
+ return result;
+ };
+ const invalidatedOrigin = (record: InteropOrigin | undefined): boolean =>
+ record?.dependencies.some(({ path, capturedAt }) => {
+ if (capturedAt === undefined) return true;
+ const scope = opaqueMutationPath(capturedAt).join(".");
+ // Captured function values survive later replacement of global
+ // properties. Other callable bodies are not execution evidence.
+ return writes.some(
+ (write) =>
+ (write.scope === scope || write.scope === "intrinsic") &&
+ write.offset < (capturedAt.start ?? -1) &&
+ write.coverage.covers(path),
+ );
+ }) ?? false;
+ return {
+ origin,
+ callOrigin,
+ intrinsicPath,
+ intrinsicInvocation: (node: t.CallExpression | t.OptionalCallExpression) =>
+ resolveJavaScriptIntrinsicInvocation(
+ node,
+ intrinsicPath,
+ boundIntrinsic,
+ intrinsicReadChanged,
+ ),
+ boundIntrinsic,
+ staticString,
+ isFreshObject,
+ opaqueMutationPath,
+ retainWrite: (node: t.Node, path: readonly (string | null)[]) => {
+ const coverage = new SemanticPropertyPathCoverage();
+ coverage.retain(path[0] === "opaque-intrinsic" ? ["intrinsic"] : path);
+ writes.push({
+ scope: opaqueMutationPath(node).join("."),
+ offset: node.start ?? Infinity,
+ coverage,
+ });
+ },
+ invalidated: (binding: JavaScriptSemanticBindingState): boolean => {
+ const cached = invalidatedBindings.get(binding.bindingId);
+ if (cached !== undefined) return cached;
+ const result = invalidatedOrigin(origins.get(binding.bindingId));
+ invalidatedBindings.set(binding.bindingId, result);
+ return result;
+ },
+ invalidatedCall: (node: t.Node): boolean => {
+ const cached = invalidatedCalls.get(node);
+ if (cached !== undefined) return cached;
+ const result = invalidatedOrigin(calls.get(node));
+ invalidatedCalls.set(node, result);
+ return result;
+ },
+ };
+};
+
+const identityFunction = (
+ node: t.Node,
+ state: JavaScriptSemanticAnalysisState,
+): boolean => {
+ if (
+ !t.isFunction(node) ||
+ node.async ||
+ node.generator ||
+ node.params.length !== 1
+ )
+ return false;
+ const parameter = node.params[0];
+ const result = t.isBlockStatement(node.body)
+ ? node.body.body.length === 1 && t.isReturnStatement(node.body.body[0])
+ ? node.body.body[0].argument
+ : undefined
+ : node.body;
+ return (
+ t.isIdentifier(parameter) &&
+ t.isIdentifier(result) &&
+ resolveSemanticBindingState(state, parameter, parameter.name) !==
+ undefined &&
+ resolveSemanticBindingState(state, parameter, parameter.name) ===
+ resolveSemanticBindingState(state, result, result.name)
+ );
+};
+
+const unprojectedInitializer = (
+ binding: JavaScriptSemanticBindingState | undefined,
+ state: JavaScriptSemanticAnalysisState,
+): t.Node | undefined => {
+ const initializer = semanticStableInitializer(binding, state);
+ return initializer?.projection.length === 0 ? initializer.node : undefined;
+};
+
+/** Match operations and lexical roles, allowing single-statement control blocks. */
+const canonicalRoles = (
+ actual: t.Node,
+ pattern: t.Node,
+ state: JavaScriptSemanticAnalysisState,
+): ReadonlyMap<string, JavaScriptSemanticBindingState> | undefined => {
+ const roles = new Map<string, JavaScriptSemanticBindingState>();
+ const used = new Map<string, string>();
+ const pending: { actual: t.Node; pattern: t.Node; parent: t.Node | null }[] =
+ [{ actual, pattern, parent: null }];
+ while (pending.length !== 0) {
+ const pair = pending.pop();
+ if (pair === undefined) return undefined;
+ const { parent } = pair;
+ const controlBody =
+ (t.isIfStatement(parent) &&
+ (parent.consequent === pair.pattern ||
+ parent.alternate === pair.pattern)) ||
+ (t.isForStatement(parent) && parent.body === pair.pattern);
+ const node = controlBody ? controlBodyOperation(pair.actual) : pair.actual;
+ const expected = controlBody
+ ? controlBodyOperation(pair.pattern)
+ : pair.pattern;
+ if (node.type !== expected.type) return undefined;
+ const literalKey =
+ parent !== null &&
+ ((t.isMemberExpression(parent) &&
+ !parent.computed &&
+ parent.property === expected) ||
+ (t.isObjectProperty(parent) &&
+ !parent.computed &&
+ parent.key === expected));
+ if (t.isIdentifier(expected) && t.isIdentifier(node) && !literalKey) {
+ const binding = resolveSemanticBindingState(state, node, node.name);
+ if (
+ binding === undefined ||
+ (roles.has(expected.name) && roles.get(expected.name) !== binding) ||
+ (used.has(binding.bindingId) &&
+ used.get(binding.bindingId) !== expected.name)
+ )
+ return undefined;
+ roles.set(expected.name, binding);
+ used.set(binding.bindingId, expected.name);
+ }
+ const visitorKeys = javaScriptAstChildKeys(expected);
+ for (const [key, field] of Object.entries(
+ t.NODE_FIELDS[expected.type] ?? {},
+ )) {
+ if (
+ visitorKeys.includes(key) ||
+ (t.isIdentifier(expected) && key === "name" && !literalKey)
+ )
+ continue;
+ const fallback: unknown = Reflect.get(field, "default");
+ if (
+ JSON.stringify(Reflect.get(node, key) ?? fallback) !==
+ JSON.stringify(Reflect.get(expected, key) ?? fallback)
+ )
+ return undefined;
+ }
+ const children = childNodes(node),
+ expectedChildren = childNodes(expected);
+ if (children.length !== expectedChildren.length) return undefined;
+ for (const [index, child] of children.entries()) {
+ const expectedChild = expectedChildren[index];
+ if (expectedChild !== undefined)
+ pending.push({
+ actual: child,
+ pattern: expectedChild,
+ parent: expected,
+ });
+ }
+ }
+ return roles;
+};
+
+// Braces around one control-body statement do not add operations. Keep other
+// blocks, directives and extra statements intact; their semantics need proof.
+// Lexical declarations/references still pass through canonicalRoles' bijection.
+const controlBodyOperation = (node: t.Node): t.Node => {
+ while (
+ t.isBlockStatement(node) &&
+ node.directives.length === 0 &&
+ node.body.length === 1
+ ) {
+ const statement = node.body[0];
+ if (statement === undefined) break;
+ node = statement;
+ }
+ return node;
+};
diff --git a/src/domain/javascript/javascriptRpcEndpoints.test.ts b/src/domain/javascript/javascriptRpcEndpoints.test.ts
index 05062b4c7..b086470f3 100644
--- a/src/domain/javascript/javascriptRpcEndpoints.test.ts
+++ b/src/domain/javascript/javascriptRpcEndpoints.test.ts
@@ -195,6 +195,32 @@ describe("tRPC binding identity and bundled syntax", () => {
]);
});
+ it("retains one client initializer across variable redeclarations", () => {
+ expect(
+ rpcEndpoints(`
+ var c;
+ var c = createTRPCClient({});
+ var c;
+ c.users.query();
+
+ var replaced;
+ var replaced = createTRPCClient({});
+ replaced = pool;
+ replaced.posts.query();
+
+ var initializedTwice = createTRPCClient({});
+ var initializedTwice = pool;
+ initializedTwice.comments.query();
+
+ var conditional;
+ if (flag) { var conditional = createTRPCClient({}); }
+ conditional.groups.query();
+ `),
+ ).toEqual([
+ { kind: "network", value: "users", mechanism: "trpc:procedure:query" },
+ ]);
+ });
+
it("recognizes surviving factory names inside bundled call wrappers", () => {
expect(
rpcEndpoints(`
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.ts
index c4d8153c1..517ed5836 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.ts
@@ -18,6 +18,7 @@ import {
import {
semanticObjectPatternKeys,
semanticStaticPropertyKey,
+ semanticWriteTargets,
} from "./javascriptAstValues.js";
import type {
JavaScriptSemanticAnalysisState,
@@ -31,16 +32,14 @@ import {
resolveSemanticBindingFromScope,
semanticBindingId,
semanticScopeId,
+ semanticStableInitializer,
semanticVariableScope,
} from "./javascriptSemanticState.js";
import {
completeSemanticSteps,
traverseJavaScriptAstSteps,
} from "./javascriptSemanticTraversal.js";
-import {
- semanticNamespaceInteropOperand,
- semanticRequireOrigin,
-} from "./javascriptSemanticRequireOrigin.js";
+import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
import { collectSemanticMemberMutationsSteps } from "./javascriptSemanticMemberMutations.js";
import {
collectSemanticReturns,
@@ -49,7 +48,7 @@ import {
import { collectJavaScriptDerivedSemanticsSteps } from "./javascriptSemanticDerivedAnalysis.js";
import { evaluateSemanticProvenance } from "./javascriptSemanticValues.js";
import {
- collectElectronMemberWritesSteps,
+ collectJavaScriptIdentityWritesSteps,
electronExportPath,
electronMemberPath,
ELECTRON_MODULE,
@@ -64,6 +63,8 @@ import {
} from "./javascriptSourceParser.js";
import { isJavaScriptRpcClientFactory } from "./javascriptRpcEndpoints.js";
+import { createSemanticModuleInterop } from "./javascriptModuleInterop.js";
+import { SemanticPropertyPathCoverage } from "./javascriptSemanticPropertyPaths.js";
interface BindPatternInput {
readonly pattern: t.Node;
@@ -205,13 +206,10 @@ export function* classifyParsedJavaScriptRpcClientRootsSteps(
if (binding === undefined) return;
let client = clients.get(binding.bindingId);
if (client === undefined) {
- const [initializer] = binding.initializers;
+ const initializer = semanticStableInitializer(binding, state);
client =
initializer !== undefined &&
initializer.projection.length === 0 &&
- binding.initializers.length === 1 &&
- !binding.definitions.some(({ kind }) => kind === "assignment") &&
- !state.conditionalInitializers.has(initializer.node) &&
isJavaScriptRpcClientFactory(initializer.node);
clients.set(binding.bindingId, client);
}
@@ -374,6 +372,9 @@ export function* classifyParsedJavaScriptElectronBindingsSteps(
const facts = new Map<number, readonly string[]>();
const state = createState(file.program);
yield* collectDefinitionsSteps(file.program, state);
+ const interop = createSemanticModuleInterop(state);
+ const writes = new SemanticPropertyPathCoverage();
+ let collectedWrites = false;
const exportsByBinding = new Map<string, readonly string[] | null>();
const rootExport = (root: t.Node): readonly string[] | undefined => {
if (t.isIdentifier(root)) {
@@ -382,23 +383,45 @@ export function* classifyParsedJavaScriptElectronBindingsSteps(
if (binding === undefined) return undefined;
let exported = exportsByBinding.get(binding.bindingId);
if (exported === undefined) {
- exported = electronExport(binding, state);
+ exported = electronExport(binding, state, interop);
exportsByBinding.set(binding.bindingId, exported);
}
- return exported ?? undefined;
+ return collectedWrites && interop.invalidated(binding)
+ ? undefined
+ : (exported ?? undefined);
}
- const origin = semanticRequireOrigin(
- semanticNamespaceInteropOperand(root, state) ?? root,
- state,
- )?.origin;
+ const wrapped = interop.callOrigin(root);
+ const origin =
+ wrapped === undefined
+ ? semanticRequireOrigin(root, state)?.origin
+ : collectedWrites && interop.invalidatedCall(root)
+ ? undefined
+ : wrapped.origin;
return origin !== undefined && ELECTRON_MODULE.test(origin.specifier)
? electronExportPath(origin.importedPath)
: undefined;
};
- const writes = yield* collectElectronMemberWritesSteps(
+ yield* collectJavaScriptIdentityWritesSteps(
file.program,
- rootExport,
+ (root, kind) => {
+ if (kind === "opaque-call") return interop.opaqueMutationPath(root);
+ const exported = kind === "binding" ? undefined : rootExport(root);
+ return exported === undefined
+ ? (interop.intrinsicPath(root) ??
+ (kind === "member"
+ ? interop.boundIntrinsic(root)?.path
+ : undefined))
+ : ["electron", ...exported];
+ },
+ interop.intrinsicInvocation,
+ interop.staticString,
+ interop.isFreshObject,
+ (node, path) => {
+ if (path[0] === "electron") writes.retain(path);
+ else interop.retainWrite(node, path);
+ },
);
+ collectedWrites = true;
yield* traverseJavaScriptAstSteps(file.program, {
enter: (node) => {
if (
@@ -409,7 +432,10 @@ export function* classifyParsedJavaScriptElectronBindingsSteps(
return;
const { root, members } = electronMemberPath(node.callee);
const exported = rootExport(root);
- if (exported !== undefined && !writes.covers([...exported, ...members]))
+ if (
+ exported !== undefined &&
+ !writes.covers(["electron", ...exported, ...members])
+ )
facts.set(root.start ?? -1, exported);
},
});
@@ -421,19 +447,16 @@ export function* classifyParsedJavaScriptElectronBindingsSteps(
const electronExport = (
binding: JavaScriptSemanticBindingState,
state: JavaScriptSemanticAnalysisState,
+ interop: ReturnType<typeof createSemanticModuleInterop>,
): readonly string[] | null => {
- const initializers = namespacePreservingInitializers(binding, state);
- if (initializers === undefined) return null;
- const directOrigin = bindingOrigin(binding, initializers, state);
- const [initializer] = initializers;
- if (
- directOrigin === undefined &&
- (initializer === undefined ||
- initializers.length !== 1 ||
- initializers.length !== binding.initializers.length ||
- state.conditionalInitializers.has(initializer.node))
- )
- return null;
+ const reassigned = binding.definitions.some(
+ ({ kind }) => kind === "assignment",
+ );
+ const converted = interop.origin(binding);
+ if (reassigned && converted === undefined) return null;
+ const directOrigin = converted?.origin ?? bindingOrigin(binding, state);
+ const initializer = semanticStableInitializer(binding, state);
+ if (directOrigin === undefined && initializer === undefined) return null;
const provenance =
directOrigin === undefined
? evaluateSemanticProvenance(binding, state)
@@ -448,66 +471,17 @@ const electronExport = (
: null;
};
-/**
- * Return the initializers that can change which module a binding names.
- * Bundlers emit `name = __toESM(name)` after a CommonJS require; rewrapping
- * the binding's own value keeps every member, so it is not a reassignment.
- */
-const namespacePreservingInitializers = (
- binding: JavaScriptSemanticBindingState,
- state: JavaScriptSemanticAnalysisState,
-): JavaScriptSemanticBindingState["initializers"] | undefined => {
- const initializers = binding.initializers.filter(
- ({ node }) => !rewrapsOwnNamespace(binding, node, state),
- );
- const rewraps = binding.initializers.length - initializers.length;
- const assignments = binding.definitions.filter(
- ({ kind }) => kind === "assignment",
- ).length;
- return assignments === rewraps ? initializers : undefined;
-};
-
-const rewrapsOwnNamespace = (
- binding: JavaScriptSemanticBindingState,
- node: t.Node,
- state: JavaScriptSemanticAnalysisState,
-): boolean => {
- const assignment = state.parentsByNode.get(node);
- const operand = semanticNamespaceInteropOperand(node, state);
- return (
- t.isAssignmentExpression(assignment) &&
- assignment.operator === "=" &&
- assignment.right === node &&
- t.isIdentifier(assignment.left, { name: binding.name }) &&
- t.isIdentifier(operand, { name: binding.name }) &&
- !semanticResolutionBlocked(state, operand, operand.name) &&
- resolveSemanticBindingState(state, operand, operand.name) === binding
- );
-};
-
const bindingOrigin = (
binding: JavaScriptSemanticBindingState,
- initializers: JavaScriptSemanticBindingState["initializers"],
state: JavaScriptSemanticAnalysisState,
): JavaScriptModuleOrigin | undefined => {
if (binding.directOrigins.length > 0)
return binding.directOrigins.length === 1
? binding.directOrigins[0]
: undefined;
- const [initializer] = initializers;
- // A var/let declaration permits writes without proving one occurred.
- // Require one unconditional initializer and no actual binding writes.
- if (
- initializer === undefined ||
- initializers.length !== 1 ||
- state.conditionalInitializers.has(initializer.node)
- )
- return undefined;
- const origin = semanticRequireOrigin(
- semanticNamespaceInteropOperand(initializer.node, state) ??
- initializer.node,
- state,
- )?.origin;
+ const initializer = semanticStableInitializer(binding, state);
+ if (initializer === undefined) return undefined;
+ const origin = semanticRequireOrigin(initializer.node, state)?.origin;
const projection = initializer.projection;
return origin === undefined ||
!projection.every((key): key is string => typeof key === "string")
@@ -650,10 +624,11 @@ function* collectDefinitionsSteps(
for (const [index, { body, scope, parameters }] of functionBodies.entries()) {
if (index % 64 === 0) yield;
for (const parameter of parameters)
- for (const identifier of assignedPatternIdentifiers(
+ for (const identifier of semanticWriteTargets(
t.isTSParameterProperty(parameter) ? parameter.parameter : parameter,
))
- copyParameterToBody({ identifier, body, scope, state });
+ if (t.isIdentifier(identifier))
+ copyParameterToBody({ identifier, body, scope, state });
}
}
@@ -801,16 +776,18 @@ const bindAssignment = (
state,
);
else
- for (const identifier of assignedPatternIdentifiers(node.left))
- addAssignment(identifier, node, scope, state);
+ for (const identifier of semanticWriteTargets(node.left))
+ if (t.isIdentifier(identifier))
+ addAssignment(identifier, node, scope, state);
} else if (t.isUpdateExpression(node) && t.isIdentifier(node.argument))
addAssignment(node.argument, node, scope, state);
else if (t.isForOfStatement(node) || t.isForInStatement(node))
for (const pattern of t.isVariableDeclaration(node.left)
? node.left.declarations.map(({ id }) => id)
: [node.left]) {
- for (const identifier of assignedPatternIdentifiers(pattern))
- addAssignment(identifier, node, scope, state);
+ for (const identifier of semanticWriteTargets(pattern))
+ if (t.isIdentifier(identifier))
+ addAssignment(identifier, node, scope, state);
if (t.isForOfStatement(node))
// Keep the loop value unknown, but preserve references yielded into
// each bound slot so writes/escapes can reach their iterable origins.
@@ -825,30 +802,6 @@ const bindAssignment = (
}
};
-const assignedPatternIdentifiers = (
- pattern: t.Node,
-): readonly t.Identifier[] => {
- const identifiers: t.Identifier[] = [];
- const pending = [pattern];
- while (pending.length > 0) {
- const node = pending.pop();
- if (node === undefined) continue;
- if (t.isIdentifier(node)) identifiers.push(node);
- else if (t.isRestElement(node)) pending.push(node.argument);
- else if (t.isAssignmentPattern(node)) pending.push(node.left);
- else if (t.isArrayPattern(node)) {
- for (const element of node.elements)
- if (element !== null) pending.push(element);
- } else if (t.isObjectPattern(node)) {
- for (const property of node.properties)
- pending.push(
- t.isRestElement(property) ? property.argument : property.value,
- );
- }
- }
- return identifiers;
-};
-
const nestedScope = (
node: t.Node,
parent: t.Node | null,
diff --git a/src/domain/javascript/javascriptSemanticMemberMutations.ts b/src/domain/javascript/javascriptSemanticMemberMutations.ts
index 62df4c38c..35f3a0ca9 100644
--- a/src/domain/javascript/javascriptSemanticMemberMutations.ts
+++ b/src/domain/javascript/javascriptSemanticMemberMutations.ts
@@ -33,7 +33,7 @@ import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
import { traverseJavaScriptAstSteps } from "./javascriptSemanticTraversal.js";
import {
semanticStaticPropertyKey,
- semanticMemberWriteTargets,
+ semanticWriteTargets,
unwrapJavaScriptExpression,
} from "./javascriptAstValues.js";
@@ -401,14 +401,15 @@ export function* collectSemanticMemberMutationsSteps(
markEscaped(expression.object, mutation);
};
const markTarget = (node: t.Node, mutation: t.Node): void => {
- 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) => {
diff --git a/src/domain/javascript/javascriptSemanticRequireOrigin.ts b/src/domain/javascript/javascriptSemanticRequireOrigin.ts
index ec9ec9ae6..00f0805ba 100644
--- a/src/domain/javascript/javascriptSemanticRequireOrigin.ts
+++ b/src/domain/javascript/javascriptSemanticRequireOrigin.ts
@@ -5,7 +5,6 @@ import {
resolveSemanticBindingState,
semanticResolutionBlocked,
type JavaScriptSemanticAnalysisState,
- type JavaScriptSemanticBindingState,
} from "./javascriptSemanticState.js";
import {
semanticStaticPropertyKey,
@@ -59,73 +58,3 @@ export const semanticRequireOrigin = (
call: current,
};
};
-
-// esbuild/Rolldown, TypeScript, and Babel emit these helpers for namespace
-// imports of CommonJS modules; each returns an object exposing every own
-// member of its operand, so member paths through the result are unchanged.
-// Helper bodies are not evaluated: recognition trusts a single program-scope
-// function definition under one of these emitted names.
-const NAMESPACE_INTEROP_HELPERS = new Set([
- "__importStar",
- "__toESM",
- "_interopRequireWildcard",
-]);
-
-/** Return the module operand of a locally declared namespace interop helper. */
-export const semanticNamespaceInteropOperand = (
- node: t.Node,
- state: JavaScriptSemanticAnalysisState,
-): t.Expression | undefined => {
- const call = unwrapJavaScriptExpression(node).node;
- if (
- !t.isCallExpression(call) ||
- !t.isIdentifier(call.callee) ||
- !NAMESPACE_INTEROP_HELPERS.has(call.callee.name) ||
- semanticResolutionBlocked(state, call.callee, call.callee.name)
- )
- return undefined;
- const helper = resolveSemanticBindingState(
- state,
- call.callee,
- call.callee.name,
- );
- const [operand] = call.arguments;
- return helper !== undefined &&
- emittedInteropHelper(helper, state) &&
- t.isExpression(operand)
- ? operand
- : undefined;
-};
-
-// Emitters declare each helper once at program scope as a function, an
-// arrow/function expression, or `(this && this.name) || <function>`.
-const emittedInteropHelper = (
- helper: JavaScriptSemanticBindingState,
- state: JavaScriptSemanticAnalysisState,
-): boolean => {
- const [initializer] = helper.initializers;
- if (
- initializer === undefined ||
- helper.initializers.length !== 1 ||
- helper.definitions.length !== 1 ||
- (helper.kind !== "function" && helper.kind !== "variable") ||
- state.scopesById.get(helper.scopeId)?.kind !== "program"
- )
- return false;
- const value = unwrapJavaScriptExpression(initializer.node).node;
- const emitted =
- t.isLogicalExpression(value, { operator: "||" }) &&
- t.isLogicalExpression(unwrapJavaScriptExpression(value.left).node, {
- operator: "&&",
- })
- ? unwrapJavaScriptExpression(value.right).node
- : value;
- return (
- t.isFunctionDeclaration(emitted) ||
- t.isFunctionExpression(emitted) ||
- t.isArrowFunctionExpression(emitted) ||
- (t.isCallExpression(emitted) &&
- (t.isFunctionExpression(emitted.callee) ||
- t.isArrowFunctionExpression(emitted.callee)))
- );
-};
diff --git a/src/domain/javascript/javascriptSemanticState.ts b/src/domain/javascript/javascriptSemanticState.ts
index 2024d7486..e07caad99 100644
--- a/src/domain/javascript/javascriptSemanticState.ts
+++ b/src/domain/javascript/javascriptSemanticState.ts
@@ -75,6 +75,30 @@ export interface JavaScriptSemanticAnalysisState {
readonly conditionalInitializers: WeakSet<t.Node>;
}
+/**
+ * Return one unconditional source initializer for a declared lexical binding.
+ * Repeated variable declarations without another initializer do not write it.
+ * This establishes a stable source fact only; it does not prove immutability or
+ * that the declaration has executed at a particular program point.
+ */
+export const semanticStableInitializer = (
+ binding: JavaScriptSemanticBindingState | undefined,
+ state: JavaScriptSemanticAnalysisState,
+): JavaScriptSemanticBindingState["initializers"][number] | undefined => {
+ const [initializer] = binding?.initializers ?? [];
+ const [definition] = binding?.definitions ?? [];
+ return binding !== undefined &&
+ ((definition?.kind === "variable" &&
+ binding.definitions.every(({ kind }) => kind === "variable")) ||
+ (binding.definitions.length === 1 &&
+ (definition?.kind === "function" || definition?.kind === "class"))) &&
+ binding.initializers.length === 1 &&
+ initializer !== undefined &&
+ !state.conditionalInitializers.has(initializer.node)
+ ? initializer
+ : undefined;
+};
+
/** Return the active scope from a non-empty construction stack. */
export const currentSemanticScope = (
stack: readonly JavaScriptSemanticScopeState[],
diff --git a/src/domain/javascript/javascriptSemanticTraversal.ts b/src/domain/javascript/javascriptSemanticTraversal.ts
index 16960ba8f..e2e351254 100644
--- a/src/domain/javascript/javascriptSemanticTraversal.ts
+++ b/src/domain/javascript/javascriptSemanticTraversal.ts
@@ -82,8 +82,7 @@ interface TraversalFrame {
* not be reintroduced (they diverge on loc/comment fields and ordering).
*/
export const childNodes = (node: t.Node): t.Node[] => {
- const keys = t.VISITOR_KEYS[node.type];
- if (keys === undefined) return [];
+ const keys = javaScriptAstChildKeys(node);
const children: t.Node[] = [];
for (const key of keys) {
const value: unknown = Reflect.get(node, key);
@@ -98,3 +97,7 @@ export const childNodes = (node: t.Node): t.Node[] => {
}
return children;
};
+
+/** Child-bearing fields; shared by traversal and structural AST comparison. */
+export const javaScriptAstChildKeys = (node: t.Node): readonly string[] =>
+ t.VISITOR_KEYS[node.type] ?? [];
diff --git a/tests/acceptance/applications/electronModuleInteropCli.test.ts b/tests/acceptance/applications/electronModuleInteropCli.test.ts
new file mode 100644
index 000000000..badad8696
--- /dev/null
+++ b/tests/acceptance/applications/electronModuleInteropCli.test.ts
@@ -0,0 +1,180 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { expect } from "vitest";
+import { z } from "zod";
+
+import { javascriptApplicationAnalysisResultSchema } from "../../../src/domain/javascript/javascriptApplicationAnalysis.js";
+import { ROLLDOWN_MODULE_INTEROP } from "../../../src/domain/javascript/javascriptModuleInterop.fixture.js";
+import { connectLocalToolsMcp } from "../../fixtures/localToolsMcp.js";
+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
+import { cliTest } from "../../support/cli/cliFixture.js";
+
+const INTRINSIC_MUTATIONS = [
+ ["poisoned.cjs", "({Object} = replacements);"],
+ [
+ "projected.cjs",
+ 'const {defineProperty:change} = Object; change(Object,"create",{value:customCreate});',
+ ],
+ [
+ "decorated.cjs",
+ '@(() => Object) class metadata {}; Object.defineProperty(metadata,"create",{value:customCreate});',
+ ],
+ [
+ "uncurried.cjs",
+ 'const change = Function.prototype.call.bind(Object.defineProperty,null); change(Object,"create",{value:customCreate});',
+ ],
+ [
+ "generic-bind.cjs",
+ 'const change = Function.prototype.bind.call(Object.defineProperty,null); change(Object,"create",{value:customCreate});',
+ ],
+ [
+ "replaced-apply.cjs",
+ 'Reflect.apply = Object.defineProperty; Reflect.apply(Object,"create",{value:customCreate});',
+ ],
+ [
+ "bound.cjs",
+ 'const change = Object.defineProperty.bind(null,Object,"create"); change({value:customCreate});',
+ ],
+ ["receiver.cjs", 'Reflect.set({},"create",customCreate,Object);'],
+] as const;
+
+cliTest.for(["CLI", "stdio MCP"] as const)(
+ "retains converted Electron windows and preload evidence through %s",
+ async (surface, { cli }) => {
+ const root = await createTestTempDirectory("rea-electron-interop-");
+ await writeFile(
+ join(root, "package.json"),
+ JSON.stringify({ main: "main.cjs" }),
+ );
+ await writeFile(
+ join(root, "preload.js"),
+ 'throw new Error("must stay inert");',
+ );
+ for (const [name, mutation] of INTRINSIC_MUTATIONS)
+ await writeFile(
+ join(root, name),
+ `${mutation}
+ ${ROLLDOWN_MODULE_INTEROP}
+ let poisoned = require("electron");
+ poisoned = __toESM(poisoned, 1);
+ new poisoned.BrowserWindow({});
+ throw new Error("must not execute poisoned source");`,
+ );
+ const source = `const metadata = {};
+ Object.defineProperty(metadata,"x",{value:1});
+ const decorateMetadata = Object.defineProperty.bind(null,metadata,"bound");
+ decorateMetadata({value:1});
+ const localFunction = () => {};
+ Object.defineProperty(localFunction,"x",{value:1});
+ const localClass = class {};
+ Object.defineProperty(localClass,"x",{value:1});
+ const localRegExp = /local/;
+ Object.defineProperty(localRegExp,"x",{value:1});
+ Object.defineProperty(hoistedFunction,"x",{value:1});
+ function hoistedFunction() {}
+ const captured = Object.defineProperty;
+ Object.defineProperty = custom;
+ ${ROLLDOWN_MODULE_INTEROP.replace("__defProp = Object.defineProperty", "__defProp = captured")}
+ let electron = require("electron");
+ electron = __toESM(electron, 1);
+ new electron.BrowserWindow({webPreferences:{preload:"./preload.js"}});
+ new electron.BrowserWindow({webPreferences:{preload:runtimePath}});
+ var direct;
+ var direct = require("electron");
+ var direct;
+ new direct.BrowserWindow({});
+ const fresh = __toESM(require("electron"), 1);
+ new fresh.BrowserWindow({});
+ const {BrowserWindow: ProjectedWindow} = __toESM(require("electron"));
+ new ProjectedWindow({});
+ const nonNode = __toESM(require("electron"), 0);
+ new nonNode.BrowserWindow({});
+ function identity(mod) {return mod;}
+ const passthrough = identity(require("electron"));
+ new passthrough.BrowserWindow({});
+ const __importStar = () => ({BrowserWindow:FakeWindow});
+ const fake = __importStar(require("electron"));
+ new fake.BrowserWindow({});
+ function decoy(electron) {new electron.BrowserWindow({});}
+ require("./poisoned.cjs");
+ require("./projected.cjs");
+ require("./decorated.cjs");
+ require("./bound.cjs");
+ require("./uncurried.cjs");
+ require("./generic-bind.cjs");
+ require("./replaced-apply.cjs");
+ require("./receiver.cjs");
+ throw new Error("must not execute main");
+ `;
+ await writeFile(join(root, "main.cjs"), source);
+ let document: unknown;
+ if (surface === "CLI") {
+ const response = await cli.run({
+ arguments: ["analyze-javascript-application", root, "--json"],
+ });
+ expect(response.exitCode, response.stderr).toBe(0);
+ document = response.json;
+ } else {
+ const { call } = await connectLocalToolsMcp();
+ const response = await call("analyze_javascript_application", {
+ input_path: root,
+ });
+ expect(response.isError, JSON.stringify(response)).not.toBe(true);
+ document = response.structuredContent;
+ }
+ const result = z
+ .object({ normalized_result: javascriptApplicationAnalysisResultSchema })
+ .parse(document).normalized_result;
+ expect(result.summary).toMatchObject({
+ browser_windows: 7,
+ preload_entrypoints: 1,
+ });
+ expect(result.statistics.parse_failures).toBe(0);
+ expect(result.statistics.parsed_javascript_files).toBe(10);
+ const windows = result.graph.nodes.filter(
+ ({ kind }) => kind === "browser-window",
+ );
+ expect(windows).toHaveLength(7);
+ const expectedLines = source
+ .split("\n")
+ .flatMap((line, index) =>
+ /^\s*new (?:(?:electron|direct|fresh|passthrough|nonNode)\.BrowserWindow|ProjectedWindow)\(/u.test(
+ line,
+ )
+ ? [index + 1]
+ : [],
+ );
+ const observedLines = windows.flatMap((window) => {
+ const location = window.observations[0]?.evidence.location;
+ return location?.available && location.value.kind === "source-range"
+ ? [location.value.start.line]
+ : [];
+ });
+ expect(observedLines.toSorted()).toEqual(expectedLines.toSorted());
+ for (const window of windows) {
+ expect(window.observations[0]?.evidence.location).toMatchObject({
+ available: true,
+ value: { kind: "source-range", source: "main.cjs" },
+ });
+ }
+ expect(
+ windows.flatMap((window) =>
+ window.observations.map(({ properties }) => properties.web_preferences),
+ ),
+ ).toEqual(
+ expect.arrayContaining([
+ expect.arrayContaining([
+ expect.objectContaining({
+ name: "preload",
+ value: {
+ status: "dynamic",
+ value: null,
+ expression: "runtimePath",
+ },
+ }),
+ ]),
+ ]),
+ );
+ },
+);