test(vnext): close worker evidence gaps

Author: Light2Dark

docs/adr/0004-isolated-parser-execution.md

@@ -238,10 +238,10 @@ The latest local Node 24 / Chromium 149 / arm64 macOS sample recorded:
 
 | Output | Raw | gzip |
 | --- | ---: | ---: |
-| Core-only fixture | 24,462 B | 7,475 B |
-| PostgreSQL transitive worker graph | 320,495 B | 67,214 B |
-| BigQuery transitive worker graph | 224,648 B | 50,205 B |
-| Complete worker fixture | 549,003 B | 117,941 B |
+| Core-only fixture | 24,680 B | 7,572 B |
+| PostgreSQL transitive worker graph | 321,156 B | 67,396 B |
+| BigQuery transitive worker graph | 225,309 B | 50,389 B |
+| Complete worker fixture | 549,885 B | 118,160 B |
 
 The core module trace contained no `node-sql-parser` module. No dialect
 resource loaded before explicit construction. A single static module worker
@@ -254,10 +254,10 @@ One sequential cold/warm run on the shared worker measured:
 
 | Dialect | Grammar load and initialization | First parse | First round trip | Warm parse | Warm round trip |
 | --- | ---: | ---: | ---: | ---: | ---: |
-| PostgreSQL | 8.7 ms | 2.6 ms | 11.5 ms | 0.2 ms | 0.3 ms |
-| BigQuery | 4.3 ms | 2.3 ms | 6.6 ms | 0.4 ms | 0.5 ms |
+| PostgreSQL | 8.2 ms | 2.3 ms | 10.7 ms | 0.2 ms | 0.2 ms |
+| BigQuery | 4.3 ms | 2.2 ms | 6.7 ms | 0.3 ms | 0.3 ms |
 
-The worker ready handshake took 7.0 ms in that run.
+The worker ready handshake took 7.4 ms in that run.
 
 These numbers establish packaging feasibility and initial size guards. They
 are not percentile claims. Stable latency decisions require repeated,

scripts/worker-placement.mjs

