@mandujs/core 0.54.2 → 0.54.4

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

@@ -54,16 +54,36 @@
 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 manifest: RoutesManifest = {
-  version: 1,
-  routes: [
-    {
+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,
+          },
+        },
+      ],
+    }
+  : {
+  version: 1,
+  routes: [
+    {
       id: "demo",
       kind: "page",
       pattern: "/",
@@ -75,9 +95,9 @@ const manifest: RoutesManifest = {
         priority: "visible",
         preload: false,
       },
-    },
-  ],
-};
+    },
+  ],
+};
 
 try {
   const result = await buildClientBundles(manifest, rootDir, {

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

@@ -29,10 +29,11 @@ import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import path from "path";
 import type { RouteSpec } from "../../spec/schema";
-import {
-  _testOnly_scanIslandFiles,
-  _testOnly_getHydratedRoutes,
-} from "../build";
+import {
+  _testOnly_scanIslandFiles,
+  _testOnly_scanPartialFiles,
+  _testOnly_getHydratedRoutes,
+} from "../build";
 import { HMR_PERF } from "../../perf/hmr-markers";
 import {
   _resetCacheForTesting as _resetPerfCache,
@@ -372,7 +373,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(() => {
@@ -500,5 +501,32 @@ 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("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

@@ -0,0 +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"]);
+  });
+});

package/src/bundler/analyzer.ts

@@ -341,18 +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: [],
-    });
-  }
+      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,17 +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): 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 proc = Bun.spawn([process.execPath, "run", runner, root], {
+    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",
@@ -171,9 +173,49 @@ 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");
-  });
-});
+    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 });
+    }
+  });
+});