fix(core): apply rs.mock to non-literal dynamic import()

A dynamic `import()` with a non-literal specifier is routed to the worker's
native import hook and loaded by Node outside the webpack runtime, so
`rs.mock` was bypassed (#1454).

- Route a non-literal `import(request)` whose request names a mocked module
  to the bundle's mock instance via a shared-global resolver (all Node),
  fixing `const s = 'node:os'; import(s)`.
- Install in-thread `module.registerHooks` (Node >= 22.15 / >= 23.5,
  feature-detected with silent fallback) so a natively-loaded module's inner
  import of a mocked module is redirected to a worker-realm mock registry —
  fixing the reported repro (a local module reached via a variable `import()`)
  and externalized deps that import a mocked module.

Limitations documented in the mock guide: Node version floor, TS/JSX native
targets, function-factory instance divergence, and isolate:false ESM cache.

Author: fi3ework

e2e/mock/fixtures/nonLiteralDynamic/target.mts

@@ -0,0 +1,3 @@
+import { hostname } from 'node:os';
+
+export const probe = (): string => hostname();

e2e/mock/fixtures/nonLiteralDynamic/targetVar.mjs

@@ -0,0 +1,8 @@
+// Imported ONLY via a non-literal `import(variable)` (see
+// mockNonLiteralDynamicImport.test.ts) so it stays out of the bundle and is
+// loaded by Node's loader — the #1454 off-graph case. Kept separate from
+// `target.mjs` (which a literal import compiles into the bundle) so the two
+// tests exercise distinct paths.
+import { hostname } from 'node:os';
+
+export const probe = () => hostname();

e2e/mock/fixtures/nonLiteralDynamic/targetVarNpm.mjs

@@ -0,0 +1,7 @@
+// Imported ONLY via a non-literal `import(variable)`, so Node loads it natively.
+// Its bare `strip-ansi` import exercises the registerHooks NON-builtin branch
+// (real resolution via `nextResolve`, keyed by the resolved URL) — distinct from
+// the builtin (`node:os`) path.
+import stripAnsi from 'strip-ansi';
+
+export const probe = () => stripAnsi('x');

e2e/mock/tests/mockNonLiteralDynamicImport.test.ts

@@ -0,0 +1,42 @@
+import nodeModule from 'node:module';
+import { describe, expect, it, rs } from '@rstest/core';
+
+// Regression for #1454: rs.mock must reach the inner imports of a module loaded
+// via a NON-LITERAL dynamic `import(variable)`. rspack cannot statically include
+// such a target, so Node loads it outside the bundle; only the in-thread
+// `module.registerHooks` path (Node >= 22.15 / >= 23.5) can redirect the
+// target's `import 'node:os'` to the mock. The literal-import control compiles
+// the target into the bundle and is mock-aware on all Node.
+const HAS_REGISTER_HOOKS =
+  typeof (nodeModule as { registerHooks?: unknown }).registerHooks ===
+  'function';
+
+rs.mock('node:os', () => ({ hostname: () => 'MOCKED' }));
+rs.mock('strip-ansi', () => ({ default: () => 'MOCKED_STRIP' }));
+
+it('dynamic import with a string LITERAL applies the mock (control)', async () => {
+  const mod = await import('../fixtures/nonLiteralDynamic/target.mts');
+  expect(mod.probe()).toBe('MOCKED');
+});
+
+it('non-literal import where the variable IS a mocked builtin applies the mock (all Node)', async () => {
+  // The specifier resolves to the mocked module itself — fixed by the request-key
+  // bridge in the runtime router (no registerHooks needed), so this is ungated.
+  const spec = ['node', 'os'].join(':');
+  const os = (await import(spec)) as unknown as { hostname: () => string };
+  expect(os.hostname()).toBe('MOCKED');
+});
+
+describe.skipIf(!HAS_REGISTER_HOOKS)('non-literal specifier (#1454)', () => {
+  it('dynamic import with a VARIABLE applies the mock (builtin)', async () => {
+    const specifier = '../fixtures/nonLiteralDynamic/targetVar.mjs';
+    const mod = (await import(specifier)) as { probe: () => string };
+    expect(mod.probe()).toBe('MOCKED');
+  });
+
+  it('dynamic import of a module that imports a mocked npm package sees the mock', async () => {
+    const specifier = '../fixtures/nonLiteralDynamic/targetVarNpm.mjs';
+    const mod = (await import(specifier)) as { probe: () => string };
+    expect(mod.probe()).toBe('MOCKED_STRIP');
+  });
+});

packages/core/src/core/plugins/mockRuntimeCode.js

@@ -96,6 +96,73 @@ const createMockedModule = (originalModule, isSpy) => {
   );
 };
 