@@ -428,40 +428,50 @@ function verifyWorkerAssets(workersDirectory) {
 }
 
 function verifyCoreExcludesParser(coreDirectory) {
-  const moduleIds = JSON.parse(
-    readFileSync(join(coreDirectory, "module-ids.json"), "utf8"),
+  const trace = requireModuleTrace(
+    join(coreDirectory, "core-module-trace.json"),
   );
-  if (!Array.isArray(moduleIds)) {
-    throw new Error("Core module trace was not an array");
+  const chunks = chunkMap(trace, coreDirectory);
+  const entries = trace.chunks.filter(
+    (chunk) => chunk.isEntry === true,
+  );
+  if (entries.length !== 1) {
+    throw new Error("Core module trace did not contain exactly one entry");
   }
-  const parserModules = moduleIds.filter(
-    (moduleId) =>
-      typeof moduleId === "string" &&
-      moduleId.includes("/node-sql-parser/"),
+  const reachable = reachableChunks(
+    chunks,
+    [entries[0].fileName],
+    true,
   );
-  if (parserModules.length > 0) {
+  const javascriptFiles = listFiles(coreDirectory)
+    .filter((path) => extname(path) === ".js")
+    .map((path) =>
+      path.slice(coreDirectory.length + 1).split(sep).join("/"),
+    );
+  const orphanJavascript = javascriptFiles.filter(
+    (fileName) => !reachable.has(fileName),
+  );
+  if (orphanJavascript.length > 0) {
     throw new Error(
-      `Core-only build included parser modules: ${parserModules.join(", ")}`,
+      `Core-only build emitted unreachable JavaScript: ${orphanJavascript.join(", ")}`,
     );
   }
-  const workerModules = moduleIds.filter(
+  const moduleIds = trace.chunks.flatMap((chunk) => chunk.moduleIds);
+  const parserModules = moduleIds.filter(
     (moduleId) =>
       typeof moduleId === "string" &&
-      /(?:^|[/\\])[^/\\]*worker[^/\\]*\.[cm]?[jt]s$/i.test(moduleId),
+      moduleId.includes("/node-sql-parser/"),
   );
-  if (workerModules.length > 0) {
+  if (parserModules.length > 0) {
     throw new Error(
-      `Core-only build included worker modules: ${workerModules.join(", ")}`,
+      `Core-only build included parser modules: ${parserModules.join(", ")}`,
     );
   }
   for (const path of listFiles(coreDirectory)) {
     const extension = extname(path);
     if (extension !== ".js" && extension !== ".json") {
       continue;
     }
-    if (/worker/i.test(basename(path))) {
-      throw new Error(`Core-only build emitted worker asset ${basename(path)}`);
-    }
     const contents = readFileSync(path, "utf8");
     const marker = PARSER_MARKERS.find((candidate) =>
       contents.includes(candidate),
@@ -471,13 +481,8 @@ function verifyCoreExcludesParser(coreDirectory) {
         `Core-only output ${basename(path)} contained parser marker ${marker}`,
       );
     }
-    if (extension === ".js" && /new\s+Worker\s*\(/.test(contents)) {
-      throw new Error(
-        `Core-only output ${basename(path)} contained a worker constructor`,
-      );
-    }
   }
-  return moduleIds.length;
+  return new Set(moduleIds).size;
 }
 
 function verifySsrImport(fixtureDirectory) {
@@ -697,7 +702,12 @@ try {
   const fixtureDirectory = join(temporaryDirectory, "fixture");
   cpSync(fixtureSource, fixtureDirectory, { recursive: true });
   runPackageManager(
-    ["install", "--frozen-lockfile", "--ignore-scripts"],
+    [
+      "install",
+      "--frozen-lockfile",
+      "--ignore-scripts",
+      "--offline",
+    ],
     fixtureDirectory,
   );
 

test/worker-placement/README.md

@@ -7,9 +7,9 @@ fixture dependencies are installed before the exact tarball is extracted, and
 the harness verifies that its exact `5.4.0` version matches the packed
 package's dependency.
 
-The minified Vite 8 single-worker baseline is 67,214 gzip bytes for the
-PostgreSQL transitive graph, 50,205 gzip bytes for the BigQuery transitive
-graph, and 117,941 gzip/549,003 raw bytes for the complete worker build output.
+The minified Vite 8 single-worker baseline is 67,396 gzip bytes for the
+PostgreSQL transitive graph, 50,389 gzip bytes for the BigQuery transitive
+graph, and 118,160 gzip/549,885 raw bytes for the complete worker build output.
 The PostgreSQL and BigQuery figures each include their transitive shared
 chunks; the report also identifies those shared chunks explicitly. The
 fail-closed ceilings include small explicit headroom over that measured

test/worker-placement/src/parser-worker.js

@@ -151,14 +151,57 @@ function resourceEntries() {
   }));
 }
 
-async function syntheticCleanupPoisonEvidence() {
+async function syntheticCleanupEvidence() {
+  const successfulTarget = {};
+  const originalNodeSqlParser = Object.freeze({
+    owner: "original-node-sql-parser",
+  });
+  const originalGlobal = () => "original-global";
+  Object.defineProperties(successfulTarget, {
+    NodeSQLParser: {
+      configurable: true,
+      enumerable: true,
+      value: originalNodeSqlParser,
+      writable: false,
+    },
+    global: {
+      configurable: true,
+      enumerable: false,
+      get: originalGlobal,
+    },
+  });
+  const successfulLoad = createGuardedModuleLoader(successfulTarget);
+  let successfulEvaluations = 0;
+  const successful = await successfulLoad(async () => {
+    successfulEvaluations += 1;
+    Object.defineProperties(successfulTarget, {
+      NodeSQLParser: {
+        configurable: true,
+        enumerable: false,
+        value: "temporary-node-sql-parser",
+        writable: true,
+      },
+      global: {
+        configurable: true,
+        enumerable: true,
+        value: "temporary-global",
+        writable: true,
+      },
+    });
+    return "first-load";
+  });
+  const reusable = await successfulLoad(async () => {
+    successfulEvaluations += 1;
+    return "second-load";
+  });
+
   const target = {};
   const load = createGuardedModuleLoader(target);
-  let evaluations = 0;
+  let poisonedEvaluations = 0;
   let cleanupFailed = false;
   try {
     await load(async () => {
-      evaluations += 1;
+      poisonedEvaluations += 1;
       Object.defineProperty(target, "NodeSQLParser", {
         configurable: false,
         value: "synthetic-pollution",
@@ -171,16 +214,21 @@ async function syntheticCleanupPoisonEvidence() {
   let poisonedRetryFailed = false;
   try {
     await load(async () => {
-      evaluations += 1;
+      poisonedEvaluations += 1;
       return {};
     });
   } catch {
     poisonedRetryFailed = true;
   }
   return {
     cleanupFailed,
-    evaluations,
+    poisonedEvaluations,
     poisonedRetryFailed,
+    successfulDescriptorEquality: successful.descriptorEquality,
+    successfulEvaluations,
+    successfulModuleValues:
+      successful.moduleValue === "first-load" &&
+      reusable.moduleValue === "second-load",
   };
 }
 
@@ -240,11 +288,11 @@ export function installParserWorker(moduleLoaders) {
       });
       return;
     }
-    if (request.kind === "test-cleanup-poison") {
+    if (request.kind === "test-cleanup") {
       globalThis.postMessage({
-        evidence: await syntheticCleanupPoisonEvidence(),
+        evidence: await syntheticCleanupEvidence(),
         id: request.id,
-        kind: "cleanup-poison-result",
+        kind: "cleanup-result",
         resources: resourceEntries(),
       });
       return;

test/worker-placement/src/workers.js

@@ -217,27 +217,32 @@ async function run() {
       );
     }
 
-    const cleanupPoison = await request(worker, {
+    const cleanup = await request(worker, {
       id: 5,
-      kind: "test-cleanup-poison",
+      kind: "test-cleanup",
     });
     if (
-      cleanupPoison.response.kind !==
-        "cleanup-poison-result" ||
-      cleanupPoison.response.evidence.cleanupFailed !== true ||
-      cleanupPoison.response.evidence.poisonedRetryFailed !== true ||
-      cleanupPoison.response.evidence.evaluations !== 1
+      cleanup.response.kind !== "cleanup-result" ||
+      cleanup.response.evidence.cleanupFailed !== true ||
+      cleanup.response.evidence.poisonedRetryFailed !== true ||
+      cleanup.response.evidence.poisonedEvaluations !== 1 ||
+      cleanup.response.evidence.successfulEvaluations !== 2 ||
+      cleanup.response.evidence.successfulModuleValues !== true ||
+      cleanup.response.evidence.successfulDescriptorEquality
+        .NodeSQLParser !== true ||
+      cleanup.response.evidence.successfulDescriptorEquality.global !==
+        true
     ) {
       throw new Error(
-        "Synthetic cleanup failure did not poison its loader",
+        "Synthetic cleanup did not prove restoration and poisoning",
       );
     }
     if (globalThis.NodeSQLParser !== sentinel) {
       throw new Error("A parser bundle changed the browser main global");
     }
     const report = Object.freeze({
       bigquery,
-      cleanupPoison: cleanupPoison.response.evidence,
+      cleanup: cleanup.response.evidence,
       postgresql,
       resources: {
         mainAfterReady: mainResourcesAfterReady,

test/worker-placement/vite.core.config.mjs

@@ -5,17 +5,23 @@ function moduleTrace() {
   return {
     name: "worker-placement-core-module-trace",
     generateBundle(_options, bundle) {
-      const moduleIds = new Set();
-      for (const output of Object.values(bundle)) {
-        if (output.type === "chunk") {
-          for (const moduleId of Object.keys(output.modules)) {
-            moduleIds.add(moduleId.replaceAll("\\", "/"));
-          }
-        }
-      }
+      const chunks = Object.values(bundle)
+        .filter((output) => output.type === "chunk")
+        .map((chunk) => ({
+          dynamicImports: [...chunk.dynamicImports].sort(),
+          fileName: chunk.fileName,
+          imports: [...chunk.imports].sort(),
+          isEntry: chunk.isEntry,
+          moduleIds: Object.keys(chunk.modules)
+            .map((moduleId) => moduleId.replaceAll("\\", "/"))
+            .sort(),
+        }))
+        .sort((left, right) =>
+          left.fileName.localeCompare(right.fileName),
+        );
       this.emitFile({
-        fileName: "module-ids.json",
-        source: `${JSON.stringify([...moduleIds].sort(), null, 2)}\n`,
+        fileName: "core-module-trace.json",
+        source: `${JSON.stringify({ chunks }, null, 2)}\n`,
         type: "asset",
       });
     },