refactor: consolidate boundary semantics and prune redundant tests

Share parser modes and collision-free composite keys, enforce architecture guards, and consolidate redundant unit assertions into filesystem, CLI, MCP, and producer-backed workflows. Preserve concurrent upstream boundary fixes and exclude legacy Objective-C class-name bookkeeping labels.

Validation: source/composition suites (3358 passing), focused canonical digest and MCP checks, typecheck/lint, Knip, formatting, architecture guards, and real Foundation archive and Apple legacy simulator CLI/MCP verification. No real Hopper, Ghidra, or IDA verification claim.

src/application/javascript/ElectronBoundaryGraphNative.ts

@@ -7,6 +7,7 @@ import {
   type JavaScriptArtifactGraphCoverage,
 } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
+import { compositeKey } from "../../domain/unicodeCodePointOrder.js";
 import {
   addElectronInferenceEdge,
   electronFindingSourceNode,
@@ -50,7 +51,9 @@ const addNativeBinding = (input: NativeBindingInput): void => {
     identity: electronObservationIdentity(
       context,
       "javascript-requested-native-export",
-      `${file.path}:${value.specifier}:${value.binding_kind}:${value.members.join("\0")}:${electronRangeKey(value.location)}`,
+      // Members are a variable-length source-derived list: compositeKey keeps
+      // ["a\0b"] distinct from ["a", "b"] inside the digested identity.
+      `${file.path}:${value.specifier}:${value.binding_kind}:${compositeKey(value.members)}:${electronRangeKey(value.location)}`,
     ),
     observations: [
       {

src/application/javascript/JavaScriptApplicationEmptyLiterals.test.ts

@@ -31,28 +31,49 @@ const analyzeSource = async (
   );
 };
 
-it.each([
-  "fetch('');",
-  "new WebSocket('');",
-  "navigator.serviceWorker.register('');",
-  "new Worker('');",
-  "const x = require('');",
-  "import y from ''; y();",
-  "import('');",
-  "localStorage.getItem('');",
-  "localStorage.setItem('', 1);",
-  "indexedDB.open('');",
-  "win.loadFile('');",
-  "win.loadURL('');",
-  "app.get('', handler);",
-  "process.on('', () => 1);",
-  "const { EventEmitter } = require('events'); new EventEmitter().on('', () => 1);",
-  "const { spawn } = require('child_process'); spawn('/bin/x').on('', () => 1);",
-  "const { ipcMain } = require('electron'); ipcMain.handle('', () => 1);",
-  "const { ipcRenderer } = require('electron'); ipcRenderer.invoke('');",
-  "const { contextBridge } = require('electron'); contextBridge.exposeInMainWorld('', {});",
-])("analyzes the legal empty string literal in %s", async (source) => {
-  await expect(analyzeSource(source)).resolves.toBeDefined();
+it("retains empty literal evidence across the application boundary surfaces", async () => {
+  const sources = [
+    "fetch('');",
+    "new WebSocket('');",
+    "navigator.serviceWorker.register('');",
+    "new Worker('');",
+    "const x = require('');",
+    "import y from ''; y();",
+    "import('');",
+    "localStorage.getItem('');",
+    "localStorage.setItem('', 1);",
+    "indexedDB.open('');",
+    "win.loadFile('');",
+    "win.loadURL('');",
+    "app.get('', handler);",
+    "process.on('', () => 1);",
+    "const { EventEmitter } = require('events'); new EventEmitter().on('', () => 1);",
+    "const { spawn } = require('child_process'); spawn('/bin/x').on('', () => 1);",
+    "const { ipcMain } = require('electron'); ipcMain.handle('', () => 1);",
+    "const { ipcRenderer } = require('electron'); ipcRenderer.invoke('');",
+    "const { contextBridge } = require('electron'); contextBridge.exposeInMainWorld('', {});",
+  ];
+  const output = await analyzeSource(sources.join("\n"));
+  expect(output.graph.nodes).toEqual(
+    expect.arrayContaining([
+      expect.objectContaining({ kind: "endpoint" }),
+      expect.objectContaining({ kind: "worker" }),
+      expect.objectContaining({ kind: "ipc-channel" }),
+      expect.objectContaining({ kind: "context-bridge-api" }),
+    ]),
+  );
+  expect(output.semantic_graph?.nodes).toEqual(
+    expect.arrayContaining([
+      expect.objectContaining({
+        kind: "request",
+        properties: expect.objectContaining({ endpoint: "" }),
+      }),
+      expect.objectContaining({
+        kind: "event",
+        properties: expect.objectContaining({ event_name: "" }),
+      }),
+    ]),
+  );
 });
 
 it("analyzes a plain long-line loader without package metadata", async () => {

src/application/javascript/JavaScriptModuleSpecifierPaths.test.ts

@@ -159,21 +159,26 @@ describe("module specifier punctuation", () => {
 });
 
 describe("ESM module URL decoding", () => {
-  it.each([
-    ["./plain.mjs", "plain.mjs"],
-    ["./space%20name.mjs", "space name.mjs"],
-    ["./pr%C3%A9load.mjs", "préload.mjs"],
-    ["./name%3F%23.mjs", "name?#.mjs"],
-    ["./percent%2520.mjs?cache=1#v2", "percent%20.mjs"],
-  ])(
-    "points %s imports to the file loaded by Node",
-    async (specifier, target) => {
-      const root = await createTestTempDirectory("rea-module-url-");
-      const main = join(root, "main.mjs");
-      await writeFile(
-        main,
-        `import value from ${JSON.stringify(specifier)}; console.log(value);`,
-      );
+  it("resolves URL-encoded imports to the files loaded by Node", async () => {
+    const cases = [
+      ["./plain.mjs", "plain.mjs"],
+      ["./space%20name.mjs", "space name.mjs"],
+      ["./pr%C3%A9load.mjs", "préload.mjs"],
+      ["./name%3F%23.mjs", "name?#.mjs"],
+      ["./percent%2520.mjs?cache=1#v2", "percent%20.mjs"],
+    ] as const;
+    const root = await createTestTempDirectory("rea-module-url-");
+    const main = join(root, "main.mjs");
+    await writeFile(
+      main,
+      cases
+        .map(
+          ([specifier], index) =>
+            `import value${index} from ${JSON.stringify(specifier)}; console.log(value${index});`,
+        )
+        .join("\n"),
+    );
+    for (const [specifier, target] of cases) {
       await writeFile(
         join(root, target),
         `export default ${JSON.stringify(target)};`,
@@ -181,19 +186,23 @@ describe("ESM module URL decoding", () => {
       const encoded = specifier.slice(2).split("?", 1)[0]?.split("#", 1)[0];
       if (encoded !== undefined && encoded !== target)
         await writeFile(join(root, encoded), 'export default "encoded decoy";');
-      const native = await promisify(execFile)(process.execPath, [main], {
-        timeout: 5_000,
-      });
-      expect(native.stdout.trim()).toBe(target);
+    }
+    const native = await promisify(execFile)(process.execPath, [main], {
+      timeout: 5_000,
+    });
+    expect(native.stdout.trim().split("\n")).toEqual(
+      cases.map(([, target]) => target),
+    );
 
-      const result = await analyzeJavaScriptApplication({
-        input_path: root,
-        format: "directory",
-      });
-      if (!result.ok) throw result.error;
-      const { graph } = javascriptApplicationAnalysisResultSchema.parse(
-        result.value.normalized_result,
-      );
+    const result = await analyzeJavaScriptApplication({
+      input_path: root,
+      format: "directory",
+    });
+    if (!result.ok) throw result.error;
+    const { graph } = javascriptApplicationAnalysisResultSchema.parse(
+      result.value.normalized_result,
+    );
+    for (const [specifier, target] of cases) {
       const imports = graph.edges.filter(
         (edge) =>
           edge.relation === "imports" &&
@@ -202,8 +211,8 @@ describe("ESM module URL decoding", () => {
       expect(imports.length).toBeGreaterThan(0);
       for (const edge of imports)
         expect(edge.properties.resolved_path).toBe(target);
-    },
-  );
+    }
+  });
 
   it("preserves CommonJS literal percent names", () => {
     expect(
@@ -249,26 +258,21 @@ const packageEntryUrlCases = [
   ["main", "./actual#file.cjs", "actual#file.cjs"],
 ] as const;
 
-describe("package exports URL paths", () => {
-  it.each(
-    (["import", "require"] as const).flatMap((moduleKind) =>
-      packageEntryUrlCases.map(([field, declaredPath, target]) => ({
-        moduleKind,
-        field,
-        declaredPath,
-        target,
-      })),
-    ),
-  )(
-    "matches Node $moduleKind for $field $declaredPath",
-    async ({ moduleKind, field, declaredPath, target }) => {
-      const root = await createTestTempDirectory("rea-package-export-url-");
-      const packageRoot = join(root, "node_modules", "fixture");
+it.each(["import", "require"] as const)(
+  "matches Node %s across package exports and main path representations",
+  async (moduleKind) => {
+    const root = await createTestTempDirectory("rea-package-export-url-");
+    for (const [
+      index,
+      [field, declaredPath, target],
+    ] of packageEntryUrlCases.entries()) {
+      const name = `fixture-${index}`;
+      const packageRoot = join(root, "node_modules", name);
       await mkdir(packageRoot, { recursive: true });
       await writeFile(
         join(packageRoot, "package.json"),
         JSON.stringify({
-          name: "fixture",
+          name,
           [field]: declaredPath,
         }),
       );
@@ -282,41 +286,54 @@ describe("package exports URL paths", () => {
           join(packageRoot, literal),
           'module.exports="literal decoy";',
         );
-      const main = join(
-        root,
-        moduleKind === "import" ? "main.mjs" : "main.cjs",
-      );
-      await writeFile(
-        main,
-        moduleKind === "import"
-          ? 'import value from "fixture"; console.log(value);'
-          : 'console.log(require("fixture"));',
-      );
-      const native = await promisify(execFile)(process.execPath, [main], {
-        timeout: 5_000,
-      });
-      expect(native.stdout.trim()).toBe(target);
-      const result = await analyzeJavaScriptApplication({
-        input_path: root,
-        format: "directory",
-      });
-      if (!result.ok) throw result.error;
-      const { graph } = javascriptApplicationAnalysisResultSchema.parse(
-        result.value.normalized_result,
-      );
+    }
+    const main = join(root, moduleKind === "import" ? "main.mjs" : "main.cjs");
+    await writeFile(
+      main,
+      packageEntryUrlCases
+        .map((_, index) =>
+          moduleKind === "import"
+            ? `import value${index} from "fixture-${index}"; console.log(value${index});`
+            : `console.log(require("fixture-${index}"));`,
+        )
+        .join("\n"),
+    );
+    const native = await promisify(execFile)(process.execPath, [main], {
+      timeout: 5_000,
+    });
+    expect(native.stdout.trim().split("\n")).toEqual(
+      packageEntryUrlCases.map(([, , target]) => target),
+    );
+    const result = await analyzeJavaScriptApplication({
+      input_path: root,
+      format: "directory",
+    });
+    if (!result.ok) throw result.error;
+    const { graph } = javascriptApplicationAnalysisResultSchema.parse(
+      result.value.normalized_result,
+    );
+    for (const [
+      index,
+      [field, declaredPath, target],
+    ] of packageEntryUrlCases.entries()) {
       const imports = graph.edges.filter(
         (edge) =>
           edge.relation === "imports" &&
-          edge.properties.specifier === "fixture",
+          edge.properties.specifier === `fixture-${index}`,
       );
-      expect(imports.length).toBeGreaterThan(0);
+      expect(
+        imports.length,
+        `${moduleKind}: ${field} ${declaredPath}`,
+      ).toBeGreaterThan(0);
       for (const edge of imports)
         expect(edge.properties.resolved_path).toBe(
-          `node_modules/fixture/${target}`,
+          `node_modules/fixture-${index}/${target}`,
         );
-    },
-  );
+    }
+  },
+);
 
+describe("package exports URL path rejections", () => {
   it.each(
     (["import", "require"] as const).flatMap((moduleKind) =>
       [