+// #1454: publish a mock's settled exports to the worker-realm native-mock
+// registry so a Node `registerHooks` load hook can serve them to a module loaded
+// NATIVELY by Node — a true-external `A` (a node_modules package), or a local
+// module reached via a non-literal `import(variable)` (loaded outside the
+// bundle) — that internally imports this mocked module. Routed over the existing
+// RSTEST_API channel (same as `mockObject`). `request` is `undefined` under an
+// older @rspack/core that omits the request literal — skip then.
+//
+// `produce` is the source of the mock's exports: the already-built mocked module
+// for the spy/mock-option path (the SAME instance bundle consumers see, via its
+// getters), or the raw factory for a function mock. It is run on a MICROTASK,
+// never eagerly at install time: a factory may reference module-level imports
+// not yet evaluated when the hoisted `rs.mock` runs (notably under circular
+// deps — see mockHoist/barrel), so eager evaluation throws `Cannot read
+// properties of undefined`. The microtask runs after the module body settles its
+// imports but before the test body's `await import(...)`, so the registry is
+// populated in time. Errors are swallowed: a factory that only runs inside the
+// bundle context simply won't back a native mock, leaving the webpack path
+// untouched.
+//
+// LIMITATION (function factory only): the factory is re-run here, so the
+// native-realm mock is a SEPARATE instance from the bundle's. A spy created
+// inside the factory (`rs.fn()`) is therefore a different object on each side, so
+// asserting — through the bundle handle — calls made via the natively-loaded
+// module will not see them. Sync object-returning factories (the #1454 repro)
+// and the spy/mock-option path are unaffected. Sharing the bundle instance was
+// tried (`() => __webpack_require__(id)`) but it eagerly evaluates the mock
+// module on the microtask, corrupting state for an async-factory error and
+// running factory side effects early; deferring that eval is a future change.
+const publishNativeMock = (request, produce) => {
+  if (request === undefined) {
+    return;
+  }
+  const api = globalThis.RSTEST_API?.rstest;
+  if (!api || typeof api.__setNativeMock !== 'function') {
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      const res = produce();
+      if (isPromise(res)) {
+        res.then((mod) => api.__setNativeMock(request, mod)).catch(() => {});
+      } else {
+        api.__setNativeMock(request, res);
+      }
+    } catch {
+      // factory is not standalone-runnable — skip native mocking for it
+    }
+  });
+};
+
+// Deferred on a microtask like `publishNativeMock` so install→uninstall order is
+// preserved: a synchronous unpublish would run BEFORE the deferred publish
+// microtask, which would then re-add a stale entry. Queuing both keeps the last
+// operation winning (`rs.mock` then `rs.unmock` ⇒ removed).
+const unpublishNativeMock = (request) => {
+  if (request === undefined) {
+    return;
+  }
+  queueMicrotask(() => {
+    const api = globalThis.RSTEST_API?.rstest;
+    if (api && typeof api.__unsetNativeMock === 'function') {
+      api.__unsetNativeMock(request);
+    }
+  });
+};
+
 //#region rs.unmock
 __webpack_require__.rstest_unmock = (id, request) => {
   restoreOriginalFactory(id);
@@ -105,6 +172,7 @@ __webpack_require__.rstest_unmock = (id, request) => {
   if (request !== undefined) {
     delete __webpack_require__.rstest_mocked_ids_by_request[request];
   }
+  unpublishNativeMock(request);
 };
 //#endregion
 
@@ -239,6 +307,7 @@ const getMockImplementation = (mockType = 'mock') => {
       };
 
       installFactory(finalModFactory);
+      publishNativeMock(request, () => mockedModule);
       return;
     }
 
