fix(core): late-bind expect to current file under isolate: false

A follow-up to the test.extend() fix: under `isolate: false` a context-bound
`@rstest/core` API value-copied into a module shared across files goes stale.
A shared helper doing `Object.assign(impl, expect)` (or `const { poll } = expect`)
captures the first file's concrete `expect`, whose `expect.poll` is bound to that
file's `getCurrentTest`; from the second file on it threw "expect.poll() must be
called inside a test".

Make the per-file `expect` self-delegate: when invoked from a stale cross-file
reference it forwards to the current file's live expect (`globalThis[GLOBAL_EXPECT]`,
reassigned per file), so test attribution and assertion state track the running
file. The per-test local expect leaves `isFileExpect: false` so it never delegates
and keeps `test.concurrent` assertion isolation. For the current file's own expect
`live === expect`, so this is a no-op fast path.

Refs #1376.

Author: fi3ework

e2e/no-isolate/fixtures/sharing/pollA.test.ts

@@ -0,0 +1,10 @@
+import { test } from '@rstest/core';
+import { pollFor } from './sharedExpect';
+
+test('pollA: shared expect.poll resolves this file test context', async () => {
+  let v = 0;
+  setTimeout(() => {
+    v = 10;
+  }, 20);
+  await pollFor(() => v).toBe(10);
+});

e2e/no-isolate/fixtures/sharing/pollB.test.ts

@@ -0,0 +1,10 @@
+import { test } from '@rstest/core';
+import { pollFor } from './sharedExpect';
+
+test('pollB: shared expect.poll still resolves this file test context', async () => {
+  let v = 0;
+  setTimeout(() => {
+    v = 10;
+  }, 20);
+  await pollFor(() => v).toBe(10);
+});

e2e/no-isolate/fixtures/sharing/sharedExpect.ts

@@ -0,0 +1,20 @@
+// A shared helper that value-copies the `@rstest/core` expect (including
+// `expect.poll`) at module top-level — the common pattern of re-exporting a
+// wrapped `expect` plus pre-bound helpers from one workspace module.
+//
+// Under `isolate: false` this module is evaluated once per worker (#1373), but
+// `@rstest/core` is reset per file. The captured `poll` must still resolve the
+// CURRENT file's test context — otherwise from the second file on it throws
+// "expect.poll() must be called inside a test".
+// See https://github.com/web-infra-dev/rstest/issues/1376.
+import { expect as rstestExpect } from '@rstest/core';
+
+const expectImpl = ((actual: unknown, message?: string) =>
+  rstestExpect(actual, message)) as typeof rstestExpect;
+Object.assign(expectImpl, rstestExpect);
+
+export const expect = expectImpl;
+
+// `poll` value-captured at module scope, mirroring a shared `expectPoll` helper.
+export const pollFor = (fn: () => unknown) =>
+  expect.poll(fn, { interval: 10, timeout: 500 });

e2e/no-isolate/moduleSharing.test.ts

