@mandujs/core 0.54.13 → 0.54.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandujs/core",
-  "version": "0.54.13",
+  "version": "0.54.15",
   "description": "Mandu Framework Core - Spec, Generator, Guard, Runtime",
   "type": "module",
   "main": "./src/index.ts",

package/src/bundler/__tests__/build-runner.ts

@@ -100,11 +100,11 @@ const manifest: RoutesManifest = mode === "server-page-client-module"
           },
         ],
       }
-  : mode === "hydration-no-client-module"
-    ? {
-        version: 1,
-        routes: [
-          {
+  : mode === "hydration-no-client-module"
+    ? {
+        version: 1,
+        routes: [
+          {
             id: "login",
             kind: "page",
             pattern: "/login",
@@ -115,13 +115,32 @@ const manifest: RoutesManifest = mode === "server-page-client-module"
               priority: "immediate",
               preload: false,
             },
-          },
-        ],
-      }
-    : {
-        version: 1,
-        routes: [
-          {
+          },
+        ],
+      }
+  : mode === "i18n-locale-route-id"
+    ? {
+        version: 1,
+        routes: [
+          {
+            id: "ko::demo",
+            kind: "page",
+            pattern: "/ko",
+            module: "app/page.tsx",
+            componentModule: "app/page.tsx",
+            clientModule: "app/demo.client.tsx",
+            hydration: {
+              strategy: "island",
+              priority: "visible",
+              preload: false,
+            },
+          },
+        ],
+      }
+    : {
+        version: 1,
+        routes: [
+          {
             id: "demo",
             kind: "page",
             pattern: "/",

package/src/bundler/__tests__/fast-refresh.test.ts

@@ -19,9 +19,9 @@
  *   packages/core/src/runtime/fast-refresh-runtime.ts
  */
 
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, mkdir, rm, writeFile, readFile } from "fs/promises";
-import path from "path";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, rm, writeFile, readFile } from "fs/promises";
+import path from "path";
 
 import {
   appendBoundary,
@@ -40,12 +40,19 @@ import {
   _isRefreshScheduledForTests,
   type ReactRefreshRuntime,
 } from "../../runtime/fast-refresh-runtime";
-import {
-  createManduHot,
-  dispatchReplacement,
-  _resetRegistryForTests,
-} from "../../runtime/hmr-client";
-import { generateFastRefreshPreamble } from "../dev";
+import {
+  createManduHot,
+  dispatchReplacement,
+  _resetRegistryForTests,
+} from "../../runtime/hmr-client";
+import { generateFastRefreshPreamble } from "../dev";
+
+const repoTempRoot = path.resolve(import.meta.dir, "../../../../..", ".tmp-test-artifacts");
+
+async function mkRepoTempDir(prefix: string): Promise<string> {
+  await mkdir(repoTempRoot, { recursive: true });
+  return mkdtemp(path.join(repoTempRoot, prefix));
+}
 
 // ═══════════════════════════════════════════════════════════════════
 // Section A — plugin pure unit tests
@@ -263,10 +270,10 @@ describe("manduHMR — __MANDU_HMR__ global behavior", () => {
 describe.skipIf(process.env.MANDU_SKIP_BUNDLER_TESTS === "1")(
   "Bun.build({ reactFastRefresh: true }) + fastRefreshPlugin()",
   () => {
-    let rootDir: string;
-
-    beforeAll(async () => {
-      rootDir = await mkdtemp(path.join(import.meta.dir, ".tmp-fr-build-"));
+    let rootDir: string;
+
+    beforeAll(async () => {
+      rootDir = await mkRepoTempDir("fr-build-");
       // Three source files — one boundary, one plain, one .island.tsx —
       // give us the minimal matrix for the plugin's include filter.
       await writeFile(
@@ -512,10 +519,10 @@ describe("dispatchReplacement + __MANDU_HMR__ integration", () => {
 describe.skipIf(process.env.MANDU_SKIP_BUNDLER_TESTS === "1")(
   "buildVendorShims emits fast-refresh shims in dev mode",
   () => {
-    let rootDir: string;
-
-    beforeAll(async () => {
-      rootDir = await mkdtemp(path.join(import.meta.dir, ".tmp-fr-vendor-"));
+    let rootDir: string;
+
+    beforeAll(async () => {
+      rootDir = await mkRepoTempDir("fr-vendor-");
       await mkdir(path.join(rootDir, "app"), { recursive: true });
       await writeFile(
         path.join(rootDir, "package.json"),

package/src/bundler/__tests__/hdr.test.ts

@@ -204,9 +204,16 @@ describe("Phase 7.2 Agent B — findRouteIdForSlot", () => {
 // Section B — HMR server broadcast of slot-refetch
 // -----------------------------------------------------------------------------
 
-function pickPort(): number {
-  return 40000 + Math.floor(Math.random() * 10000);
-}
+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);
+}
 
 describe("Phase 7.2 Agent B — slot-refetch broadcast", () => {
   let server: HMRServer | null = null;

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

@@ -172,17 +172,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. For these tests that would
- * complicate setup; we pick a random port in the high range instead
- * and accept the tiny risk of collision (test is < 1 s).
- */
-function pickPort(): number {
-  // 40000–49999 range — avoids common dev ports while staying well
-  // below ephemeral ranges Bun may pick for outbound sockets.
-  return 40000 + Math.floor(Math.random() * 10000);
-}
+ * 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

package/src/bundler/build.test.ts

@@ -1,11 +1,17 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtemp, mkdir, readFile, rm, writeFile } from "fs/promises";
-import path from "path";
-import { pathToFileURL } from "url";
-
-// 모든 테스트가 하나의 빌드 결과를 공유 — 병렬 Bun.build 충돌 방지
-let rootDir: string;
-let result: { success: boolean; errors: string[] };
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+
+// 모든 테스트가 하나의 빌드 결과를 공유 — 병렬 Bun.build 충돌 방지
+let rootDir: string;
+let result: { success: boolean; errors: string[] };
+const repoTempRoot = path.resolve(import.meta.dir, "../../../..", ".tmp-test-artifacts");
+
+async function mkRepoTempDir(prefix: string): Promise<string> {
+  await mkdir(repoTempRoot, { recursive: true });
+  return mkdtemp(path.join(repoTempRoot, prefix));
+}
 
 async function importBuiltModule(relativePath: string): Promise<Record<string, unknown>> {
   const fileUrl = pathToFileURL(path.join(rootDir, relativePath)).href;
@@ -24,10 +30,13 @@ async function importBuiltModule(relativePath: string): Promise<Record<string, u
  * See `__tests__/build-runner.ts` for the subprocess entrypoint and more
  * background.
  */
-async function runBuildInSubprocess(root: string, mode?: string): Promise<{
-  success: boolean;
-  errors: string[];
-}> {
+async function runBuildInSubprocess(root: string, mode?: string): Promise<{
+  success: boolean;
+  errors: string[];
+  manifest?: {
+    bundles?: Record<string, { js?: string }>;
+  } | null;
+}> {
   const runner = path.join(
     import.meta.dir,
     "__tests__",
@@ -52,25 +61,27 @@ async function runBuildInSubprocess(root: string, mode?: string): Promise<{
     const last = lines[lines.length - 1] ?? "";
     try {
       const parsed = JSON.parse(last);
-      return {
-        success: parsed.success === true,
-        errors: Array.isArray(parsed.errors) ? parsed.errors : [],
-      };
+      return {
+        success: parsed.success === true,
+        errors: Array.isArray(parsed.errors) ? parsed.errors : [],
+        manifest: parsed.manifest ?? null,
+      };
     } catch (e) {
-      return {
-        success: false,
-        errors: [
-          `build-runner output could not be parsed as JSON: ${String(e)}\nLast stdout line: ${last}`,
-        ],
-      };
-    }
-  } catch (err) {
-    return { success: false, errors: [`spawn failed: ${String(err)}`] };
-  }
-}
+      return {
+        success: false,
+        errors: [
+          `build-runner output could not be parsed as JSON: ${String(e)}\nLast stdout line: ${last}`,
+        ],
+        manifest: null,
+      };
+    }
+  } catch (err) {
+    return { success: false, errors: [`spawn failed: ${String(err)}`], manifest: null };
+  }
+}
 
-beforeAll(async () => {
-  rootDir = await mkdtemp(path.join(import.meta.dir, ".tmp-bundler-"));
+beforeAll(async () => {
+  rootDir = await mkRepoTempDir("bundler-");
 
   await mkdir(path.join(rootDir, "app"), { recursive: true });
   await writeFile(
@@ -117,14 +128,26 @@ afterAll(async () => {
 // subprocess via `__tests__/build-runner.ts`. In-process retry does not
 // recover from that one; a fresh module graph does.
 describe("buildClientBundles vendor shims", () => {
-  test("build succeeds", () => {
-    if (!result.success) {
-      console.error("[build.test] errors:", result.errors);
-    }
-    expect(result.success).toBe(true);
-  });
-
-  test("re-exports modern React 19 APIs used by islands", async () => {
+  test("build succeeds", () => {
+    if (!result.success) {
+      console.error("[build.test] errors:", result.errors);
+    }
+    expect(result.success).toBe(true);
+  });
+
+  test("runtime reads canonical data-hydrate strategies", async () => {
+    const runtimePath = path.join(rootDir, ".mandu", "client", "_runtime.js");
+    const runtimeSource = await readFile(runtimePath, "utf-8");
+
+    expect(runtimeSource).toContain("data-hydrate");
+    expect(runtimeSource).toContain("matchMedia");
+    expect(runtimeSource).toContain("200px");
+    expect(runtimeSource).toContain('"click"');
+    expect(runtimeSource).not.toContain("mouseenter");
+    expect(runtimeSource).not.toContain("pointerdown");
+  });
+
+  test("re-exports modern React 19 APIs used by islands", async () => {
     const reactShim = await importBuiltModule(".mandu/client/_react.js");
     const requiredExports = [
       "Activity",
@@ -176,18 +199,21 @@ describe("buildClientBundles vendor shims", () => {
     expect(runtimeSource).toContain("data-mandu-hydrating");
     expect(runtimeSource).toContain("data-mandu-render-mode");
     expect(runtimeSource).toContain("data-mandu-recoverable-error");
-    expect(runtimeSource).toContain("pointerdown");
+    expect(runtimeSource).toContain('"click"');
+    expect(runtimeSource).not.toContain("pointerdown");
   });
 
-  test("runtime parses SSR data script before island setup", async () => {
-    const runtimeSource = await readFile(path.join(rootDir, ".mandu", "client", "_runtime.js"), "utf-8");
-    expect(runtimeSource).toContain("function readManduData");
-    expect(runtimeSource).toContain("document.getElementById(\"__MANDU_DATA__\")");
-    expect(runtimeSource).toContain("JSON.parse");
-  });
+  test("runtime parses SSR data script before island setup", async () => {
+    const runtimeSource = await readFile(path.join(rootDir, ".mandu", "client", "_runtime.js"), "utf-8");
+    expect(runtimeSource).toContain("function readManduData");
+    expect(runtimeSource).toContain("document.getElementById(\"__MANDU_DATA__\")");
+    expect(runtimeSource).toContain("deserializeManduProps");
+    expect(runtimeSource).toContain("new Date");
+    expect(runtimeSource).toContain("new Map");
+  });
 
-  test("does not bundle a server page when stale manifest marks page.tsx as clientModule", async () => {
-    const staleRoot = await mkdtemp(path.join(import.meta.dir, ".tmp-stale-client-module-"));
+  test("does not bundle a server page when stale manifest marks page.tsx as clientModule", async () => {
+    const staleRoot = await mkRepoTempDir("stale-client-module-");
     try {
       await mkdir(path.join(staleRoot, "app"), { recursive: true });
       await mkdir(path.join(staleRoot, "src", "shared", "contracts"), { recursive: true });
@@ -220,7 +246,7 @@ describe("buildClientBundles vendor shims", () => {
   });
 
   test("rewrites route-component clientModule to the real client import before bundling", async () => {
-    const routeClientRoot = await mkdtemp(path.join(import.meta.dir, ".tmp-route-client-import-"));
+    const routeClientRoot = await mkRepoTempDir("route-client-import-");
     try {
       await mkdir(path.join(routeClientRoot, "app", "login"), { recursive: true });
       await mkdir(path.join(routeClientRoot, "src", "client", "pages", "login"), { recursive: true });
@@ -267,7 +293,7 @@ describe("buildClientBundles vendor shims", () => {
   });
 
   test("bundles route-level named client exports without requiring a default export", async () => {
-    const routeClientRoot = await mkdtemp(path.join(import.meta.dir, ".tmp-route-named-client-import-"));
+    const routeClientRoot = await mkRepoTempDir("route-named-client-import-");
     try {
       await mkdir(path.join(routeClientRoot, "app", "login"), { recursive: true });
       await mkdir(path.join(routeClientRoot, "src", "client", "pages", "login"), { recursive: true });
@@ -317,8 +343,34 @@ describe("buildClientBundles vendor shims", () => {
     }
   });
 
+  test("uses Windows-safe asset filenames for locale-prefixed route ids", async () => {
+    const localeRoot = await mkRepoTempDir("i18n-locale-route-id-");
+    try {
+      await mkdir(path.join(localeRoot, "app"), { recursive: true });
+      await writeFile(
+        path.join(localeRoot, "package.json"),
+        JSON.stringify({ name: "mandu-i18n-route-id-test", type: "module" }, null, 2),
+        "utf-8",
+      );
+      await writeFile(
+        path.join(localeRoot, "app", "demo.client.tsx"),
+        "export default function DemoIsland() { return null; }\n",
+        "utf-8",
+      );
+
+      const localeResult = await runBuildInSubprocess(localeRoot, "i18n-locale-route-id");
+      expect(localeResult.success).toBe(true);
+      const bundle = localeResult.manifest?.bundles?.["ko::demo"];
+      expect(bundle?.js).toBe("/.mandu/client/ko_3a__3a_demo.island.js");
+      expect(bundle?.js).not.toContain(":");
+      expect(await Bun.file(path.join(localeRoot, ".mandu", "client", "ko_3a__3a_demo.island.js")).exists()).toBe(true);
+    } finally {
+      await rm(localeRoot, { recursive: true, force: true });
+    }
+  });
+
   test("fails when hydration is enabled but no clientModule can be resolved", async () => {
-    const missingRoot = await mkdtemp(path.join(import.meta.dir, ".tmp-hydration-no-client-"));
+    const missingRoot = await mkRepoTempDir("hydration-no-client-");
     try {
       await mkdir(path.join(missingRoot, "app", "login"), { recursive: true });
       await mkdir(path.join(missingRoot, "src", "client", "widgets", "login-form"), { recursive: true });