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

`new URL('./file', import.meta.url)` was rewritten by rspack into a hashed
bundled asset path, which does not exist at runtime in the vm worker -> ENOENT.
Set `module.parser.javascript.url = false` so these expressions stay
source-relative, matching Node.js and Vitest.

Rework wasm handling on top of that: disable rspack's `webassembly/async` and
turn each `.wasm` into a self-contained JS module via a build-time loader that
reads its on-disk source bytes and instantiates them. This removes the
hardcoded string-replace of rspack's generated `async_wasm_loading` runtime
(`readFile(` -> `readWasmFile(`) and transparently supports import-bearing wasm
(wasm-bindgen `--target bundler`) by wiring an importObject from statically
imported glue modules. Wasm namespaces no longer carry a synthetic `default`,
matching Node's WebAssembly ESM namespace.

Claude-Session: https://claude.ai/code/session_01DWZvBGqkLP4X21iMa9Rhsq

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/wasm-imports/index.test.ts

@@ -0,0 +1,23 @@
+import { expect, test } from '@rstest/core';
+import { callExp } 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();
+});

e2e/wasm-imports/src/envmod.wasm

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

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

@@ -0,0 +1,61 @@
+// 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'),
+);

e2e/wasm-imports/src/generate.mjs

@@ -0,0 +1,2 @@
+export function imp(): number;
+export function callExp(): number;

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

@@ -0,0 +1,10 @@
+// Stands in for a wasm-bindgen `--target bundler` foo_bg.js: it imports the
+// wasm namespace (circular with the wasm), and exports the function the wasm
+// imports as a hoisted declaration so it is bound at link time.
+import * as wasm from './mod.wasm';
+export function imp() {
+  return 42;
+}
+export function callExp() {
+  return wasm.exp();
+}

e2e/wasm-imports/src/glue.js

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