@mandujs/core 0.54.10 → 0.54.11

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

@@ -54,68 +54,87 @@
 import { buildClientBundles } from "../build";
 import type { RoutesManifest } from "../../spec/schema";
 
-const rootDir = process.argv[2];
-if (!rootDir) {
-  console.error("usage: build-runner.ts <rootDir>");
-  process.exit(2);
-}
-const mode = process.argv[3] ?? "default";
-
-const manifest: RoutesManifest = mode === "server-page-client-module"
-  ? {
-      version: 1,
-      routes: [
-        {
-          id: "index",
-          kind: "page",
-          pattern: "/",
-          module: "app/page.tsx",
-          componentModule: "app/page.tsx",
-          clientModule: "app/page.tsx",
-          hydration: {
-            strategy: "island",
-            priority: "visible",
-            preload: false,
-          },
-        },
-      ],
-    }
-  : mode === "hydration-no-client-module"
-    ? {
-        version: 1,
-        routes: [
-          {
-            id: "login",
-            kind: "page",
-            pattern: "/login",
-            module: "app/login/page.tsx",
-            componentModule: "app/login/page.tsx",
-            hydration: {
-              strategy: "full",
-              priority: "immediate",
-              preload: false,
-            },
-          },
-        ],
-      }
-    : {
-        version: 1,
-        routes: [
-          {
-            id: "demo",
-            kind: "page",
-            pattern: "/",
-            module: "app/page.tsx",
-            componentModule: "app/page.tsx",
-            clientModule: "app/demo.client.tsx",
-            hydration: {
-              strategy: "island",
-              priority: "visible",
-              preload: false,
-            },
-          },
-        ],
-      };
+const rootDir = process.argv[2];
+if (!rootDir) {
+  console.error("usage: build-runner.ts <rootDir>");
+  process.exit(2);
+}
+const mode = process.argv[3] ?? "default";
+
+const manifest: RoutesManifest = mode === "server-page-client-module"
+  ? {
+      version: 1,
+      routes: [
+        {
+          id: "index",
+          kind: "page",
+          pattern: "/",
+          module: "app/page.tsx",
+          componentModule: "app/page.tsx",
+          clientModule: "app/page.tsx",
+          hydration: {
+            strategy: "island",
+            priority: "visible",
+            preload: false,
+          },
+        },
+      ],
+    }
+  : mode === "server-page-route-client-import"
+    ? {
+        version: 1,
+        routes: [
+          {
+            id: "login",
+            kind: "page",
+            pattern: "/login",
+            module: "app/login/page.tsx",
+            componentModule: "app/login/page.tsx",
+            clientModule: "app/login/page.tsx",
+            hydration: {
+              strategy: "island",
+              priority: "visible",
+              preload: false,
+            },
+          },
+        ],
+      }
+  : mode === "hydration-no-client-module"
+    ? {
+        version: 1,
+        routes: [
+          {
+            id: "login",
+            kind: "page",
+            pattern: "/login",
+            module: "app/login/page.tsx",
+            componentModule: "app/login/page.tsx",
+            hydration: {
+              strategy: "full",
+              priority: "immediate",
+              preload: false,
+            },
+          },
+        ],
+      }
+    : {
+        version: 1,
+        routes: [
+          {
+            id: "demo",
+            kind: "page",
+            pattern: "/",
+            module: "app/page.tsx",
+            componentModule: "app/page.tsx",
+            clientModule: "app/demo.client.tsx",
+            hydration: {
+              strategy: "island",
+              priority: "visible",
+              preload: false,
+            },
+          },
+        ],
+      };
 
 try {
   const result = await buildClientBundles(manifest, rootDir, {

package/src/bundler/__tests__/cold-start.test.ts

@@ -28,13 +28,13 @@ import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import path from "path";
-import type { RouteSpec, RoutesManifest } from "../../spec/schema";
-import {
-  _testOnly_scanIslandFiles,
-  _testOnly_scanPartialFiles,
-  _testOnly_getHydratedRoutes,
-  _testOnly_getHydrationRoutesMissingClientModule,
-} from "../build";
+import type { RouteSpec, RoutesManifest } from "../../spec/schema";
+import {
+  _testOnly_scanIslandFiles,
+  _testOnly_scanPartialFiles,
+  _testOnly_getHydratedRoutes,
+  _testOnly_getHydrationRoutesMissingClientModule,
+} from "../build";
 import { HMR_PERF } from "../../perf/hmr-markers";
 import {
   _resetCacheForTesting as _resetPerfCache,
@@ -374,7 +374,7 @@ describe("Phase 7.1 R1 Agent C — getHydratedRoutes filter", () => {
   });
 });
 
-describe("Phase 7.1 R1 Agent C — per-island scan skips non-hydrated routes", () => {
+describe("Phase 7.1 R1 Agent C — per-island scan skips non-hydrated routes", () => {
   let project: ReturnType<typeof createProject>;
 
   beforeEach(() => {
@@ -502,55 +502,55 @@ describe("Phase 7.1 R1 Agent C — per-island scan skips non-hydrated routes", (
     ];
     const result = await _testOnly_scanIslandFiles(routes, project.rootDir);
     expect(result).toEqual([]);
-  });
-});
-
-describe("hydration route validation", () => {
-  it("finds pages that request hydration without a client module", () => {
-    const manifest = {
-      version: 1,
-      routes: [
-        {
-          id: "login",
-          pattern: "/login",
-          kind: "page",
-          module: "app/login/page.tsx",
-          componentModule: "app/login/page.tsx",
-          hydration: { strategy: "full", priority: "immediate", preload: false },
-        },
-        pureSsrRoute("about", "/about", "app/about"),
-        pageRoute("dashboard", "/dashboard", "app/dashboard"),
-      ],
-    } as RoutesManifest;
-
-    const missing = _testOnly_getHydrationRoutesMissingClientModule(manifest);
-    expect(missing.map((route) => route.id)).toEqual(["login"]);
-  });
-});
-
-describe("partial bundle scan", () => {
-  let project: ReturnType<typeof createProject>;
-
-  beforeEach(() => {
-    project = createProject();
-  });
-
-  afterEach(() => {
-    try {
-      rmSync(project.rootDir, { recursive: true, force: true });
-    } catch {
-      /* Windows lock tolerance */
-    }
-  });
-
-  it("discovers *.partial.tsx files outside .mandu and node_modules", async () => {
-    project.writeIslandFile("app", "Home.partial.tsx");
-    project.writeIslandFile(".mandu/client", "Stale.partial.tsx");
-    project.writeIslandFile("node_modules/pkg", "Ignored.partial.tsx");
-
-    const result = await _testOnly_scanPartialFiles(project.rootDir);
-
-    expect(result.map((entry) => entry.name)).toEqual(["Home"]);
-    expect(result[0].priority).toBe("visible");
-  });
-});
+  });
+});
+
+describe("hydration route validation", () => {
+  it("finds pages that request hydration without a client module", () => {
+    const manifest = {
+      version: 1,
+      routes: [
+        {
+          id: "login",
+          pattern: "/login",
+          kind: "page",
+          module: "app/login/page.tsx",
+          componentModule: "app/login/page.tsx",
+          hydration: { strategy: "full", priority: "immediate", preload: false },
+        },
+        pureSsrRoute("about", "/about", "app/about"),
+        pageRoute("dashboard", "/dashboard", "app/dashboard"),
+      ],
+    } as RoutesManifest;
+
+    const missing = _testOnly_getHydrationRoutesMissingClientModule(manifest);
+    expect(missing.map((route) => route.id)).toEqual(["login"]);
+  });
+});
+
+describe("partial bundle scan", () => {
+  let project: ReturnType<typeof createProject>;
+
+  beforeEach(() => {
+    project = createProject();
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(project.rootDir, { recursive: true, force: true });
+    } catch {
+      /* Windows lock tolerance */
+    }
+  });
+
+  it("discovers *.partial.tsx files outside .mandu and node_modules", async () => {
+    project.writeIslandFile("app", "Home.partial.tsx");
+    project.writeIslandFile(".mandu/client", "Stale.partial.tsx");
+    project.writeIslandFile("node_modules/pkg", "Ignored.partial.tsx");
+
+    const result = await _testOnly_scanPartialFiles(project.rootDir);
+
+    expect(result.map((entry) => entry.name)).toEqual(["Home"]);
+    expect(result[0].priority).toBe("visible");
+  });
+});

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

