@mandujs/core 0.54.32 → 0.55.0-beta.1

package/src/bundler/__tests__/hmr-client.test.ts

@@ -41,11 +41,16 @@ import {
 import { createHMRServer, type HMRServer } from "../dev";
 import { PORTS } from "../../constants";
 
+const describeCoreIsolated =
+  process.env.MANDU_SKIP_CORE_ISOLATED_TESTS === "1"
+    ? describe.skip
+    : describe;
+
 // ═══════════════════════════════════════════════════════════════════
 // Section A — `ManduHot` runtime
 // ═══════════════════════════════════════════════════════════════════
 
-describe("createManduHot — Vite-compat import.meta.hot runtime", () => {
+describeCoreIsolated("createManduHot — Vite-compat import.meta.hot runtime", () => {
   beforeEach(() => {
     _resetRegistryForTests();
   });
@@ -172,22 +177,22 @@ describe("createManduHot — Vite-compat import.meta.hot runtime", () => {
  * Utility: spin up an HMR server and return it plus the public port the
  * client should dial. The caller owns teardown via `afterEach`.
  *
- * We pass `port: 0` ... almost. `createHMRServer` computes
- * `port + PORTS.HMR_OFFSET` internally, so if we want an ephemeral
- * listener we'd need to bind ahead of time. These tests instead use a
- * process-local monotonic port allocator to avoid random collisions
- * during the full parallel core suite.
- */
-const HMR_TEST_PORT_STATE = "__MANDU_HMR_TEST_PORT_STATE__";
-
-function pickPort(): number {
-  const stateGlobal = globalThis as typeof globalThis & {
-    __MANDU_HMR_TEST_PORT_STATE__?: { next: number };
-  };
-  stateGlobal.__MANDU_HMR_TEST_PORT_STATE__ ??= { next: 0 };
-  const index = stateGlobal.__MANDU_HMR_TEST_PORT_STATE__.next++;
-  return 41000 + (((process.pid % 3500) * 2 + index * 2) % 7000);
-}
+ * We pass `port: 0` ... almost. `createHMRServer` computes
+ * `port + PORTS.HMR_OFFSET` internally, so if we want an ephemeral
+ * listener we'd need to bind ahead of time. These tests instead use a
+ * process-local monotonic port allocator to avoid random collisions
+ * during the full parallel core suite.
+ */
+const HMR_TEST_PORT_STATE = "__MANDU_HMR_TEST_PORT_STATE__";
+
+function pickPort(): number {
+  const stateGlobal = globalThis as typeof globalThis & {
+    __MANDU_HMR_TEST_PORT_STATE__?: { next: number };
+  };
+  stateGlobal.__MANDU_HMR_TEST_PORT_STATE__ ??= { next: 0 };
+  const index = stateGlobal.__MANDU_HMR_TEST_PORT_STATE__.next++;
+  return 41000 + (((process.pid % 3500) * 2 + index * 2) % 7000);
+}
 
 /**
  * A wrapper around WebSocket that stashes every incoming message in an
@@ -206,7 +211,7 @@ interface MessageClient {
 
 async function connectWS(hmrPort: number, since?: number): Promise<MessageClient> {
   const qs = since !== undefined ? `?since=${since}` : "";
-  const ws = new WebSocket(`ws://localhost:${hmrPort}${qs ? "/" + qs : ""}`);
+  const ws = new WebSocket(`ws://127.0.0.1:${hmrPort}${qs ? "/" + qs : ""}`);
   const messages: unknown[] = [];
   const waiters: Array<{ idx: number; resolve: (v: unknown) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> }> = [];
 
@@ -262,14 +267,14 @@ function waitFor(ms: number): Promise<void> {
   return new Promise((r) => setTimeout(r, ms));
 }
 
-describe("createHMRServer — replay buffer semantics", () => {
+describeCoreIsolated("createHMRServer — replay buffer semantics", () => {
   let server: HMRServer | null = null;
   let hmrPort = 0;
 
   beforeEach(() => {
     const basePort = pickPort();
     hmrPort = basePort + PORTS.HMR_OFFSET;
-    server = createHMRServer(basePort);
+    server = createHMRServer(basePort, { hostname: "127.0.0.1" });
   });
 
   afterEach(() => {
@@ -366,14 +371,14 @@ describe("createHMRServer — replay buffer semantics", () => {
 // Section C — Wire-format + layout-update + invalidate upstream
 // ═══════════════════════════════════════════════════════════════════
 
-describe("createHMRServer — wire format + event dispatch", () => {
+describeCoreIsolated("createHMRServer — wire format + event dispatch", () => {
   let server: HMRServer | null = null;
   let hmrPort = 0;
 
   beforeEach(() => {
     const basePort = pickPort();
     hmrPort = basePort + PORTS.HMR_OFFSET;
-    server = createHMRServer(basePort);
+    server = createHMRServer(basePort, { hostname: "127.0.0.1" });
   });
 
   afterEach(() => {
@@ -442,6 +447,39 @@ describe("createHMRServer — wire format + event dispatch", () => {
     });
   });
 
+  test("[13a] a build error reaches new browsers until a successful recovery", async () => {
+    server!.broadcast({
+      type: "error",
+      data: {
+        name: "BuildError",
+        kind: "build",
+        message: "synthetic build failure",
+        routeId: "home",
+        timestamp: Date.now(),
+      },
+    });
+
+    const failedClient = await connectWS(hmrPort);
+    expect(await failedClient.awaitMessage(0)).toMatchObject({ type: "connected" });
+    expect(await failedClient.awaitMessage(1)).toMatchObject({
+      type: "error",
+      data: {
+        name: "BuildError",
+        kind: "build",
+        message: "synthetic build failure",
+        routeId: "home",
+      },
+    });
+    failedClient.ws.close();
+
+    server!.broadcast({ type: "reload", data: { timestamp: Date.now() } });
+    const recoveredClient = await connectWS(hmrPort);
+    expect(await recoveredClient.awaitMessage(0)).toMatchObject({ type: "connected" });
+    await waitFor(25);
+    expect(recoveredClient.peek()).toHaveLength(1);
+    recoveredClient.ws.close();
+  });
+
   test("[14] reconnect with since=0 after many broadcasts and no buffered survivors → full-reload", async () => {
     // Fire enough envelopes to push id past MAX_REPLAY_BUFFER — oldestId
     // becomes > 0, so since=0 is older than oldestId.
@@ -490,7 +528,7 @@ describe("createHMRServer — wire format + event dispatch", () => {
 // Section D — Integration: runtime + envelope produced by server
 // ═══════════════════════════════════════════════════════════════════
 
-describe("integration — ManduHot + broadcastVite envelope shape", () => {
+describeCoreIsolated("integration — ManduHot + broadcastVite envelope shape", () => {
   beforeEach(() => {
     _resetRegistryForTests();
   });
@@ -521,7 +559,7 @@ describe("integration — ManduHot + broadcastVite envelope shape", () => {
 
   test("[17] HMRReplayEnvelope id is monotonic even across size eviction (ids don't reset)", () => {
     const envelopes: HMRReplayEnvelope[] = [];
-    const server = createHMRServer(pickPort());
+    const server = createHMRServer(pickPort(), { hostname: "127.0.0.1" });
     try {
       for (let i = 0; i < MAX_REPLAY_BUFFER + 3; i++) {
         envelopes.push(server.broadcastVite({ type: "full-reload", path: `/p-${i}` }));

package/src/bundler/__tests__/jsx-runtime-shim.test.ts

@@ -1,140 +1,179 @@
-/**
- * Regression guard for issues #322 / #323 — dev island hydration broke with
- * `TypeError: jsxDEV is not a function`.
- *
- * #322: the shim imported `jsxDEV` from bare `"react"`, which (via the import
- * map → `_react.js`) only worked if `_react.js` re-exported jsxDEV.
- * #323: the "fix" changed the import to `"react/jsx-dev-runtime"`, but the
- * import map maps `react/jsx-dev-runtime` to THIS shim — a circular
- * self-import, so jsxDEV stayed `undefined`.
- *
- * The correct source: import JSX runtime functions from bare `"react"`, which
- * the import map resolves to the self-contained `_react.js` vendor bundle
- * (built with no `external`, so the real jsx/jsxs/jsxDEV/Fragment are inlined
- * and re-exported). The shim must NEVER import from the import-map-aliased
- * subpath that points back at itself.
- */
-import { describe, expect, test } from "bun:test";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import {
-  _testOnly_generateJsxDevRuntimeShimSource,
-  _testOnly_generateJsxRuntimeShimSource,
-} from "../build";
-
-describe("JSX runtime shim sources (issues #322 / #323)", () => {
-  test("dev shim imports jsxDEV/Fragment from bare 'react', never the self-aliased subpath", () => {
-    const source = _testOnly_generateJsxDevRuntimeShimSource();
-
-    // #323: must NOT import from 'react/jsx-dev-runtime' — that is this shim's
-    // own import-map alias, which would be a circular self-import. (Targets
-    // the import statement, not comment mentions of the path.)
-    expect(source).not.toMatch(/from\s*['"]react\/jsx-dev-runtime['"]/);
-
-    // Correct: jsxDEV (+ jsx/jsxs fallback inputs) come from bare 'react'
-    // (→ _react.js). Import includes jsxDEV and resolves from "react".
-    expect(source).toMatch(/import\s*\{[^}]*\bjsxDEV\b[^}]*\}\s*from\s*['"]react['"]/);
-
-    // Shim still re-exports what the import map expects.
-    expect(source).toContain("export { jsxDEV, Fragment }");
-  });
-
-  test("prod shim imports jsx/jsxs/Fragment from bare 'react', never the self-aliased subpath", () => {
-    const source = _testOnly_generateJsxRuntimeShimSource();
-
-    // #323: must NOT import from 'react/jsx-runtime' (this shim's own alias).
-    expect(source).not.toMatch(/from\s*['"]react\/jsx-runtime['"]/);
-
-    expect(source).toMatch(
-      /import\s*\{\s*jsx\s*,\s*jsxs\s*,\s*Fragment\s*\}\s*from\s*['"]react['"]/,
-    );
-
-    expect(source).toContain("export { jsx, jsxs, Fragment }");
-  });
-
-  // #323 build-level guard: the SOURCE test alone missed the real bug because
-  // the broken 0.54.24 build still emitted `from "react/jsx-dev-runtime"` in
-  // the OUTPUT (the import-map alias pointing back at this shim). Build the
-  // shim the same way buildVendorShims does (external: ["react"]) and assert
-  // the emitted module never self-imports the alias.
-  test("built dev shim never self-imports react/jsx-dev-runtime", async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), "mandu-jsx-shim-"));
-    try {
-      const srcPath = path.join(dir, "_jsx-dev-runtime.js");
-      await writeFile(srcPath, _testOnly_generateJsxDevRuntimeShimSource(), "utf-8");
-
-      const result = await Bun.build({
-        entrypoints: [srcPath],
-        external: ["react"],
-        target: "browser",
-      });
-
-      expect(result.success).toBe(true);
-      const out = await result.outputs[0]!.text();
-
-      // The emitted shim must source jsxDEV from bare 'react' (→ _react.js),
-      // NOT from the import-map alias that resolves back to itself.
-      expect(out).not.toMatch(/from\s*["']react\/jsx-dev-runtime["']/);
-      expect(out).toMatch(/from\s*["']react["']/);
-      expect(out).toContain("jsxDEV");
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  // #323 re-regression (0.54.30): a SOURCE/static check passed but at RUNTIME
-  // `_react.js`'s jsxDEV was `undefined` (jsxDEV is a React dev-only export;
-  // a production-built _react.js drops it while keeping jsx/jsxs). The shim
-  // re-exported that undefined → "jsxDEV is not a function". Guard the VALUE:
-  // build the dev shim against a `react` stub whose jsxDEV is undefined (the
-  // exact failing condition) and assert the shim still exposes a callable
-  // jsxDEV via its jsx/jsxs fallback.
-  test("dev shim exposes a callable jsxDEV even when react.jsxDEV is undefined (runtime value)", async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), "mandu-jsx-shim-rt-"));
-    try {
-      // Stub for bare 'react' = a production-built _react.js: jsx/jsxs are real
-      // functions, jsxDEV is missing.
-      const reactStub = path.join(dir, "react-stub.js");
-      await writeFile(
-        reactStub,
-        [
-          "export const jsx = (type) => ({ type, runtime: 'jsx' });",
-          "export const jsxs = (type) => ({ type, runtime: 'jsxs' });",
-          "export const Fragment = Symbol.for('react.fragment');",
-          "export const jsxDEV = undefined;",
-        ].join("\n"),
-        "utf-8",
-      );
-
-      // Generate the real shim source, but resolve its bare `react` import to
-      // the stub so we can drive the undefined-jsxDEV condition.
-      const shimSource = _testOnly_generateJsxDevRuntimeShimSource().replace(
-        /from\s*['"]react['"]/g,
-        `from ${JSON.stringify(reactStub.replace(/\\/g, "/"))}`,
-      );
-      const shimSrc = path.join(dir, "_jsx-dev-runtime.src.js");
-      await writeFile(shimSrc, shimSource, "utf-8");
-
-      const result = await Bun.build({
-        entrypoints: [shimSrc],
-        target: "browser",
-        define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      });
-      expect(result.success).toBe(true);
-
-      const outPath = path.join(dir, "_jsx-dev-runtime.built.js");
-      await writeFile(outPath, await result.outputs[0]!.text(), "utf-8");
-      const mod = await import(`${pathToFileURL(outPath).href}?t=${Date.now()}`);
-
-      // The whole point of #323's re-regression: jsxDEV must be CALLABLE.
-      expect(typeof mod.jsxDEV).toBe("function");
-      // Fallback routes static-children to jsxs, otherwise jsx.
-      expect(mod.jsxDEV("div", {}, undefined, false).runtime).toBe("jsx");
-      expect(mod.jsxDEV("div", {}, undefined, true).runtime).toBe("jsxs");
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});
+/**
+ * Regression guard for issues #322 / #323 — dev island hydration broke with
+ * `TypeError: jsxDEV is not a function`.
+ *
+ * #322: the shim imported `jsxDEV` from bare `"react"`, which (via the import
+ * map → `_react.js`) only worked if `_react.js` re-exported jsxDEV.
+ * #323: the "fix" changed the import to `"react/jsx-dev-runtime"`, but the
+ * import map maps `react/jsx-dev-runtime` to THIS shim — a circular
+ * self-import, so jsxDEV stayed `undefined`.
+ *
+ * The correct source: import JSX runtime functions from bare `"react"`, which
+ * the import map resolves to the self-contained `_react.js` vendor bundle
+ * (built with no `external`, so the real jsx/jsxs/jsxDEV/Fragment are inlined
+ * and re-exported). The shim must NEVER import from the import-map-aliased
+ * subpath that points back at itself.
+ */
+import { describe, expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  _testOnly_generateJsxDevRuntimeShimSource,
+  _testOnly_generateJsxRuntimeShimSource,
+} from "../build";
+
+const describeBundler = describe.skipIf(
+  process.env.MANDU_SKIP_BUNDLER_TESTS === "1",
+);
+
+describeBundler("JSX runtime shim sources (issues #322 / #323)", () => {
+  test("dev shim imports jsxDEV/Fragment from bare 'react', never the self-aliased subpath", () => {
+    const source = _testOnly_generateJsxDevRuntimeShimSource();
+
+    // #323: must NOT import from 'react/jsx-dev-runtime' — that is this shim's
+    // own import-map alias, which would be a circular self-import. (Targets
+    // the import statement, not comment mentions of the path.)
+    expect(source).not.toMatch(/from\s*['"]react\/jsx-dev-runtime['"]/);
+
+    // Correct: jsxDEV (+ jsx/jsxs fallback inputs) come from bare 'react'
+    // (→ _react.js). Import includes jsxDEV and resolves from "react".
+    expect(source).toMatch(/import\s*\{[^}]*\bjsxDEV\b[^}]*\}\s*from\s*['"]react['"]/);
+
+    // Shim still re-exports what the import map expects.
+    expect(source).toContain("export { jsxDEV, Fragment }");
+  });
+
+  test("prod shim imports jsx/jsxs/Fragment from bare 'react', never the self-aliased subpath", () => {
+    const source = _testOnly_generateJsxRuntimeShimSource();
+
+    // #323: must NOT import from 'react/jsx-runtime' (this shim's own alias).
+    expect(source).not.toMatch(/from\s*['"]react\/jsx-runtime['"]/);
+
+    expect(source).toMatch(
+      /import\s*\{\s*jsx\s*,\s*jsxs\s*,\s*Fragment\s*\}\s*from\s*['"]react['"]/,
+    );
+
+    expect(source).toContain("export { jsx, jsxs, Fragment }");
+  });
+
+  // #323 build-level guard: the SOURCE test alone missed the real bug because
+  // the broken 0.54.24 build still emitted `from "react/jsx-dev-runtime"` in
+  // the OUTPUT (the import-map alias pointing back at this shim). Build the
+  // shim the same way buildVendorShims does (external: ["react"]) and assert
+  // the emitted module never self-imports the alias.
+  test("built dev shim never self-imports react/jsx-dev-runtime", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "mandu-jsx-shim-"));
+    try {
+      const srcPath = path.join(dir, "_jsx-dev-runtime.js");
+      await writeFile(srcPath, _testOnly_generateJsxDevRuntimeShimSource(), "utf-8");
+
+      const result = await Bun.build({
+        entrypoints: [srcPath],
+        external: ["react"],
+        target: "browser",
+      });
+
+      expect(result.success).toBe(true);
+      const out = await result.outputs[0]!.text();
+
+      // The emitted shim must source jsxDEV from bare 'react' (→ _react.js),
+      // NOT from the import-map alias that resolves back to itself.
+      expect(out).not.toMatch(/from\s*["']react\/jsx-dev-runtime["']/);
+      expect(out).toMatch(/from\s*["']react["']/);
+      expect(out).toContain("jsxDEV");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  // #323 re-regression (0.54.30): a SOURCE/static check passed but at RUNTIME
+  // `_react.js`'s jsxDEV was `undefined` (jsxDEV is a React dev-only export;
+  // a production-built _react.js drops it while keeping jsx/jsxs). The shim
+  // re-exported that undefined → "jsxDEV is not a function". Guard the VALUE:
+  // build the dev shim against a `react` stub whose jsxDEV is undefined (the
+  // exact failing condition) and assert the shim still exposes a callable
+  // jsxDEV via its jsx/jsxs fallback.
+  test("dev shim exposes a callable jsxDEV even when react.jsxDEV is undefined (runtime value)", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "mandu-jsx-shim-rt-"));
+    try {
+      // Stub for bare 'react' = a production-built _react.js: jsx/jsxs are real
+      // functions, jsxDEV is missing.
+      const reactStub = path.join(dir, "react-stub.js");
+      await writeFile(
+        reactStub,
+        [
+          "export const jsx = (type) => ({ type, runtime: 'jsx' });",
+          "export const jsxs = (type) => ({ type, runtime: 'jsxs' });",
+          "export const Fragment = Symbol.for('react.fragment');",
+          "export const jsxDEV = undefined;",
+        ].join("\n"),
+        "utf-8",
+      );
+
+      // Generate the real shim source, but resolve its bare `react` import to
+      // the stub so we can drive the undefined-jsxDEV condition.
+      const shimSource = _testOnly_generateJsxDevRuntimeShimSource().replace(
+        /from\s*['"]react['"]/g,
+        `from ${JSON.stringify(reactStub.replace(/\\/g, "/"))}`,
+      );
+      const shimSrc = path.join(dir, "_jsx-dev-runtime.src.js");
+      await writeFile(shimSrc, shimSource, "utf-8");
+
+      const result = await Bun.build({
+        entrypoints: [shimSrc],
+        target: "browser",
+        define: { "process.env.NODE_ENV": JSON.stringify("production") },
+      });
+      expect(result.success).toBe(true);
+
+      const outPath = path.join(dir, "_jsx-dev-runtime.built.js");
+      await writeFile(outPath, await result.outputs[0]!.text(), "utf-8");
+
+      // Import through a relative specifier in a fresh Bun process. This
+      // exercises the public export while avoiding Bun 1.3's unreliable
+      // in-process resolution of temporary absolute file URLs on macOS.
+      const probePath = path.join(dir, "probe.js");
+      await writeFile(
+        probePath,
+        [
+          "import * as runtime from './_jsx-dev-runtime.built.js';",
+          "console.log(JSON.stringify({",
+          "  type: typeof runtime.jsxDEV,",
+          "  single: runtime.jsxDEV('div', {}, undefined, false).runtime,",
+          "  multi: runtime.jsxDEV('div', {}, undefined, true).runtime,",
+          "}));",
+        ].join("\n"),
+        "utf-8",
+      );
+
+      const proc = Bun.spawn([process.execPath, "run", probePath], {
+        cwd: dir,
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+      ]);
+      if (exitCode !== 0) {
+        throw new Error(`Built JSX runtime probe failed (${exitCode}): ${stderr}`);
+      }
+      const probe = JSON.parse(stdout.trim()) as {
+        type: string;
+        single: string;
+        multi: string;
+      };
+
+      // The whole point of #323's re-regression: jsxDEV must be CALLABLE.
+      expect(probe.type).toBe("function");
+      // Fallback routes static-children to jsxs, otherwise jsx.
+      expect(probe.single).toBe("jsx");
+      expect(probe.multi).toBe("jsxs");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});