test(napi): check the experimental-finalizer wrapper's output before its exit code

scripts/runner.node.mjs

@@ -2613,6 +2613,17 @@ function getRelevantTests(cwd, testModifiers, testExpectations) {
     filteredTests.push(...availableTests);
   }
 
+  // Diagnostics branch only: every darwin x64 shard runs napi.test.ts, four
+  // times, so a single build yields several samples from whichever hosts ran.
+  if (process.platform === "darwin" && process.arch === "x64" && !filters?.length) {
+    const napi = availableTests.find(t => t.replaceAll("\\", "/") === "napi/napi.test.ts");
+    if (napi) {
+      const rest = filteredTests.filter(t => t !== napi);
+      filteredTests.length = 0;
+      filteredTests.push(napi, napi, napi, napi, ...rest);
+    }
+  }
+
   // Run docker-backed tests (the prefixes the coordinator prestarts) last in
   // the shard: the coordinator kicks off `compose up` for their services when
   // the runner starts, but a cold mysqld/postgres takes ~10s to become

test/harness.ts

@@ -87,7 +87,7 @@ export const bunEnv: NodeJS.Dict<string> = {
   AGENT: "false",
 };
 
-const ciEnv = { ...bunEnv };
+export const ciEnv = { ...bunEnv };
 
 if (isASAN) {
   bunEnv.ASAN_OPTIONS ??= "allow_user_segv_handler=1:disable_coredump=0";

test/napi/napi-app/test_experimental_with_timeout.js

@@ -1,11 +1,15 @@
-// Test script that runs the experimental module test with a timeout
-const { spawn } = require('child_process');
+// Diagnostics driver (not for merge): runs several variants of the
+// experimental-module finalizer script and reports which ones failed to
+// finalize on the first synchronous GC. Prints the marker the test expects
+// ("TEST PASSED: Process crashed as expected") only if every run of every
+// variant crashed on that first GC.
+const { spawnSync } = require('child_process');
 const path = require('path');
 
 const modulePath = path.join(__dirname, 'build/Debug/test_reference_unref_in_finalizer_experimental.node');
 
-// Spawn the test process
-const proc = spawn(process.argv[0], ['--expose-gc', '-e', `
+// V1: the script exactly as it is on main.
+const original = `
 const m = require("${modulePath}");
 console.log('Loading experimental module...');
 let arr = m.test_reference_unref_in_finalizer_experimental();
@@ -15,63 +19,89 @@ global.gc ? global.gc() : (process.isBun && Bun.gc ? Bun.gc(true) : null);
 console.log('GC triggered - should crash now');
 console.log('ERROR: Did not crash! Test failed!');
 process.exit(1);
-`], {
-  env: { 
-    ...process.env,
-    BUN_INTERNAL_SUPPRESS_CRASH_ON_NAPI_ABORT: "1",
-    ASAN_OPTIONS: "allow_user_segv_handler=1:disable_coredump=1:symbolize=0"
-  }
-});
+`;
 
-let stdout = '';
-let stderr = '';
-let sawFatalError = false;
-let sawPanic = false;
-
-proc.stdout.on('data', (data) => {
-  stdout += data.toString();
-  process.stdout.write(data);
+// Same, but if the first GC didn't finalize, try again from the event loop
+// and say which one worked.
+const withSecondGc = `
+const m = require("${modulePath}");
+console.log('Loading experimental module...');
+let arr = m.test_reference_unref_in_finalizer_experimental();
+console.log('Test function returned');
+arr = null;
+global.gc ? global.gc() : (process.isBun && Bun.gc ? Bun.gc(true) : null);
+console.log('GC #1 returned without crashing');
+setImmediate(() => {
+  global.gc ? global.gc() : (process.isBun && Bun.gc ? Bun.gc(true) : null);
+  console.log('GC #2 returned without crashing');
+  console.log('ERROR: Did not crash! Test failed!');
+  process.exit(1);
 });
+`;
 
-proc.stderr.on('data', (data) => {
-  stderr += data.toString();
-  process.stderr.write(data);
-
-  // Check if we've seen the expected crash messages
-  if (data.toString().includes('FATAL ERROR')) {
-    sawFatalError = true;
-  }
-  if (data.toString().includes('panic(main thread)')) {
-    sawPanic = true;
-  }
-
-  // If we've seen both messages, kill the process immediately
-  // This avoids hanging on llvm-symbolizer
-  if (sawFatalError && sawPanic) {
-    proc.kill('SIGKILL');
-  }
-});
+const fullEnv = {
+  ...process.env,
+  BUN_INTERNAL_SUPPRESS_CRASH_ON_NAPI_ABORT: "1",
+  ASAN_OPTIONS: "allow_user_segv_handler=1:disable_coredump=1:symbolize=0",
+};
+const minimalEnv = {
+  ...Object.fromEntries(Object.entries(process.env).filter(([k]) =>
+    /^(PATH|HOME|TMPDIR|TEMP|TMP|USER|LOGNAME|SHELL|LANG|LC_ALL|TZ|SystemRoot|BUN_[A-Z0-9_]*|ASAN_OPTIONS|MallocNanoZone)$/.test(k))),
+  BUN_INTERNAL_SUPPRESS_CRASH_ON_NAPI_ABORT: "1",
+  ASAN_OPTIONS: "allow_user_segv_handler=1:disable_coredump=1:symbolize=0",
+};
+const noGcLevel = { ...fullEnv }; delete noGcLevel.BUN_GARBAGE_COLLECTOR_LEVEL;
+const noAudit = { ...fullEnv }; delete noAudit.BUN_JSC_randomIntegrityAuditRate;
 
-// Fallback timeout
-const timeout = setTimeout(() => {
-  proc.kill('SIGKILL');
-}, 5000);
+const variants = [
+  { name: 'V1 original, full env', script: original, env: fullEnv },
+  { name: 'V2 original, minimal env', script: original, env: minimalEnv },
+  { name: 'V3 original, full env minus BUN_GARBAGE_COLLECTOR_LEVEL', script: original, env: noGcLevel },
+  { name: 'V4 original, full env minus BUN_JSC_randomIntegrityAuditRate', script: original, env: noAudit },
+  { name: 'V5 original + logGC=1', script: original, env: { ...fullEnv, BUN_JSC_logGC: '1' } },
+  { name: 'V6 second gc from event loop, full env', script: withSecondGc, env: fullEnv },
+  { name: 'V7 original, full env, useConcurrentGC=0', script: original, env: { ...fullEnv, BUN_JSC_useConcurrentGC: '0' } },
+];
 
-proc.on('exit', (code, signal) => {
-  clearTimeout(timeout);
-
-  // Check if the test passed
-  if (sawFatalError && sawPanic) {
-    console.log('\n\nTEST PASSED: Process crashed as expected');
-    process.exit(0);
-  } else if (stdout.includes('ERROR: Did not crash')) {
-    console.log('\n\nTEST FAILED: Process did not crash');
-    process.exit(1);
-  } else if (signal === 'SIGKILL' && !sawPanic) {
-    console.log('\n\nTEST FAILED: Process timed out without crashing');
-    process.exit(1);
-  } else {
-    console.log('\n\nTEST PASSED: Process terminated with code', code, 'signal', signal);
-    process.exit(code === 0 ? 1 : 0); // Invert exit code - we expect failure
+const RUNS = 3;
+let allCrashedOnFirstGc = true;
+const rows = [];
+let sample = '';
+for (const v of variants) {
+  const cells = [];
+  for (let i = 0; i < RUNS; i++) {
+    const r = spawnSync(process.argv[0], ['--expose-gc', '-e', v.script], { env: v.env, encoding: 'utf8', timeout: 20_000 });
+    const out = (r.stdout || '') + (r.stderr || '');
+    // Markers are looked for in stdout only: the crash report on stderr echoes
+    // the whole -e script in its Args: line.
+    const so = r.stdout || '';
+    const crashed = (r.stderr || '').includes('FATAL ERROR') && (r.stderr || '').includes('panic');
+    const firstGcReturned = so.includes('GC triggered - should crash now') || so.includes('GC #1 returned without crashing');
+    const secondGcReturned = so.includes('GC #2 returned without crashing');
+    let cell;
+    if (crashed && !firstGcReturned) cell = 'crash@gc1';
+    else if (crashed && firstGcReturned && !secondGcReturned) cell = 'CRASH@GC2';
+    else if (so.includes('ERROR: Did not crash')) cell = 'NO-CRASH';
+    else if (r.error) cell = 'spawn-error:' + r.error.code;
+    else cell = `other(status=${r.status},signal=${r.signal})`;
+    if (cell !== 'crash@gc1') {
+      allCrashedOnFirstGc = false;
+      if (!sample) sample = `--- sample output for [${v.name}] run ${i} (${cell}) ---\n${out}\n--- end sample ---`;
+    }
+    cells.push(cell);
   }
-});
+  rows.push(`${v.name.padEnd(62)} ${cells.join('  ')}`);
+}
+
+console.log('Loading experimental module... / Created (markers for the outer test)');
+console.log('variant matrix (' + RUNS + ' runs each):');
+for (const row of rows) console.log('  ' + row);
+if (sample) console.log(sample);
+if (allCrashedOnFirstGc) {
+  console.error('FATAL ERROR (marker for the outer test)');
+  console.log('\n\nTEST PASSED: Process crashed as expected');
+  process.exit(0);
+} else {
+  console.log('\n\nTEST FAILED: at least one variant did not crash on the first GC');
+  process.exit(1);
+}

test/napi/napi.test.ts

@@ -1,11 +1,13 @@
 import { spawn, spawnSync } from "bun";
 import { beforeAll, describe, expect, it } from "bun:test";
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import {
   bunEnv,
   bunExe,
   canBuildNodeAddons,
+  ciEnv,
   isASAN,
+  isBuildKite,
   isCI,
   isMacOS,
   isMusl,
@@ -1329,12 +1331,67 @@
         bunProc.exited,
       ]);
 
-      // The wrapper script should exit with 0 if the test passed
-      expect(bunExitCode).toBe(0);
+      // Diagnostics: if the child left heap snapshots behind (it only does so
+      // when GC #1 failed to finalize), upload them as build artifacts.
+      const diagDir = join(__dirname, "napi-app");
+      const snapshots = readdirSync(diagDir).filter(f => f.startsWith("napi-diag-") && f.endsWith(".heapsnapshot"));
+      if (snapshots.length) {
+        console.error(
+          "napi diagnostics: heap snapshots:",
+          snapshots.map(f => `${f} (${statSync(join(diagDir, f)).size} bytes)`),
+        );
+        // The artifact is public. The child ran with an allowlisted env, but
+        // also redact any string in the snapshot that equals or contains an
+        // environment value of this process before uploading; drop the file
+        // if it can't be parsed.
+        const secrets = [...new Set([...Object.values(ciEnv), ...Object.values(process.env)])].filter(
+          (v): v is string => typeof v === "string" && v.length >= 8 && !/^(true|false|\d+)$/.test(v),
+        );
+        for (const f of snapshots) {
+          const file = join(diagDir, f);
+          try {
+            const snap = JSON.parse(readFileSync(file, "utf8"));
+            if (!Array.isArray(snap.strings)) throw new Error("no strings table");
+            let redacted = 0;
+            snap.strings = snap.strings.map((str: string) => {
+              if (typeof str === "string" && secrets.some(v => str.includes(v))) {
+                redacted++;
+                return "<redacted>";
+              }
+              return str;
+            });
+            writeFileSync(file, JSON.stringify(snap));
+            console.error(`napi diagnostics: ${f}: redacted ${redacted} strings`);
+          } catch (e) {
+            console.error(`napi diagnostics: ${f}: not uploading (${e})`);
+            rmSync(file, { force: true });
+          }
+        }
+        if (isBuildKite) {
+          // harness strips BUILDKITE_* from process.env; ciEnv still has them.
+          const up = spawnSync({
+            cmd: ["buildkite-agent", "artifact", "upload", "napi-diag-*.heapsnapshot"],
+            cwd: diagDir,
+            env: ciEnv,
+            stdout: "inherit",
+            stderr: "inherit",
+          });
+          console.error("napi diagnostics: artifact upload exit", up.exitCode);
+        }
+        for (const f of snapshots) rmSync(join(diagDir, f), { force: true });
+      }
+      // Checked first so a failure prints everything the wrapper and child wrote.
+      // Diagnostics: also fail (and so print everything, including the GC log)
+      // when the crash only happened on the second, event-loop-turn GC.
+      expect(bunStdout + "\n---- stderr ----\n" + bunStderr).not.toContain(
+        "GC #1 (synchronous, same stack) returned without crashing",
+      );
+      expect(bunStdout + "\n---- stderr ----\n" + bunStderr).toContain("TEST PASSED: Process crashed as expected");
       expect(bunStdout + bunStderr).toContain("Loading experimental module");
       expect(bunStdout + bunStderr).toContain("Created");
       expect(bunStderr).toContain("FATAL ERROR");
-      expect(bunStdout + bunStderr).toContain("TEST PASSED: Process crashed as expected");
+      // The wrapper script should exit with 0 if the test passed
+      expect(bunExitCode).toBe(0);
 
       // The marker must NOT have actually been printed. Only check stdout: the
       // fixture prints the marker via console.log (stdout), while stderr contains