@@ -12,10 +12,12 @@ describe('module state sharing under isolate: false', () => {
   // - https://github.com/web-infra-dev/rstest/issues/1373: a module imported by
   //   multiple files is evaluated once per worker (state shared), while setup
   //   files still re-run per file (a.test.ts / b.test.ts + shared.ts).
-  // - https://github.com/web-infra-dev/rstest/issues/1376: a `test.extend(...)`
-  //   captured in a module shared across files must still register against the
-  //   current file's runner, not the first file's torn-down one
-  //   (extendA.test.ts / extendB.test.ts + sharedFixture.ts).
+  // - https://github.com/web-infra-dev/rstest/issues/1376: a context-bound
+  //   `@rstest/core` API captured in a module shared across files must still
+  //   resolve the current file's context, not the first file's torn-down one —
+  //   `test.extend(...)` against the current runner (extendA/extendB +
+  //   sharedFixture.ts) and `expect.poll(...)` against the current test
+  //   (pollA/pollB + sharedExpect.ts).
   it('shares imported module state across files while re-running setup', async ({
     onTestFinished,
   }) => {

packages/core/src/runtime/api/expect.ts

@@ -57,10 +57,19 @@ export function createExpect({
   getCurrentTest,
   workerState,
   snapshotPlugin,
+  isFileExpect = false,
 }: {
   workerState: WorkerState;
   getCurrentTest: () => TestCase | undefined;
   snapshotPlugin?: ChaiPlugin;
+  /**
+   * Whether this is the per-file `expect` published as `globalThis[GLOBAL_EXPECT]`
+   * (and injected as `@rstest/core`'s `expect`). Only the per-file instance
+   * self-delegates to the current file's live expect when invoked from a stale
+   * (cross-file shared) reference. The per-test local expect leaves this `false`
+   * so it never delegates and keeps `test.concurrent` assertion isolation.
+   */
+  isFileExpect?: boolean;
 }): RstestExpect {
   use(JestExtend);
   use(JestChaiExpect);
@@ -69,7 +78,24 @@ export function createExpect({
   }
   use(JestAsymmetricMatchers);
 
+  // Resolve the expect whose state/context should be used right now. Under
+  // `isolate: false` the per-file `expect` (and members value-copied off it,
+  // e.g. `expect.poll`) may be captured in a module shared across files; when a
+  // later file calls such a stale reference, delegate to that file's live
+  // expect — `globalThis[GLOBAL_EXPECT]` is reassigned per file — so assertion
+  // state and test attribution track the running file. For the current file's
+  // own expect `live === expect`, so this is a no-op fast path.
+  // See https://github.com/web-infra-dev/rstest/issues/1376.
+  const activeExpect = (): RstestExpect => {
+    const live = (globalThis as any)[GLOBAL_EXPECT] as RstestExpect | undefined;
+    return isFileExpect && live && live !== expect ? live : expect;
+  };
+
   const expect = ((value: any, message?: string): Assertion => {
+    const live = activeExpect();
+    if (live !== expect) {
+      return live(value, message);
+    }
     const { assertionCalls } = getState(expect);
     setState({ assertionCalls: assertionCalls + 1 }, expect);
     const assert = chaiExpect(value, message) as unknown as Assertion;
@@ -83,8 +109,11 @@ export function createExpect({
   Object.assign(expect, chaiExpect);
   Object.assign(expect, (globalThis as any)[ASYMMETRIC_MATCHERS_OBJECT]);
 
-  expect.getState = () => getState<MatcherState>(expect);
-  expect.setState = (state) => setState(state, expect);
+  // Route the public state accessors through `activeExpect()` so `assertions`,
+  // `hasAssertions`, `soft`, and `poll` (which call these) land on the running
+  // file's state key when reached via a stale cross-file reference.
+  expect.getState = () => getState<MatcherState>(activeExpect());
+  expect.setState = (state) => setState(state, activeExpect());
 
   const globalState = getState((globalThis as any)[GLOBAL_EXPECT]) || {};
 

packages/core/src/runtime/api/index.ts

@@ -40,6 +40,7 @@ export const createRstestRuntime = async (
     workerState,
     getCurrentTest: () => runner.getCurrentTest(),
     snapshotPlugin: SnapshotPlugin(workerState),
+    isFileExpect: true,
   });
 
   Object.defineProperty(globalThis, GLOBAL_EXPECT, {

packages/core/tests/runtime/api/expect.test.ts

@@ -0,0 +1,108 @@
+import { util } from 'chai';
+import { createExpect, GLOBAL_EXPECT } from '../../../src/runtime/api/expect';
+import type { TestCase, WorkerState } from '../../../src/types';
+
+function createWorkerState(testPath: string): WorkerState {
+  return { testPath, runtimeConfig: {} } as WorkerState;
+}
+
+const fakeTest = (name: string) => ({ name }) as unknown as TestCase;
+
+// This test hijacks `globalThis[GLOBAL_EXPECT]` — the same slot the host rstest
+// runtime uses — so each case swaps it only briefly, captures what it needs,
+// then restores it before running the outer assertions.
+function withLiveExpect<T>(live: unknown, fn: () => T): T {
+  // @ts-expect-error symbol index
+  const prev = globalThis[GLOBAL_EXPECT];
+  // @ts-expect-error symbol index
+  globalThis[GLOBAL_EXPECT] = live;
+  try {
+    return fn();
+  } finally {
+    // @ts-expect-error symbol index
+    globalThis[GLOBAL_EXPECT] = prev;
+  }
+}
+
+/**
+ * Regression for https://github.com/web-infra-dev/rstest/issues/1376: under
+ * `isolate: false` the per-file `expect` (and members value-copied off it) can
+ * be captured in a module shared across files. When a later file invokes that
+ * stale reference, it must delegate to the current file's live expect
+ * (`globalThis[GLOBAL_EXPECT]`) so assertion state and test attribution track
+ * the running file — while the per-test local expect must NOT delegate.
+ */
+describe('createExpect cross-file delegation (isolate: false)', () => {
+  it('attributes a stale per-file expect to the live file test', () => {
+    const file1 = createExpect({
+      workerState: createWorkerState('/f1'),
+      getCurrentTest: () => fakeTest('t1'),
+      isFileExpect: true,
+    });
+    const file2 = createExpect({
+      workerState: createWorkerState('/f2'),
+      getCurrentTest: () => fakeTest('t2'),
+      isFileExpect: true,
+    });
+
+    // File 2 is the running file; the stale file-1 expect must resolve t2.
+    const attributed = withLiveExpect(file2, () =>
+      util.flag(file1(1) as unknown as object, 'vitest-test'),
+    ) as TestCase;
+    expect(attributed.name).toBe('t2');
+  });
+
+  it('routes assertion state of a stale per-file expect onto the live expect', () => {
+    const file1 = createExpect({
+      workerState: createWorkerState('/f1'),
+      getCurrentTest: () => undefined,
+      isFileExpect: true,
+    });
+    const file2 = createExpect({
+      workerState: createWorkerState('/f2'),
+      getCurrentTest: () => undefined,
+      isFileExpect: true,
+    });
+
+    const calls = withLiveExpect(file2, () => {
+      file1.setState({ assertionCalls: 7 });
+      // State must land on the live (file 2) key, not file 1's own object.
+      return file2.getState().assertionCalls;
+    });
+    expect(calls).toBe(7);
+  });
+
+  it('does not delegate the per-test local expect (concurrent isolation)', () => {
+    const fileExpect = createExpect({
+      workerState: createWorkerState('/f2'),
+      getCurrentTest: () => fakeTest('file'),
+      isFileExpect: true,
+    });
+    const localExpect = createExpect({
+      workerState: createWorkerState('/f2'),
+      getCurrentTest: () => fakeTest('local'),
+      // isFileExpect omitted -> false: a per-test local expect never delegates.
+    });
+
+    const { attributed, localCalls, fileCalls } = withLiveExpect(
+      fileExpect,
+      () => {
+        const a = util.flag(
+          localExpect(1) as unknown as object,
+          'vitest-test',
+        ) as TestCase;
+        localExpect.setState({ assertionCalls: 3 });
+        return {
+          attributed: a,
+          localCalls: localExpect.getState().assertionCalls,
+          fileCalls: fileExpect.getState().assertionCalls,
+        };
+      },
+    );
+
+    expect(attributed.name).toBe('local');
+    expect(localCalls).toBe(3);
+    // The live file expect's state is untouched by the local expect.
+    expect(fileCalls).toBe(0);
+  });
+});