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/napi/napi-app/test_experimental_with_timeout.js

@@ -12,12 +12,34 @@ 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 triggered - should crash now');
-console.log('ERROR: Did not crash! Test failed!');
-process.exit(1);
+console.log('GC #1 (synchronous, same stack) returned without crashing');
+if (process.env.NAPI_DIAG_SNAPSHOT) {
+  // Retaining paths of whatever survived GC #1. (Building the snapshot runs a
+  // GC of its own; if that one finalizes the objects we crash right here,
+  // which the test also reports.)
+  require('fs').writeFileSync(process.env.NAPI_DIAG_SNAPSHOT, Bun.generateHeapSnapshot('v8'));
+  console.log('wrote heap snapshot after GC #1 to ' + process.env.NAPI_DIAG_SNAPSHOT);
+}
+setImmediate(() => {
+  global.gc ? global.gc() : (process.isBun && Bun.gc ? Bun.gc(true) : null);
+  console.log('GC #2 (from a fresh event-loop turn) returned without crashing');
+  // Diagnostics for the no-crash path: which napi-related cells are still
+  // live after two full GCs (a live NapiHandleScopeImpl / counts of Object).
+  const { heapStats } = require("bun:jsc");
+  const counts = heapStats().objectTypeCounts;
+  const pick = {};
+  for (const k of Object.keys(counts)) if (/napi|Napi|External|^Object$|^Array$|Finaliz|Weak/i.test(k)) pick[k] = counts[k];
+  console.log('live cells after GC #2: ' + JSON.stringify(pick));
+  console.log('protected: ' + JSON.stringify(heapStats().protectedObjectTypeCounts));
+  console.log('ERROR: Did not crash! Test failed!');
+  process.exit(1);
+});
 `], {
   env: { 
     ...process.env,
+    NAPI_DIAG_SNAPSHOT: path.join(__dirname, 'napi-diag-' + process.pid + '.heapsnapshot'),
+    // Diagnostics: one line per GC cycle on stderr (C:<n> = conservative roots visited).
+    BUN_JSC_logGC: "2",
     BUN_INTERNAL_SUPPRESS_CRASH_ON_NAPI_ABORT: "1",
     ASAN_OPTIONS: "allow_user_segv_handler=1:disable_coredump=1:symbolize=0"
   }

test/napi/napi.test.ts

@@ -1329,12 +1329,38 @@
         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)`),
+        );
+        if (process.env.BUILDKITE) {
+          const up = spawnSync({
+            cmd: ["buildkite-agent", "artifact", "upload", "napi-diag-*.heapsnapshot"],
+            cwd: diagDir,
+            env: process.env,
+            stdout: "inherit",
+            stderr: "inherit",
+          });
+          console.error("napi diagnostics: artifact upload exit", up.exitCode);
+        }
+      }
+      // 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