@@ -1,20 +1,20 @@
-import { describe, expect, test } from "bun:test";
-import { __private } from "../css";
-
-describe("CSS Tailwind command resolution", () => {
-  test("uses process.execPath when it is Bun", () => {
-    expect(
-      __private.getTailwindCommand(["@tailwindcss/cli"], "C:\\tools\\bun.exe"),
-    ).toEqual(["C:\\tools\\bun.exe", "x", "@tailwindcss/cli"]);
-  });
-
-  test("does not treat standalone mandu.exe as Bun", () => {
-    expect(
-      __private.getTailwindCommand(
-        ["@tailwindcss/cli"],
-        "C:\\Users\\User\\AppData\\Local\\Mandu\\bin\\mandu.exe",
-        () => "C:\\Users\\User\\.bun\\bin\\bun.exe",
-      ),
-    ).toEqual(["C:\\Users\\User\\.bun\\bin\\bun.exe", "x", "@tailwindcss/cli"]);
-  });
-});
+import { describe, expect, test } from "bun:test";
+import { __private } from "../css";
+
+describe("CSS Tailwind command resolution", () => {
+  test("uses process.execPath when it is Bun", () => {
+    expect(
+      __private.getTailwindCommand(["@tailwindcss/cli"], "C:\\tools\\bun.exe"),
+    ).toEqual(["C:\\tools\\bun.exe", "x", "@tailwindcss/cli"]);
+  });
+
+  test("does not treat standalone mandu.exe as Bun", () => {
+    expect(
+      __private.getTailwindCommand(
+        ["@tailwindcss/cli"],
+        "C:\\Users\\User\\AppData\\Local\\Mandu\\bin\\mandu.exe",
+        () => "C:\\Users\\User\\.bun\\bin\\bun.exe",
+      ),
+    ).toEqual(["C:\\Users\\User\\.bun\\bin\\bun.exe", "x", "@tailwindcss/cli"]);
+  });
+});

