fix(core): prevent late console logs from failing the run (isolate: false)

With `isolate: false`, all test files share one worker but each file owns its
own birpc channel. The host disposes a file's channel as soon as the file
finishes, while the worker only closes it when the next file starts. A console
reference captured by a file (e.g. a logger that flushes from a late
`setTimeout`/microtask) could fire in or after that window and forward the log
over a disposed/closed channel.

Because `onConsoleLog` was a normal birpc call, the late log registered a
pending request that `$close()` then rejected with `[birpc] rpc is closed`.
Since the console interceptor does not await it, the rejection surfaced as an
`unhandledRejection` that failed the run even though every assertion passed,
and was misattributed to whichever file happened to be running.

`onConsoleLog` is fire-and-forget telemetry whose result the worker never reads,
so model it as a one-way birpc event (`eventNames`): it no longer registers a
pending request, so there is nothing for `$close()` to reject. Forwarding is
also made best-effort — a send that races channel teardown is swallowed rather
than crashing the run, and a dropped late log stays subject to the host's
`onConsoleLog` policy, matching `isolate: true` where such logs are lost as the
worker is torn down.

Covered by an e2e regression test (with console suppression) across both the
forks and threads pools and both isolate modes, plus a unit test asserting
`onConsoleLog` is registered as a one-way event.

Originally surfaced while migrating Rsbuild's e2e runner to rstest
(web-infra-dev/rsbuild#7776), then reduced to the minimal repro in #1367.

Closes #1367

Author: fi3ework

e2e/log/fixtures/late-console/a.test.ts

@@ -0,0 +1,17 @@
+import { test } from '@rstest/core';
+
+// A captured `console` reference, like a logger that grabs `console` once.
+const log = globalThis.console;
+
+test('schedules console calls that outlive the test file', () => {
+  // None of these are awaited, so they fire after this file's tests finish. With
+  // `isolate: false` the host disposes this file's birpc channel as soon as the
+  // file finishes, but the worker only closes it once the next file starts.
+  // Spread the logs across that handoff window so some fire while the channel is
+  // disposed-but-open (the one-way-event path) and the later one fires after the
+  // worker has closed it (the closed-channel path). Neither may crash the run.
+  for (let delay = 0; delay <= 60; delay += 5) {
+    setTimeout(() => log.log('late log from a.test.ts'), delay);
+  }
+  setTimeout(() => log.log('late log from a.test.ts'), 250);
+});

e2e/log/fixtures/late-console/b.test.ts

@@ -0,0 +1,6 @@
+import { test } from '@rstest/core';
+
+test('keeps the worker alive while a.test.ts logs late', async () => {
+  // Stay running long enough for a.test.ts's late `setTimeout` to fire.
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+});

e2e/log/fixtures/late-console/rstest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  // `isolate` is driven per case by the test via `--isolate`. Run files
+  // sequentially on a single worker so that, under `isolate: false`, `a.test.ts`
+  // and `b.test.ts` share one process and exercise the closed-channel path.
+  pool: { maxWorkers: 1 },
+  // Suppress all console output. A late log that outlives its file must not only
+  // avoid crashing the run, it must also stay suppressed — forwarding it after
+  // teardown (or writing it to the raw stream) would bypass this filter.
+  onConsoleLog: () => false,
+});

e2e/log/late-console.test.ts

@@ -0,0 +1,45 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from '@rstest/core';
+import { runRstestCli } from '../scripts';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Regression test for https://github.com/web-infra-dev/rstest/issues/1367.
+// `a.test.ts` captures a `console` reference and flushes it from `setTimeout`s
+// that outlive the file. With `isolate: false` every file shares one worker, so
+// the late logs fire after the host has disposed a's birpc channel (and, later,
+// after the worker has closed it). Forwarding such a log used to leave a pending
+// birpc request that `$close()` rejected as `[birpc] rpc is closed`, failing the
+// run and misattributing it to `b.test.ts`.
+//
+// `onConsoleLog` is now a one-way event and forwarding is best-effort, so a late
+// log can neither crash the run nor leak past the `onConsoleLog: () => false`
+// suppression filter. Assert this across both pools and both isolate modes: with
+// `isolate: true` each file gets a fresh worker so the bug cannot occur, which
+// guards against a regression that only fixes one mode.
+describe('late console log (issue #1367)', () => {
+  for (const pool of ['forks', 'threads'] as const) {
+    for (const isolate of [true, false] as const) {
+      it(`should not fail the run when a console call outlives its test file (${pool} pool, isolate: ${isolate})`, async () => {
+        const { cli, expectExecSuccess } = await runRstestCli({
+          command: 'rstest',
+          args: ['run', '--pool', pool, '--isolate', String(isolate)],
+          options: {
+            nodeOptions: {
+              cwd: join(__dirname, 'fixtures/late-console'),
+            },
+          },
+        });
+
+        await expectExecSuccess();
+
+        // The late log must not crash the run via a closed/disposed channel...
+        expect(cli.log).not.toContain('rpc is closed');
+        // ...and it must stay suppressed, not leak to the raw worker stream.
+        expect(cli.log).not.toContain('late log from a.test.ts');
+      });
+    }
+  }
+});

