fix(core): resolve new URL() and wasm from on-disk source (#1455) (#1464)

Author: fi3ework

e2e/new-url/index.test.ts

@@ -0,0 +1,12 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { expect, it } from '@rstest/core';
+
+// Regression test for #1455: `new URL(<relative literal>, import.meta.url)`
+// must resolve at runtime relative to the source module, instead of being
+// rewritten by Rspack into a hashed bundled asset path.
+it('resolves a sibling file via new URL(..., import.meta.url)', () => {
+  const siblingPath = fileURLToPath(new URL('./sibling.txt', import.meta.url));
+  expect(siblingPath).toMatch(/[\\/]new-url[\\/]sibling\.txt$/);
+  expect(readFileSync(siblingPath, 'utf8')).toBe('hello');
+});

e2e/new-url/sibling.txt

@@ -0,0 +1 @@
+hello

e2e/rstest.config.mts

@@ -1,3 +1,4 @@
+import { fileURLToPath } from 'node:url';
 import { defineConfig } from '@rstest/core';
 
 /**
@@ -42,6 +43,16 @@ export default defineConfig({
       react: 'commonjs react',
     },
   },
+  resolve: {
+    alias: {
+      // Fixture-only: lets wasm-imports/src/aliasmod.wasm reach its glue through
+      // a non-relative specifier, exercising the wasm loader's resolver-based
+      // import wiring (bare/alias, not just `./` paths).
+      '@e2e/wasm-glue': fileURLToPath(
+        new URL('./wasm-imports/src/alias-glue.js', import.meta.url),
+      ),
+    },
+  },
   pool: {
     // Limit to 80% of available workers to reduce "worker exited unexpectedly"
     // errors in resource-constrained environments (e.g., certain CI runners).

e2e/wasm-imports/index.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from '@rstest/core';
+import { callExp, getImpCalls } from './src/glue.js';
+
+// Import-bearing wasm (the wasm declares `(import "<module>" "imp" ...)`):
+// - mod.wasm imports a RESOLVABLE JS module ('./glue.js') — the wasm-bindgen
+//   `--target bundler` shape, including the circular glue<->wasm dependency.
+//   wasmLoader.mjs links the glue statically and instantiates with an
+//   importObject, so a plain `import` works transparently.
+// - envmod.wasm imports the synthetic, non-resolvable 'env' module: the build
+//   must still succeed (no `import 'env'` emitted) and only fail at runtime.
+
+test('resolvable glue import: circular wasm-bindgen-bundler shape links transparently', () => {
+  expect(callExp()).toBe(42); // glue.callExp -> wasm.exp -> imports ./glue.js imp() -> 42
+});
+
+test('direct import of an import-bearing wasm resolves its importObject', async () => {
+  const ns = await import('./src/mod.wasm');
+  expect(ns.exp()).toBe(42);
+});
+
+test('non-resolvable env import builds, and only LinkErrors at runtime', async () => {
+  await expect(import('./src/envmod.wasm')).rejects.toThrow();
+});
+
+// The wasm loader wires an import-module by actually resolving it, not by
+// checking for a `./ ../ /` prefix. aliasmod.wasm imports `@e2e/wasm-glue`
+// (a non-relative specifier mapped via resolve.alias); a prefix-only heuristic
+// would drop it and the wasm would LinkError. Actual resolution wires the glue.
+test('alias import module: non-relative specifier resolves its glue via resolve.alias', async () => {
+  const ns = await import('./src/aliasmod.wasm');
+  expect(ns.exp()).toBe(42); // wasm.exp -> imports @e2e/wasm-glue imp() -> 42
+});
+
+// Regression guard for the load-bearing property that distinguishes the
+// build-time wasmLoader from any native auto-link approach: the glue the test
+// imports and the glue the wasm links against must be the SAME instance. The
+// loader keeps glue in rspack's module graph (one shared instance), so a state
+// mutation the wasm triggers through `imp()` is observable here. A native
+// `import('x.wasm')` would link the wasm against a separate Node-loaded glue
+// copy, leaving `getImpCalls()` at its prior value (split-brain).
+test('import-bearing wasm links the same glue instance the test holds (no split-brain)', () => {
+  const before = getImpCalls();
+  callExp(); // -> wasm.exp() -> calls glue.imp() exactly once
+  expect(getImpCalls()).toBe(before + 1);
+});

e2e/wasm-imports/src/alias-glue.js

@@ -0,0 +1,7 @@
+// Glue for aliasmod.wasm, reached through a `resolve.alias` (see the e2e root
+// config's `@e2e/wasm-glue` entry). It exercises the loader wiring an
+// import-module whose specifier is NOT relative (`./ ../ /`): the old
+// prefix heuristic dropped these, actual resolution wires them.
+export function imp() {
+  return 42;
+}

e2e/wasm-imports/src/aliasmod.wasm

@@ -0,0 +1 @@
+export function exp(): number;

e2e/wasm-imports/src/aliasmod.wasm.d.ts

@@ -0,0 +1 @@
+export function exp(): number;

e2e/wasm-imports/src/envmod.wasm

@@ -0,0 +1,67 @@
+// Regenerates the two minimal wasm fixtures used by ../index.test.ts.
+// Run: `node src/generate.mjs`. Each module imports `<mod>.imp: () => i32`
+// and exports `exp: () => i32` whose body is `call imp`.
+import { writeFileSync } from 'node:fs';
+
+const str = (s) => [s.length, ...[...s].map((c) => c.charCodeAt(0))];
+const wasmImporting = (mod, name) => {
+  const imp = [0x01, ...str(mod), ...str(name), 0x00, 0x00]; // import mod.name func t0
+  return Buffer.from([
+    0x00,
+    0x61,
+    0x73,
+    0x6d,
+    0x01,
+    0x00,
+    0x00,
+    0x00, // magic + version
+    0x01,
+    0x05,
+    0x01,
+    0x60,
+    0x00,
+    0x01,
+    0x7f, // type: () -> i32
+    0x02,
+    imp.length,
+    ...imp, // import section
+    0x03,
+    0x02,
+    0x01,
+    0x00, // func: exp uses t0
+    0x07,
+    0x07,
+    0x01,
+    0x03,
+    0x65,
+    0x78,
+    0x70,
+    0x00,
+    0x01, // export "exp" func#1
+    0x0a,
+    0x06,
+    0x01,
+    0x04,
+    0x00,
+    0x10,
+    0x00,
+    0x0b, // code: call 0; end
+  ]);
+};
+
+// Resolvable glue import (wasm-bindgen --target bundler shape).
+writeFileSync(
+  new URL('./mod.wasm', import.meta.url),
+  wasmImporting('./glue.js', 'imp'),
+);
+// Synthetic, non-resolvable import (emscripten/wasi shape).
+writeFileSync(
+  new URL('./envmod.wasm', import.meta.url),
+  wasmImporting('env', 'imp'),
+);
+// Non-relative but resolvable import module: reaches its glue through a
+// `resolve.alias` entry rather than a `./` path (see ../index.test.ts).
+writeFileSync(
+  new URL('./aliasmod.wasm', import.meta.url),
+  wasmImporting('@e2e/wasm-glue', 'imp'),
+);