package/src/bundler/analyzer.ts

@@ -341,26 +341,26 @@ export async function analyzeBundle(
       deps: entry.dependencies ?? [],
     });
   }
-  for (const [islandName, entry] of Object.entries(manifest.islands ?? {})) {
-    // Avoid double-counting: if a per-island chunk shares its route id with
-    // a route-level bundle, we prefer the island entry (finer granularity).
-    const existing = islandSources.findIndex((s) => s.name === islandName);
+  for (const [islandName, entry] of Object.entries(manifest.islands ?? {})) {
+    // Avoid double-counting: if a per-island chunk shares its route id with
+    // a route-level bundle, we prefer the island entry (finer granularity).
+    const existing = islandSources.findIndex((s) => s.name === islandName);
     if (existing !== -1) islandSources.splice(existing, 1);
     islandSources.push({
       name: islandName,
       url: entry.js,
       priority: entry.priority,
-      deps: [],
-    });
-  }
-  for (const [partialName, entry] of Object.entries(manifest.partials ?? {})) {
-    islandSources.push({
-      name: `partial:${partialName}`,
-      url: entry.js,
-      priority: entry.priority,
-      deps: [],
-    });
-  }
+      deps: [],
+    });
+  }
+  for (const [partialName, entry] of Object.entries(manifest.partials ?? {})) {
+    islandSources.push({
+      name: `partial:${partialName}`,
+      url: entry.js,
+      priority: entry.priority,
+      deps: [],
+    });
+  }
 
   const islands: AnalyzeIsland[] = [];
   for (const src of islandSources) {

package/src/bundler/build.test.ts

@@ -24,19 +24,19 @@ 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[];
+}> {
   const runner = path.join(
     import.meta.dir,
     "__tests__",
     "build-runner.ts",
   );
   try {
-    const args = [process.execPath, "run", runner, root];
-    if (mode) args.push(mode);
-    const proc = Bun.spawn(args, {
+    const args = [process.execPath, "run", runner, root];
+    if (mode) args.push(mode);
+    const proc = Bun.spawn(args, {
       cwd: path.resolve(import.meta.dir, "..", ".."),
       stdin: "ignore",
       stdout: "pipe",
@@ -173,84 +173,116 @@ describe("buildClientBundles vendor shims", () => {
     expect(runtimeSource).toContain("function hasHydratableMarkup");
     expect(runtimeSource).toContain("function shouldHydrateCompiledIsland");
     expect(runtimeSource).toContain("onRecoverableError");
-    expect(runtimeSource).toContain("data-mandu-hydrating");
-    expect(runtimeSource).toContain("data-mandu-render-mode");
-    expect(runtimeSource).toContain("data-mandu-recoverable-error");
-    expect(runtimeSource).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("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-"));
-    try {
-      await mkdir(path.join(staleRoot, "app"), { recursive: true });
-      await mkdir(path.join(staleRoot, "src", "shared", "contracts"), { recursive: true });
-      await writeFile(
-        path.join(staleRoot, "package.json"),
-        JSON.stringify({ name: "mandu-stale-client-module-test", type: "module" }, null, 2),
-        "utf-8",
-      );
-      await writeFile(
-        path.join(staleRoot, "src", "shared", "contracts", "api.ts"),
-        'export const INTERNAL_BASE = process.env.MANDU_INTERNAL_URL ?? "http://localhost:3333";\n',
-        "utf-8",
-      );
-      await writeFile(
-        path.join(staleRoot, "app", "page.tsx"),
-        'import { INTERNAL_BASE } from "../src/shared/contracts/api";\n' +
-          "export default async function HomePage() {\n" +
-          "  return <main>{INTERNAL_BASE}</main>;\n" +
-          "}\n",
-        "utf-8",
-      );
-
-      const staleResult = await runBuildInSubprocess(staleRoot, "server-page-client-module");
-      expect(staleResult.success).toBe(false);
-      expect(staleResult.errors.join("\n")).toContain("missing \"use client\"");
-      expect(await Bun.file(path.join(staleRoot, ".mandu", "client", "index.island.js")).exists()).toBe(false);
-    } finally {
-      await rm(staleRoot, { 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-"));
-    try {
-      await mkdir(path.join(missingRoot, "app", "login"), { recursive: true });
-      await mkdir(path.join(missingRoot, "src", "client", "widgets", "login-form"), { recursive: true });
-      await writeFile(
-        path.join(missingRoot, "package.json"),
-        JSON.stringify({ name: "mandu-hydration-no-client-test", type: "module" }, null, 2),
-        "utf-8",
-      );
-      await writeFile(
-        path.join(missingRoot, "app", "login", "page.tsx"),
-        'import { LoginForm } from "../../src/client/widgets/login-form/LoginForm.client";\n' +
-          "export default function LoginPage() {\n" +
-          "  return <main><LoginForm /></main>;\n" +
-          "}\n",
-        "utf-8",
-      );
-      await writeFile(
-        path.join(missingRoot, "src", "client", "widgets", "login-form", "LoginForm.client.tsx"),
-        "export function LoginForm() { return <form />; }\n",
-        "utf-8",
-      );
-
-      const noClientResult = await runBuildInSubprocess(missingRoot, "hydration-no-client-module");
-      const errors = noClientResult.errors.join("\n");
-      expect(noClientResult.success).toBe(false);
-      expect(errors).toContain("no clientModule could be resolved");
-      expect(errors).toContain("LoginForm.client");
-      expect(errors).toContain("run mandu generate");
-    } finally {
-      await rm(missingRoot, { recursive: true, force: true });
-    }
-  });
-});
+    expect(runtimeSource).toContain("data-mandu-hydrating");
+    expect(runtimeSource).toContain("data-mandu-render-mode");
+    expect(runtimeSource).toContain("data-mandu-recoverable-error");
+    expect(runtimeSource).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("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-"));
+    try {
+      await mkdir(path.join(staleRoot, "app"), { recursive: true });
+      await mkdir(path.join(staleRoot, "src", "shared", "contracts"), { recursive: true });
+      await writeFile(
+        path.join(staleRoot, "package.json"),
+        JSON.stringify({ name: "mandu-stale-client-module-test", type: "module" }, null, 2),
+        "utf-8",
+      );
+      await writeFile(
+        path.join(staleRoot, "src", "shared", "contracts", "api.ts"),
+        'export const INTERNAL_BASE = process.env.MANDU_INTERNAL_URL ?? "http://localhost:3333";\n',
+        "utf-8",
+      );
+      await writeFile(
+        path.join(staleRoot, "app", "page.tsx"),
+        'import { INTERNAL_BASE } from "../src/shared/contracts/api";\n' +
+          "export default async function HomePage() {\n" +
+          "  return <main>{INTERNAL_BASE}</main>;\n" +
+          "}\n",
+        "utf-8",
+      );
+
+      const staleResult = await runBuildInSubprocess(staleRoot, "server-page-client-module");
+      expect(staleResult.success).toBe(false);
+      expect(staleResult.errors.join("\n")).toContain("missing \"use client\"");
+      expect(await Bun.file(path.join(staleRoot, ".mandu", "client", "index.island.js")).exists()).toBe(false);
+    } finally {
+      await rm(staleRoot, { recursive: true, force: true });
+    }
+  });
+
+  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-"));
+    try {
+      await mkdir(path.join(routeClientRoot, "app", "login"), { recursive: true });
+      await mkdir(path.join(routeClientRoot, "src", "client", "pages", "login"), { recursive: true });
+      await writeFile(
+        path.join(routeClientRoot, "package.json"),
+        JSON.stringify({ name: "mandu-route-client-import-test", type: "module" }, null, 2),
+        "utf-8",
+      );
+      await writeFile(
+        path.join(routeClientRoot, "app", "login", "page.tsx"),
+        'import LoginPage from "@/client/pages/login/LoginPage.client";\n' +
+          "export default function Page() {\n" +
+          "  return <LoginPage />;\n" +
+          "}\n",
+        "utf-8",
+      );
+      await writeFile(
+        path.join(routeClientRoot, "src", "client", "pages", "login", "LoginPage.client.tsx"),
+        '"use client";\nexport default function LoginPage() { return <form />; }\n',
+        "utf-8",
+      );
+
+      const routeClientResult = await runBuildInSubprocess(routeClientRoot, "server-page-route-client-import");
+      expect(routeClientResult.success).toBe(true);
+      expect(await Bun.file(path.join(routeClientRoot, ".mandu", "client", "login.island.js")).exists()).toBe(true);
+    } finally {
+      await rm(routeClientRoot, { 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-"));
+    try {
+      await mkdir(path.join(missingRoot, "app", "login"), { recursive: true });
+      await mkdir(path.join(missingRoot, "src", "client", "widgets", "login-form"), { recursive: true });
+      await writeFile(
+        path.join(missingRoot, "package.json"),
+        JSON.stringify({ name: "mandu-hydration-no-client-test", type: "module" }, null, 2),
+        "utf-8",
+      );
+      await writeFile(
+        path.join(missingRoot, "app", "login", "page.tsx"),
+        'import { LoginForm } from "../../src/client/widgets/login-form/LoginForm.client";\n' +
+          "export default function LoginPage() {\n" +
+          "  return <main><LoginForm /></main>;\n" +
+          "}\n",
+        "utf-8",
+      );
+      await writeFile(
+        path.join(missingRoot, "src", "client", "widgets", "login-form", "LoginForm.client.tsx"),
+        "export function LoginForm() { return <form />; }\n",
+        "utf-8",
+      );
+
+      const noClientResult = await runBuildInSubprocess(missingRoot, "hydration-no-client-module");
+      const errors = noClientResult.errors.join("\n");
+      expect(noClientResult.success).toBe(false);
+      expect(errors).toContain("no clientModule could be resolved");
+      expect(errors).toContain("LoginForm.client");
+      expect(errors).toContain("run mandu generate");
+    } finally {
+      await rm(missingRoot, { recursive: true, force: true });
+    }
+  });
+});