packages/core/src/runtime/worker/rpc.ts

@@ -40,6 +40,14 @@ export function createRuntimeRpc(
     {},
     {
       ...options,
+      // `onConsoleLog` is fire-and-forget telemetry whose result the worker never
+      // reads. Send it as a one-way event so it never registers a pending request
+      // in birpc's promise map — otherwise a log emitted in the window after the
+      // host has disposed this file's rpc (but before the worker closes it, which
+      // only happens with `isolate: false`) would leave a promise that the later
+      // `$close()` rejects as `[birpc] rpc is closed`, crashing the run.
+      // See https://github.com/web-infra-dev/rstest/issues/1367.
+      eventNames: ['onConsoleLog'],
       // Disable timeout for worker RPC calls, as some operations may take a long time and we don't want them to fail due to timeout.
       timeout: -1,
     },

packages/core/src/runtime/worker/runInPool.ts

@@ -167,8 +167,19 @@ const preparePool = async (
       disableConsoleIntercept,
       silent,
     },
-    emitInterceptedLog: async (log) => {
-      await rpc.onConsoleLog(log);
+    emitInterceptedLog: (log) => {
+      // Forwarding console output to the host is best-effort, fire-and-forget
+      // telemetry. With `isolate: false` a captured console (e.g. a logger that
+      // flushes from a late `setTimeout`/microtask) can fire after this file's
+      // birpc channel has been closed or disposed by the host. `onConsoleLog` is
+      // a one-way event (see `createRuntimeRpc`), so it leaves no pending request
+      // to reject; swallowing any send error drops such an orphan log rather than
+      // surfacing it as an `unhandledRejection` that fails the run and is
+      // misattributed to whichever file is currently running. A dropped late log
+      // also stays subject to the host's `onConsoleLog` policy, matching
+      // `isolate: true` where late logs are lost as the worker is torn down.
+      // See https://github.com/web-infra-dev/rstest/issues/1367.
+      void rpc.onConsoleLog(log).catch(() => {});
     },
     writeOriginalLog: createOriginalLogWriter(),
   });

packages/core/tests/runtime/worker/rpc.test.ts

@@ -1,23 +1,40 @@
 import { createRuntimeRpc } from '../../../src/runtime/worker/rpc';
 
+// Capture the birpc options that `createRuntimeRpc` constructs, by injecting a
+// stub `createBirpc` that records them.
+const captureBirpcOptions = (): Record<string, unknown> => {
+  let options: Record<string, unknown> | undefined;
+
+  createRuntimeRpc(
+    {
+      serialize: (v) => v as Uint8Array,
+      deserialize: (v) => v as unknown,
+      post() {},
+      on() {},
+    },
+    (_functions, birpcOptions) => {
+      options = birpcOptions as unknown as Record<string, unknown>;
+      return {} as any;
+    },
+  );
+
+  if (!options) {
+    throw new Error('createRuntimeRpc did not construct birpc options');
+  }
+
+  return options;
+};
+
 describe('createRuntimeRpc', () => {
   it('should disable birpc timeout', () => {
-    let options: Record<string, unknown> | undefined;
-
-    createRuntimeRpc(
-      {
-        serialize: (v) => v as Uint8Array,
-        deserialize: (v) => v as unknown,
-        post() {},
-        on() {},
-      },
-      (_functions, birpcOptions) => {
-        options = birpcOptions as unknown as Record<string, unknown>;
-        return {} as any;
-      },
-    );
+    expect(captureBirpcOptions().timeout).toBe(-1);
+  });
 
-    expect(options).toBeDefined();
-    expect(options?.timeout).toBe(-1);
+  it('should send `onConsoleLog` as a one-way event', () => {
+    // `onConsoleLog` must be a fire-and-forget event so a late log (emitted after
+    // the host disposed this file's rpc) never leaves a pending request that
+    // `$close()` rejects as `[birpc] rpc is closed`.
+    // See https://github.com/web-infra-dev/rstest/issues/1367.
+    expect(captureBirpcOptions().eventNames).toContain('onConsoleLog');
   });
 });