@@ -282,6 +351,7 @@ const getMockImplementation = (mockType = 'mock') => {
       };
 
       installFactory(finalModFactory);
+      publishNativeMock(request, modFactory);
     }
   };
 };
@@ -318,6 +388,22 @@ __webpack_require__.rstest_dynamic_require = (id, request) => {
 };
 //#endregion
 
+//#region non-literal dynamic import() mock resolution
+/**
+ * Expose the mocked instance for a clean `request` to the worker's native import
+ * hook (loadEsModule/loadModule `defineRstestDynamicImport`), which handles a
+ * non-literal `import(variable)` outside the webpack runtime. `const s='node:os';
+ * import(s)` then resolves `s` to the mocked module here instead of natively
+ * loading the real one. Published on the shared `globalThis` because the worker
+ * hook has no `__webpack_require__`; returns `undefined` when the request isn't
+ * mocked, so the hook performs its normal native import.
+ */
+globalThis.__rstest_resolve_mocked_dynamic_request__ = (request) => {
+  const mockedId = __webpack_require__.rstest_mocked_ids_by_request[request];
+  return mockedId !== undefined ? __webpack_require__(mockedId) : undefined;
+};
+//#endregion
+
 //#region rs.reset_modules
 __webpack_require__.rstest_reset_modules = () => {
   const mockedIds = Object.keys(__webpack_require__.rstest_original_modules);

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

@@ -10,8 +10,16 @@ import { RSTEST_ENV_SYMBOL_KEY } from '../../utils/constants';
 import { fileContext } from '../fileContext';
 import { getRealTimers } from '../util';
 import type { FakeTimerInstallOpts, FakeTimersSnapshot } from './fakeTimers';
+import {
+  getNativeMock,
+  setNativeMock,
+  unsetNativeMock,
+} from '../worker/mockRegistry';
 import { mockObject as mockObjectImpl } from './mockObject';
 import { initSpy } from './spy';
+// Browser-safe path/URL helpers (no `node:url`/`node:path`); keeps this shared
+// module linkable in the browser runtime build.
+import { pathToFileURL } from 'url-extras';
 
 const DEFAULT_WAIT_TIMEOUT = 1000;
 const DEFAULT_WAIT_INTERVAL = 50;
@@ -124,6 +132,34 @@ let utilitiesPromise:
  * per-file `useRealTimers`, unchanged.
  * See https://github.com/web-infra-dev/rstest/issues/1376.
  */
+// #1454: browser-safe key computation for the native-mock bridge.
+// Mirrors the Node-only hook key (nativeMockHooks.ts) but imports nothing from
+// `node:url` / `node:module`, so this shared module stays linkable in the
+// browser runtime build. `import.meta.resolve` is undefined in browser mode, so
+// only the trivial `node:` short-circuit survives there (native mocks are
+// meaningless without Node's loader anyway).
+const nativeImportMetaResolve = import.meta.resolve?.bind(import.meta);
+
+const resolveNativeMockKey = (
+  request: string,
+  base: string,
+): string | undefined => {
+  // `import.meta.resolve` returns the `node:`-prefixed form for bare builtins
+  // ('os' → 'node:os'), matching `toNodeBuiltin` on the hook side; an explicit
+  // `node:` specifier needs no resolution.
+  if (request.startsWith('node:')) {
+    return request;
+  }
+  if (!nativeImportMetaResolve) {
+    return undefined;
+  }
+  try {
+    return nativeImportMetaResolve(request, pathToFileURL(base).href);
+  } catch {
+    return undefined;
+  }
+};
+
 export const createRstestUtilities = async (): Promise<RstestUtilities> => {
   utilitiesPromise ??= buildRstestUtilities();
   const bound = await utilitiesPromise;
@@ -633,5 +669,52 @@ const buildRstestUtilities = async (): Promise<{
     currentFakeTimersConfig = undefined;
   };
 
+  // #1454: bridge the bundle's mock runtime to the worker-realm `mockRegistry`
+  // that the Node `registerHooks` load hook reads. Called from
+  // `mockRuntimeCode.js` at rs.mock/unmock time over the existing RSTEST_API
+  // channel (the same one `mockObject` uses). Keyed by the specifier resolved
+  // against the test file so a natively-loaded module's internal `import 'B'` —
+  // resolved by Node against that module's own URL — lands on the same key for
+  // builtins and same-realpath npm deps.
+  const bridge = rstest as RstestUtilities & {
+    __setNativeMock?: (
+      request: string,
+      settledExports: Record<string, unknown>,
+    ) => void;
+    __unsetNativeMock?: (request: string) => void;
+    // Bundler retention anchor, not runtime API — see the assignment below.
+    __getNativeMock?: typeof getNativeMock;
+  };
+  // Bundler anchor (never invoked): the synthetic mock module the Node load hook
+  // generates does `import { getNativeMock } from <REGISTRY_URL>` at RUNTIME, so
+  // the registry chunk must keep `getNativeMock` as a NAMED export. mockRegistry
+  // and nativeMockHooks share one chunk, so their internal use is inlined and
+  // does NOT retain the export; this assignment from the api chunk is a real
+  // cross-chunk consumer, which forces the bundler to keep it. (Verified: drop
+  // it and the synthetic import fails to link — `does not provide an export`.)
+  bridge.__getNativeMock = getNativeMock;
+  bridge.__setNativeMock = (request, settledExports) => {
+    const key = resolveNativeMockKey(
+      request,
+      fileContext().workerState.testPath,
+    );
+    if (
+      key !== undefined &&
+      settledExports &&
+      typeof settledExports === 'object'
+    ) {
+      setNativeMock(key, settledExports);
+    }
+  };
+  bridge.__unsetNativeMock = (request) => {
+    const key = resolveNativeMockKey(
+      request,
+      fileContext().workerState.testPath,
+    );
+    if (key !== undefined) {
+      unsetNativeMock(key);
+    }
+  };
+
   return { rstest, resetForFile };
 };

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

@@ -8,6 +8,7 @@ import {
   finalizeDynamicImport,
   loadWasmFromContent,
   resolveImportSpecifier,
+  maybeResolveMockedDynamicImport,
 } from './resolveDynamicImport';
 import {
   RSTEST_DYNAMIC_IMPORT_HOOK,
@@ -104,6 +105,13 @@ const defineRstestDynamicImport =
     importAttributes: ImportCallOptions,
     origin?: string,
   ) => {
+    // #1454: route `import(variable)` of a mocked module to the bundle's mock
+    // instance before any native load (policy in resolveDynamicImport.ts).
+    const mocked = maybeResolveMockedDynamicImport(specifier, returnModule);
+    if (mocked !== undefined) {
+      return mocked;
+    }
+
     const currentDirectory = path.dirname(distPath);
 
     const joinedPath = isRelativePath(specifier)

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

@@ -8,6 +8,7 @@ import {
   finalizeDynamicImport,
   loadWasmFromContent,
   resolveImportSpecifier,
+  maybeResolveMockedDynamicImport,
 } from './resolveDynamicImport';
 import {
   RSTEST_DYNAMIC_IMPORT_HOOK,
@@ -127,6 +128,13 @@ const defineRstestDynamicImport =
     importAttributes: ImportCallOptions,
     origin?: string,
   ) => {
+    // #1454: route `import(variable)` of a mocked module to the bundle's mock
+    // instance before any native load (policy in resolveDynamicImport.ts).
+    const mocked = maybeResolveMockedDynamicImport(specifier, returnModule);
+    if (mocked !== undefined) {
+      return mocked;
+    }
+
     const modulePath = resolveImportSpecifier({ specifier, origin, testPath });
 
     // Bundled `.wasm` is emitted as an in-memory asset file and must be