@mandujs/core 0.54.32 → 0.55.0-beta.1

package/src/bundler/build.test.ts

@@ -1,915 +1,898 @@
-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";
-import { serializeProps } from "../client/serialize";
-import { toMatchSnapshot } from "../testing/snapshot";
-import { setupHappyDom } from "../../tests/setup";
-
-setupHappyDom();
-
-// 모든 테스트가 하나의 빌드 결과를 공유 — 병렬 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;
-  return import(`${fileUrl}?t=${Date.now()}`);
-}
-
-async function evaluateGeneratedHydrationRuntime(): Promise<{ hydrateIslands: () => void }> {
-  const sourcePath = path.join(rootDir, ".mandu", "client", "_runtime.src.js");
-  const bundledPath = path.join(rootDir, ".mandu", "client", "_runtime.js");
-  const runtimeSource = await readFile(await Bun.file(sourcePath).exists() ? sourcePath : bundledPath, "utf-8");
-  const instrumented = runtimeSource
-    .replace(
-      /import\s+React,\s*\{[^}]*\}\s+from\s+['"]react['"];?/,
-      "const React = globalThis.__MANDU_TEST_REACT__; const { useState, useEffect, Component } = React;",
-    )
-    .replace(
-      /import\s+\{[^}]*\}\s+from\s+['"]react-dom\/client['"];?/,
-      "const { hydrateRoot, createRoot } = globalThis.__MANDU_TEST_REACT_DOM_CLIENT__;",
-    )
-    .replace(
-      /export\s*\{[^}]*\};?/g,
-      "globalThis.__MANDU_TEST_RUNTIME__ = { hydrateIslands, unmountIsland, hydratedRoots };",
-    );
-
-  const reactStub = {
-    Component: class {
-      render() {
-        return null;
-      }
-    },
-    createElement(type: unknown, props: Record<string, unknown> | null, ...children: unknown[]) {
-      if (
-        typeof type === "function" &&
-        !(typeof type === "function" && "prototype" in type && (type as { prototype?: { render?: unknown } }).prototype?.render)
-      ) {
-        return (type as (props: Record<string, unknown>) => unknown)({
-          ...(props ?? {}),
-          children: children.length <= 1 ? children[0] : children,
-        });
-      }
-      return { type, props: props ?? {}, children };
-    },
-    isValidElement(value: unknown) {
-      return !!value && typeof value === "object" && "type" in value;
-    },
-    useEffect(effect: () => void) {
-      effect();
-    },
-    useState<T>(initial: T) {
-      return [initial, () => {}] as const;
-    },
-  };
-  const rootStub = {
-    render() {},
-    unmount() {},
-  };
-  Object.assign(globalThis, {
-    __MANDU_TEST_REACT__: reactStub,
-    __MANDU_TEST_REACT_DOM_CLIENT__: {
-      createRoot: () => rootStub,
-      hydrateRoot: () => rootStub,
-    },
-  });
-
-  new Function(instrumented)();
-  return (globalThis as typeof globalThis & {
-    __MANDU_TEST_RUNTIME__: { hydrateIslands: () => void };
-  }).__MANDU_TEST_RUNTIME__;
-}
-
-async function waitForRuntimeAssertion(assertion: () => boolean): Promise<void> {
-  for (let attempt = 0; attempt < 25; attempt++) {
-    if (assertion()) return;
-    await new Promise((resolve) => setTimeout(resolve, 0));
-  }
-  expect(assertion()).toBe(true);
-}
-
-/**
- * Run `buildClientBundles` in an isolated `bun` subprocess.
- *
- * Bun 1.3.x exhibits a deterministic `AggregateError: Bundle failed` when
- * `buildClientBundles` is called from a test file AND the same `bun test`
- * process has previously imported `react` / `react-dom` through any sibling
- * test file (happens transitively through almost every `src/testing/*` or
- * `src/runtime/*` consumer). Retrying in-process does not recover — the
- * resolver state is sticky. A fresh subprocess has a clean module graph.
- * See `__tests__/build-runner.ts` for the subprocess entrypoint and more
- * background.
- */
-async function runBuildInSubprocess(root: string, mode?: string): Promise<{
-  success: boolean;
-  errors: string[];
-  manifest?: {
-    routes?: Array<{
-      id?: string;
-      module?: string;
-      componentModule?: string;
-      boundaries?: Array<{
-        id?: string;
-        routeId?: string;
-        module?: string;
-        importSpecifier?: string;
-        exportName?: string;
-        localName?: string;
-        hydrate?: string;
-        ordinal?: number;
-        propsSource?: string;
-        propsKeys?: string[];
-        hasSpreadProps?: boolean;
-        source?: {
-          file?: string;
-          line?: number;
-          column?: number;
-        };
-      }>;
-    }>;
-    bundles?: Record<string, { js?: string }>;
-    boundaries?: Record<string, { js?: string; route?: string; module?: string; exportName?: string; hydrate?: string }>;
-  } | null;
-}> {
-  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, {
-      cwd: path.resolve(import.meta.dir, "..", ".."),
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "inherit",
-    });
-    const out = await new Response(proc.stdout).text();
-    await proc.exited;
-
-    // Find the final JSON line — the runner may log Mandu dev banners
-    // (e.g. "[Mandu] DevTools …") before emitting the payload. The
-    // contract is: last non-empty line is the JSON blob.
-    const lines = out.split(/\r?\n/).filter((l) => l.trim().length > 0);
-    const last = lines[lines.length - 1] ?? "";
-    try {
-      const parsed = JSON.parse(last);
-      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}`,
-        ],
-        manifest: null,
-      };
-    }
-  } catch (err) {
-    return { success: false, errors: [`spawn failed: ${String(err)}`], manifest: null };
-  }
-}
-
-beforeAll(async () => {
-  rootDir = await mkRepoTempDir("bundler-");
-
-  await mkdir(path.join(rootDir, "app"), { recursive: true });
-  await writeFile(
-    path.join(rootDir, "package.json"),
-    JSON.stringify({ name: "mandu-build-test", type: "module" }, null, 2),
-    "utf-8",
-  );
-  await writeFile(
-    path.join(rootDir, "app", "demo.client.tsx"),
-    "export default function DemoIsland() { return null; }\n",
-    "utf-8",
-  );
-
-  result = await runBuildInSubprocess(rootDir);
-});
-
-afterAll(async () => {
-  if (rootDir) {
-    await rm(rootDir, { recursive: true, force: true });
-  }
-});
-
-// Historical note — `MANDU_SKIP_BUNDLER_TESTS` gate REMOVED.
-//
-// A previous revision gated this describe block behind
-// `describe.skipIf(MANDU_SKIP_BUNDLER_TESTS === "1")` because running
-// `bun test src/bundler/` without the gate hung indefinitely on Windows
-// (see Phase 0.6 and `docs/qa/wave-R2-integration-report.md`). Root cause
-// was NOT actually in THIS file — it was a deadlock in `safe-build.test.ts`'s
-// "slot handoff" regression test, which drove Bun's microtask queue with a
-// `while (!stop) { await Promise.resolve() }` sampler. That starved libuv
-// I/O callbacks, so the 7 parallel `safeBuild()` calls never completed, the
-// whole test process hung, and downstream test files (including this one
-// when run in the same invocation) looked flaky when they were simply
-// never reached. The handoff sampler now yields via `setImmediate`, which
-// unblocks Bun.build completion and makes `bun test src/bundler/` finish
-// deterministically in ~35s on Windows. Confirmed green 3/3 runs without
-// the gate on 2026-04-20. If you are tempted to re-introduce the skip here,
-// first check whether a sibling test is starving the event loop.
-//
-// A second, independent flake — Bun.build `AggregateError: Bundle failed`
-// when another test file in the same invocation has imported `react` —
-// is now sidestepped by running `buildClientBundles` in a spawned `bun`
-// 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("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",
-      "__COMPILER_RUNTIME",
-      "cache",
-      "cacheSignal",
-      "startTransition",
-      "use",
-      "useActionState",
-      "useEffectEvent",
-      "useOptimistic",
-      "unstable_useCacheRefresh",
-    ];
-
-    for (const exportName of requiredExports) {
-      expect(exportName in reactShim).toBe(true);
-    }
-  });
-
-  test("re-exports modern react-dom and react-dom/client APIs", async () => {
-    const reactDomShim = await importBuiltModule(".mandu/client/_react-dom.js");
-    for (const exportName of [
-      "preconnect",
-      "prefetchDNS",
-      "preinit",
-      "preinitModule",
-      "preload",
-      "preloadModule",
-      "requestFormReset",
-      "unstable_batchedUpdates",
-      "useFormState",
-      "useFormStatus",
-    ]) {
-      expect(exportName in reactDomShim).toBe(true);
-    }
-
-    const reactDomClientShim = await importBuiltModule(".mandu/client/_react-dom-client.js");
-    for (const exportName of ["createRoot", "hydrateRoot", "version"]) {
-      expect(exportName in reactDomClientShim).toBe(true);
-    }
-  });
-
-  test("embeds hydration guards for deferred trigger strategies", async () => {
-    const runtimeSource = await readFile(path.join(rootDir, ".mandu", "client", "_runtime.js"), "utf-8");
-    expect(runtimeSource).toContain("function resolveHydrationTarget");
-    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('"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("function parsePropsScript");
-    expect(runtimeSource).toContain("data-mandu-props");
-    expect(runtimeSource).toContain("Missing boundary-local props for transformed client boundary");
-    expect(runtimeSource).toContain("warnedBoundaryPropFallbacks");
-    expect(runtimeSource).toContain("deserializeProps");
-    expect(runtimeSource).toContain("new Date");
-    expect(runtimeSource).toContain("new Map");
-  });
-
-  test("runtime hydrates named client boundary from boundary-local props before route data", async () => {
-    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-named-boundary.js");
-    await writeFile(
-      modulePath,
-      `
-        export default function WrongDefault(props) {
-          globalThis.__MANDU_TEST_DEFAULT_PROPS__ = props;
-          return null;
-        }
-        export function NamedBoundary(props) {
-          globalThis.__MANDU_TEST_NAMED_PROPS__ = props;
-          return null;
-        }
-      `,
-      "utf-8",
-    );
-    Object.assign(globalThis, {
-      __MANDU_TEST_NAMED_PROPS__: undefined,
-      __MANDU_TEST_DEFAULT_PROPS__: undefined,
-    });
-    document.body.innerHTML = `
-      <div
-        data-mandu-island="named--0"
-        data-mandu-boundary-id="named--0"
-        data-mandu-route-id="named-route"
-        data-mandu-client-export="NamedBoundary"
-        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
-        data-hydrate="load"
-      ></div>
-      <script type="application/json" data-mandu-props="named--0">${serializeProps({ label: "boundary-local" })}</script>
-    `;
-    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {
-      "named-route": { serverData: { label: "route-data" } },
-    };
-    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
-
-    const runtime = await evaluateGeneratedHydrationRuntime();
-    runtime.hydrateIslands();
-
-    await waitForRuntimeAssertion(() =>
-      (globalThis as typeof globalThis & { __MANDU_TEST_NAMED_PROPS__?: { label?: string } }).__MANDU_TEST_NAMED_PROPS__?.label === "boundary-local"
-    );
-    expect((globalThis as typeof globalThis & { __MANDU_TEST_DEFAULT_PROPS__?: unknown }).__MANDU_TEST_DEFAULT_PROPS__).toBeUndefined();
-  });
-
-  test("surfaces an island hydration failure to the DevTools hook (#324)", async () => {
-    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-failing-boundary.js");
-    // A module that throws at import time → loadAndHydrate's catch runs.
-    await writeFile(modulePath, `throw new Error("boom at import");`, "utf-8");
-
-    const emitted: Array<{ type?: string; data?: { message?: string; islandId?: string } }> = [];
-    (window as unknown as { __MANDU_DEVTOOLS_HOOK__?: { emit: (e: unknown) => void } }).__MANDU_DEVTOOLS_HOOK__ = {
-      emit: (e: unknown) => {
-        emitted.push(e as { type?: string });
-      },
-    };
-
-    document.body.innerHTML = `
-      <div
-        data-mandu-island="failing--0"
-        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
-        data-hydrate="load"
-      ></div>
-    `;
-    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
-
-    try {
-      const runtime = await evaluateGeneratedHydrationRuntime();
-      runtime.hydrateIslands();
-
-      await waitForRuntimeAssertion(() => emitted.some((e) => e.type === "error"));
-      const errorEvent = emitted.find((e) => e.type === "error");
-      expect(errorEvent?.data?.islandId).toBe("failing--0");
-      expect(errorEvent?.data?.message).toContain("boom at import");
-    } finally {
-      delete (window as unknown as { __MANDU_DEVTOOLS_HOOK__?: unknown }).__MANDU_DEVTOOLS_HOOK__;
-    }
-  });
-
-  test("runtime hydrates default client boundary from boundary-local props", async () => {
-    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-default-boundary.js");
-    await writeFile(
-      modulePath,
-      `
-        export default function DefaultBoundary(props) {
-          globalThis.__MANDU_TEST_DEFAULT_BOUNDARY_PROPS__ = props;
-          return null;
-        }
-      `,
-      "utf-8",
-    );
-    Object.assign(globalThis, {
-      __MANDU_TEST_DEFAULT_BOUNDARY_PROPS__: undefined,
-    });
-    document.body.innerHTML = `
-      <div
-        data-mandu-island="default--0"
-        data-mandu-boundary-id="default--0"
-        data-mandu-route-id="default-route"
-        data-mandu-client-export="default"
-        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
-        data-hydrate="load"
-      ></div>
-      <script type="application/json" data-mandu-props="default--0">${serializeProps({ label: "default-boundary" })}</script>
-    `;
-    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {};
-    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
-
-    const runtime = await evaluateGeneratedHydrationRuntime();
-    runtime.hydrateIslands();
-
-    await waitForRuntimeAssertion(() =>
-      (globalThis as typeof globalThis & { __MANDU_TEST_DEFAULT_BOUNDARY_PROPS__?: { label?: string } }).__MANDU_TEST_DEFAULT_BOUNDARY_PROPS__?.label === "default-boundary"
-    );
-  });
-
-  test("runtime keeps explicit island API data-props fallback working", async () => {
-    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-explicit-island.js");
-    await writeFile(
-      modulePath,
-      `
-        export default {
-          __mandu_island: true,
-          definition: {
-            setup(data) {
-              globalThis.__MANDU_TEST_EXPLICIT_ISLAND_DATA__ = data;
-              return data;
-            },
-            render() {
-              return null;
-            }
-          }
-        };
-      `,
-      "utf-8",
-    );
-    Object.assign(globalThis, {
-      __MANDU_TEST_EXPLICIT_ISLAND_DATA__: undefined,
-    });
-    document.body.innerHTML = `
-      <div
-        data-mandu-island="explicit-island"
-        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
-        data-props="${serializeProps({ label: "data-props" }).replace(/"/g, "&quot;")}"
-        data-hydrate="load"
-      ></div>
-    `;
-    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {};
-    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
-
-    const runtime = await evaluateGeneratedHydrationRuntime();
-    runtime.hydrateIslands();
-
-    await waitForRuntimeAssertion(() =>
-      (globalThis as typeof globalThis & { __MANDU_TEST_EXPLICIT_ISLAND_DATA__?: { label?: string } }).__MANDU_TEST_EXPLICIT_ISLAND_DATA__?.label === "data-props"
-    );
-  });
-
-  test("runtime falls back to route-level server data when boundary-local props are absent", async () => {
-    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-route-data-fallback.js");
-    await writeFile(
-      modulePath,
-      `
-        export default function RouteFallbackBoundary(props) {
-          globalThis.__MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__ = props;
-          return null;
-        }
-      `,
-      "utf-8",
-    );
-    Object.assign(globalThis, {
-      __MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__: undefined,
-    });
-    document.body.innerHTML = `
-      <div
-        data-mandu-island="route-fallback--0"
-        data-mandu-boundary-id="route-fallback--0"
-        data-mandu-route-id="route-fallback"
-        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
-        data-hydrate="load"
-      ></div>
-    `;
-    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {
-      "route-fallback": { serverData: { label: "route-level" } },
-    };
-    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
-
-    const runtime = await evaluateGeneratedHydrationRuntime();
-    runtime.hydrateIslands();
-
-    await waitForRuntimeAssertion(() =>
-      (globalThis as typeof globalThis & { __MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__?: { label?: string } }).__MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__?.label === "route-level"
-    );
-  });
-
-  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 });
-      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 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 });
-      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";\n' +
-          'import { useState } from "react";\n' +
-          "export default function LoginPage() {\n" +
-          '  const [email, setEmail] = useState("");\n' +
-          '  return <form><input value={email} onChange={(event) => setEmail(event.currentTarget.value)} /></form>;\n' +
-          "}\n",
-        "utf-8",
-      );
-
-      const routeClientResult = await runBuildInSubprocess(routeClientRoot, "server-page-route-client-import");
-      expect(routeClientResult.success).toBe(true);
-      const bundlePath = path.join(routeClientRoot, ".mandu", "client", "login.island.js");
-      expect(await Bun.file(bundlePath).exists()).toBe(true);
-
-      const bundleSource = await readFile(bundlePath, "utf-8");
-      expect(bundleSource).not.toContain("var LoginPage = LoginPage;");
-      const parseResult = await Bun.build({
-        entrypoints: [bundlePath],
-        target: "browser",
-        external: ["react", "react-dom", "react-dom/client", "react/jsx-dev-runtime"],
-      });
-      expect(parseResult.success).toBe(true);
-    } finally {
-      await rm(routeClientRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("bundles route-level named client exports without requiring a default export", async () => {
-    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 });
-      await writeFile(
-        path.join(routeClientRoot, "package.json"),
-        JSON.stringify({ name: "mandu-route-named-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";\n' +
-          'import { useState } from "react";\n' +
-          "export function LoginPage() {\n" +
-          '  const [email, setEmail] = useState("");\n' +
-          '  return <form><input value={email} onChange={(event) => setEmail(event.currentTarget.value)} /></form>;\n' +
-          "}\n",
-        "utf-8",
-      );
-
-      const routeClientResult = await runBuildInSubprocess(routeClientRoot, "server-page-route-named-client-import");
-      if (!routeClientResult.success) {
-        console.error("[named route client] errors:", routeClientResult.errors);
-      }
-      expect(routeClientResult.success).toBe(true);
-      const bundlePath = path.join(routeClientRoot, ".mandu", "client", "login.island.js");
-      expect(await Bun.file(bundlePath).exists()).toBe(true);
-
-      const bundleSource = await readFile(bundlePath, "utf-8");
-      expect(bundleSource).toContain("LoginPage");
-      expect(bundleSource).not.toContain("Client islands cannot use server-side modules");
-      const parseResult = await Bun.build({
-        entrypoints: [bundlePath],
-        target: "browser",
-        external: ["react", "react-dom", "react-dom/client", "react/jsx-dev-runtime"],
-      });
-      expect(parseResult.success).toBe(true);
-    } finally {
-      await rm(routeClientRoot, { recursive: true, force: true });
-    }
-  });
-
-  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 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 });
-      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 });
-    }
-  });
-});
-
-describe("buildClientBundles client boundaries", () => {
-  async function createBoundaryFixture(prefix: string): Promise<string> {
-    const boundaryRoot = await mkRepoTempDir(prefix);
-    await mkdir(path.join(boundaryRoot, "app", "boundary"), { recursive: true });
-    await mkdir(path.join(boundaryRoot, "src", "client"), { recursive: true });
-    await writeFile(
-      path.join(boundaryRoot, "package.json"),
-      JSON.stringify({ name: "mandu-boundary-test", type: "module" }, null, 2),
-      "utf-8",
-    );
-    await writeFile(
-      path.join(boundaryRoot, "app", "boundary", "page.tsx"),
-      "export default function Page() { return null; }\n",
-      "utf-8",
-    );
-    await writeFile(
-      path.join(boundaryRoot, "src", "client", "BoundaryWidget.client.tsx"),
-      `
-        import React from "react";
-
-        export default function WrongDefault({ label }) {
-          return React.createElement("p", null, "default:" + label);
-        }
-
-        export function BoundaryWidget({ label }) {
-          return React.createElement("button", null, "named:" + label);
-        }
-      `,
-      "utf-8",
-    );
-    return boundaryRoot;
-  }
-
-  test("emits boundary bundle manifest entries", async () => {
-    const boundaryRoot = await createBoundaryFixture("bundler-boundary-");
-    try {
-      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary");
-
-      if (!boundaryResult.success) {
-        console.error("[build.test boundary] errors:", boundaryResult.errors);
-      }
-      expect(boundaryResult.success).toBe(true);
-      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]).toMatchObject({
-        route: "boundary-demo",
-        module: "src/client/BoundaryWidget.client.tsx",
-        exportName: "BoundaryWidget",
-        hydrate: "visible",
-      });
-      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]?.js).toMatch(
-        /^\/\.mandu\/client\/boundary-demo--0\.boundary\.js$/,
-      );
-      expect(boundaryResult.manifest?.bundles?.["boundary-demo"]).toBeUndefined();
-
-      const refreshGlobal = globalThis as typeof globalThis & {
-        $RefreshReg$?: unknown;
-        $RefreshSig$?: unknown;
-      };
-      refreshGlobal.$RefreshReg$ = () => {};
-      refreshGlobal.$RefreshSig$ = () => (type: unknown) => type;
-      try {
-        const boundaryBundle = await import(
-          `${pathToFileURL(path.join(boundaryRoot, ".mandu", "client", "boundary-demo--0.boundary.js")).href}?t=${Date.now()}`
-        );
-        const React = await import("react");
-        const { renderToStaticMarkup } = await import("react-dom/server");
-
-        expect(typeof boundaryBundle.default).toBe("function");
-        expect(typeof boundaryBundle.BoundaryWidget).toBe("function");
-        expect(renderToStaticMarkup(React.createElement(boundaryBundle.default, { label: "ok" }))).toContain("named:ok");
-        expect(renderToStaticMarkup(React.createElement(boundaryBundle.BoundaryWidget, { label: "ok" }))).toContain("named:ok");
-      } finally {
-        delete refreshGlobal.$RefreshReg$;
-        delete refreshGlobal.$RefreshSig$;
-      }
-    } finally {
-      await rm(boundaryRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("snapshots route and bundle boundary metadata", async () => {
-    const boundaryRoot = await createBoundaryFixture("bundler-boundary-snapshot-");
-    try {
-      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary");
-      expect(boundaryResult.success).toBe(true);
-
-      toMatchSnapshot(
-        {
-          routes: boundaryResult.manifest?.routes?.map((route) => ({
-            id: route.id,
-            module: route.module,
-            componentModule: route.componentModule,
-            boundaries: route.boundaries,
-          })),
-          bundleBoundaries: boundaryResult.manifest?.boundaries,
-        },
-        {
-          testFile: path.join(import.meta.dir, "build.test.ts"),
-          name: "client boundary manifest metadata",
-        },
-      );
-    } finally {
-      await rm(boundaryRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("updates boundary manifest entries in target-route builds", async () => {
-    const boundaryRoot = await createBoundaryFixture("bundler-boundary-target-");
-    try {
-      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-target");
-      expect(boundaryResult.success).toBe(true);
-      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]?.js).toBe(
-        "/.mandu/client/boundary-demo--0.boundary.js",
-      );
-    } finally {
-      await rm(boundaryRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("fails before manifest generation when boundary ids are duplicated", async () => {
-    const boundaryRoot = await createBoundaryFixture("bundler-boundary-duplicate-");
-    try {
-      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-duplicate-id");
-
-      expect(boundaryResult.success).toBe(false);
-      expect(boundaryResult.errors.join("\n")).toContain("MANDU_BOUNDARY_DUPLICATE_ID");
-      expect(boundaryResult.errors.join("\n")).toContain("boundary-demo--0");
-    } finally {
-      await rm(boundaryRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("updates boundary manifest entries when framework bundles are skipped", async () => {
-    const boundaryRoot = await createBoundaryFixture("bundler-boundary-skip-");
-    try {
-      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-skip-framework");
-      expect(boundaryResult.success).toBe(true);
-      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]?.js).toBe(
-        "/.mandu/client/boundary-demo--0.boundary.js",
-      );
-    } finally {
-      await rm(boundaryRoot, { recursive: true, force: true });
-    }
-  });
-
-  test("builds manifest-generated boundaries from route-owned server wrappers", async () => {
-    const boundaryRoot = await mkRepoTempDir("bundler-boundary-generated-wrapper-");
-    try {
-      await mkdir(path.join(boundaryRoot, "app", "account", "components"), { recursive: true });
-      await writeFile(
-        path.join(boundaryRoot, "package.json"),
-        JSON.stringify({ name: "mandu-boundary-generated-wrapper-test", type: "module" }, null, 2),
-        "utf-8",
-      );
-      await writeFile(
-        path.join(boundaryRoot, "app", "account", "page.tsx"),
-        `
-          import { AccountShell } from "./components/AccountShell";
-
-          export default function Page() {
-            return <main><AccountShell name="Ada" /></main>;
-          }
-        `,
-        "utf-8",
-      );
-      await writeFile(
-        path.join(boundaryRoot, "app", "account", "components", "AccountShell.tsx"),
-        `
-          import { AccountCard } from "./AccountCard.client";
-
-          export function AccountShell({ name }) {
-            return <AccountCard name={name} />;
-          }
-        `,
-        "utf-8",
-      );
-      await writeFile(
-        path.join(boundaryRoot, "app", "account", "components", "AccountCard.client.tsx"),
-        `
-          import React from "react";
-          export function AccountCard({ name }) {
-            return React.createElement("button", null, name);
-          }
-        `,
-        "utf-8",
-      );
-
-      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-generated-transitive");
-
-      if (!boundaryResult.success) {
-        console.error("[build.test generated boundary] errors:", boundaryResult.errors);
-      }
-      expect(boundaryResult.success).toBe(true);
-      expect(boundaryResult.manifest?.boundaries?.["account--0"]).toMatchObject({
-        route: "account",
-        module: "app/account/components/AccountCard.client.tsx",
-        exportName: "AccountCard",
-        hydrate: "visible",
-      });
-      expect(boundaryResult.manifest?.boundaries?.["account--0"]?.js).toBe(
-        "/.mandu/client/account--0.boundary.js",
-      );
-      expect(boundaryResult.manifest?.bundles?.account).toBeUndefined();
-      expect(await Bun.file(path.join(boundaryRoot, ".mandu", "client", "account--0.boundary.js")).exists()).toBe(true);
-    } finally {
-      await rm(boundaryRoot, { recursive: true, force: true });
-    }
-  });
-});
+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";
+import { serializeProps } from "../client/serialize";
+import { toMatchSnapshot } from "../testing/snapshot";
+import { setupHappyDom } from "../../tests/setup";
+
+setupHappyDom();
+
+const skipBundlerTests = process.env.MANDU_SKIP_BUNDLER_TESTS === "1";
+
+// 모든 테스트가 하나의 빌드 결과를 공유 — 병렬 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;
+  return import(`${fileUrl}?t=${Date.now()}`);
+}
+
+async function evaluateGeneratedHydrationRuntime(): Promise<{ hydrateIslands: () => void }> {
+  const sourcePath = path.join(rootDir, ".mandu", "client", "_runtime.src.js");
+  const bundledPath = path.join(rootDir, ".mandu", "client", "_runtime.js");
+  const runtimeSource = await readFile(await Bun.file(sourcePath).exists() ? sourcePath : bundledPath, "utf-8");
+  const instrumented = runtimeSource
+    .replace(
+      /import\s+React,\s*\{[^}]*\}\s+from\s+['"]react['"];?/,
+      "const React = globalThis.__MANDU_TEST_REACT__; const { useState, useEffect, Component } = React;",
+    )
+    .replace(
+      /import\s+\{[^}]*\}\s+from\s+['"]react-dom\/client['"];?/,
+      "const { hydrateRoot, createRoot } = globalThis.__MANDU_TEST_REACT_DOM_CLIENT__;",
+    )
+    .replace(
+      /export\s*\{[^}]*\};?/g,
+      "globalThis.__MANDU_TEST_RUNTIME__ = { hydrateIslands, unmountIsland, hydratedRoots };",
+    );
+
+  const reactStub = {
+    Component: class {
+      render() {
+        return null;
+      }
+    },
+    createElement(type: unknown, props: Record<string, unknown> | null, ...children: unknown[]) {
+      if (
+        typeof type === "function" &&
+        !(typeof type === "function" && "prototype" in type && (type as { prototype?: { render?: unknown } }).prototype?.render)
+      ) {
+        return (type as (props: Record<string, unknown>) => unknown)({
+          ...(props ?? {}),
+          children: children.length <= 1 ? children[0] : children,
+        });
+      }
+      return { type, props: props ?? {}, children };
+    },
+    isValidElement(value: unknown) {
+      return !!value && typeof value === "object" && "type" in value;
+    },
+    useEffect(effect: () => void) {
+      effect();
+    },
+    useState<T>(initial: T) {
+      return [initial, () => {}] as const;
+    },
+  };
+  const rootStub = {
+    render() {},
+    unmount() {},
+  };
+  Object.assign(globalThis, {
+    __MANDU_TEST_REACT__: reactStub,
+    __MANDU_TEST_REACT_DOM_CLIENT__: {
+      createRoot: () => rootStub,
+      hydrateRoot: () => rootStub,
+    },
+  });
+
+  new Function(instrumented)();
+  return (globalThis as typeof globalThis & {
+    __MANDU_TEST_RUNTIME__: { hydrateIslands: () => void };
+  }).__MANDU_TEST_RUNTIME__;
+}
+
+async function waitForRuntimeAssertion(assertion: () => boolean): Promise<void> {
+  for (let attempt = 0; attempt < 25; attempt++) {
+    if (assertion()) return;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  expect(assertion()).toBe(true);
+}
+
+/**
+ * Run `buildClientBundles` in an isolated `bun` subprocess.
+ *
+ * Bun 1.3.x exhibits a deterministic `AggregateError: Bundle failed` when
+ * `buildClientBundles` is called from a test file AND the same `bun test`
+ * process has previously imported `react` / `react-dom` through any sibling
+ * test file (happens transitively through almost every `src/testing/*` or
+ * `src/runtime/*` consumer). Retrying in-process does not recover — the
+ * resolver state is sticky. A fresh subprocess has a clean module graph.
+ * See `__tests__/build-runner.ts` for the subprocess entrypoint and more
+ * background.
+ */
+async function runBuildInSubprocess(root: string, mode?: string): Promise<{
+  success: boolean;
+  errors: string[];
+  manifest?: {
+    routes?: Array<{
+      id?: string;
+      module?: string;
+      componentModule?: string;
+      boundaries?: Array<{
+        id?: string;
+        routeId?: string;
+        module?: string;
+        importSpecifier?: string;
+        exportName?: string;
+        localName?: string;
+        hydrate?: string;
+        ordinal?: number;
+        propsSource?: string;
+        propsKeys?: string[];
+        hasSpreadProps?: boolean;
+        source?: {
+          file?: string;
+          line?: number;
+          column?: number;
+        };
+      }>;
+    }>;
+    bundles?: Record<string, { js?: string }>;
+    boundaries?: Record<string, { js?: string; route?: string; module?: string; exportName?: string; hydrate?: string }>;
+  } | null;
+}> {
+  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, {
+      cwd: path.resolve(import.meta.dir, "..", ".."),
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "inherit",
+    });
+    const out = await new Response(proc.stdout).text();
+    await proc.exited;
+
+    // Find the final JSON line — the runner may log Mandu dev banners
+    // (e.g. "[Mandu] DevTools …") before emitting the payload. The
+    // contract is: last non-empty line is the JSON blob.
+    const lines = out.split(/\r?\n/).filter((l) => l.trim().length > 0);
+    const last = lines[lines.length - 1] ?? "";
+    try {
+      const parsed = JSON.parse(last);
+      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}`,
+        ],
+        manifest: null,
+      };
+    }
+  } catch (err) {
+    return { success: false, errors: [`spawn failed: ${String(err)}`], manifest: null };
+  }
+}
+
+beforeAll(async () => {
+  if (skipBundlerTests) return;
+  rootDir = await mkRepoTempDir("bundler-");
+
+  await mkdir(path.join(rootDir, "app"), { recursive: true });
+  await writeFile(
+    path.join(rootDir, "package.json"),
+    JSON.stringify({ name: "mandu-build-test", type: "module" }, null, 2),
+    "utf-8",
+  );
+  await writeFile(
+    path.join(rootDir, "app", "demo.client.tsx"),
+    "export default function DemoIsland() { return null; }\n",
+    "utf-8",
+  );
+
+  result = await runBuildInSubprocess(rootDir);
+});
+
+afterAll(async () => {
+  if (rootDir) {
+    await rm(rootDir, { recursive: true, force: true });
+  }
+});
+
+// Bun 1.3.x still serializes parts of Bun.build across concurrent test files.
+// The product test runner gates this file in the main process and executes it
+// alone, while direct `bun test build.test.ts` keeps the complete coverage.
+describe.skipIf(skipBundlerTests)("buildClientBundles vendor shims", () => {
+  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",
+      "__COMPILER_RUNTIME",
+      "cache",
+      "cacheSignal",
+      "startTransition",
+      "use",
+      "useActionState",
+      "useEffectEvent",
+      "useOptimistic",
+      "unstable_useCacheRefresh",
+    ];
+
+    for (const exportName of requiredExports) {
+      expect(exportName in reactShim).toBe(true);
+    }
+  });
+
+  test("re-exports modern react-dom and react-dom/client APIs", async () => {
+    const reactDomShim = await importBuiltModule(".mandu/client/_react-dom.js");
+    for (const exportName of [
+      "preconnect",
+      "prefetchDNS",
+      "preinit",
+      "preinitModule",
+      "preload",
+      "preloadModule",
+      "requestFormReset",
+      "unstable_batchedUpdates",
+      "useFormState",
+      "useFormStatus",
+    ]) {
+      expect(exportName in reactDomShim).toBe(true);
+    }
+
+    const reactDomClientShim = await importBuiltModule(".mandu/client/_react-dom-client.js");
+    for (const exportName of ["createRoot", "hydrateRoot", "version"]) {
+      expect(exportName in reactDomClientShim).toBe(true);
+    }
+  });
+
+  test("embeds hydration guards for deferred trigger strategies", async () => {
+    const runtimeSource = await readFile(path.join(rootDir, ".mandu", "client", "_runtime.js"), "utf-8");
+    expect(runtimeSource).toContain("function resolveHydrationTarget");
+    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('"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("function parsePropsScript");
+    expect(runtimeSource).toContain("data-mandu-props");
+    expect(runtimeSource).toContain("Missing boundary-local props for transformed client boundary");
+    expect(runtimeSource).toContain("warnedBoundaryPropFallbacks");
+    expect(runtimeSource).toContain("deserializeProps");
+    expect(runtimeSource).toContain("new Date");
+    expect(runtimeSource).toContain("new Map");
+  });
+
+  test("runtime hydrates named client boundary from boundary-local props before route data", async () => {
+    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-named-boundary.js");
+    await writeFile(
+      modulePath,
+      `
+        export default function WrongDefault(props) {
+          globalThis.__MANDU_TEST_DEFAULT_PROPS__ = props;
+          return null;
+        }
+        export function NamedBoundary(props) {
+          globalThis.__MANDU_TEST_NAMED_PROPS__ = props;
+          return null;
+        }
+      `,
+      "utf-8",
+    );
+    Object.assign(globalThis, {
+      __MANDU_TEST_NAMED_PROPS__: undefined,
+      __MANDU_TEST_DEFAULT_PROPS__: undefined,
+    });
+    document.body.innerHTML = `
+      <div
+        data-mandu-island="named--0"
+        data-mandu-boundary-id="named--0"
+        data-mandu-route-id="named-route"
+        data-mandu-client-export="NamedBoundary"
+        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
+        data-hydrate="load"
+      ></div>
+      <script type="application/json" data-mandu-props="named--0">${serializeProps({ label: "boundary-local" })}</script>
+    `;
+    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {
+      "named-route": { serverData: { label: "route-data" } },
+    };
+    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
+
+    const runtime = await evaluateGeneratedHydrationRuntime();
+    runtime.hydrateIslands();
+
+    await waitForRuntimeAssertion(() =>
+      (globalThis as typeof globalThis & { __MANDU_TEST_NAMED_PROPS__?: { label?: string } }).__MANDU_TEST_NAMED_PROPS__?.label === "boundary-local"
+    );
+    expect((globalThis as typeof globalThis & { __MANDU_TEST_DEFAULT_PROPS__?: unknown }).__MANDU_TEST_DEFAULT_PROPS__).toBeUndefined();
+  });
+
+  test("surfaces an island hydration failure to the DevTools hook (#324)", async () => {
+    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-failing-boundary.js");
+    // A module that throws at import time → loadAndHydrate's catch runs.
+    await writeFile(modulePath, `throw new Error("boom at import");`, "utf-8");
+
+    const emitted: Array<{ type?: string; data?: { message?: string; islandId?: string } }> = [];
+    (window as unknown as { __MANDU_DEVTOOLS_HOOK__?: { emit: (e: unknown) => void } }).__MANDU_DEVTOOLS_HOOK__ = {
+      emit: (e: unknown) => {
+        emitted.push(e as { type?: string });
+      },
+    };
+
+    document.body.innerHTML = `
+      <div
+        data-mandu-island="failing--0"
+        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
+        data-hydrate="load"
+      ></div>
+    `;
+    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
+
+    try {
+      const runtime = await evaluateGeneratedHydrationRuntime();
+      runtime.hydrateIslands();
+
+      await waitForRuntimeAssertion(() => emitted.some((e) => e.type === "error"));
+      const errorEvent = emitted.find((e) => e.type === "error");
+      expect(errorEvent?.data?.islandId).toBe("failing--0");
+      expect(errorEvent?.data?.message).toContain("boom at import");
+    } finally {
+      delete (window as unknown as { __MANDU_DEVTOOLS_HOOK__?: unknown }).__MANDU_DEVTOOLS_HOOK__;
+    }
+  });
+
+  test("runtime hydrates default client boundary from boundary-local props", async () => {
+    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-default-boundary.js");
+    await writeFile(
+      modulePath,
+      `
+        export default function DefaultBoundary(props) {
+          globalThis.__MANDU_TEST_DEFAULT_BOUNDARY_PROPS__ = props;
+          return null;
+        }
+      `,
+      "utf-8",
+    );
+    Object.assign(globalThis, {
+      __MANDU_TEST_DEFAULT_BOUNDARY_PROPS__: undefined,
+    });
+    document.body.innerHTML = `
+      <div
+        data-mandu-island="default--0"
+        data-mandu-boundary-id="default--0"
+        data-mandu-route-id="default-route"
+        data-mandu-client-export="default"
+        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
+        data-hydrate="load"
+      ></div>
+      <script type="application/json" data-mandu-props="default--0">${serializeProps({ label: "default-boundary" })}</script>
+    `;
+    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {};
+    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
+
+    const runtime = await evaluateGeneratedHydrationRuntime();
+    runtime.hydrateIslands();
+
+    await waitForRuntimeAssertion(() =>
+      (globalThis as typeof globalThis & { __MANDU_TEST_DEFAULT_BOUNDARY_PROPS__?: { label?: string } }).__MANDU_TEST_DEFAULT_BOUNDARY_PROPS__?.label === "default-boundary"
+    );
+  });
+
+  test("runtime keeps explicit island API data-props fallback working", async () => {
+    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-explicit-island.js");
+    await writeFile(
+      modulePath,
+      `
+        export default {
+          __mandu_island: true,
+          definition: {
+            setup(data) {
+              globalThis.__MANDU_TEST_EXPLICIT_ISLAND_DATA__ = data;
+              return data;
+            },
+            render() {
+              return null;
+            }
+          }
+        };
+      `,
+      "utf-8",
+    );
+    Object.assign(globalThis, {
+      __MANDU_TEST_EXPLICIT_ISLAND_DATA__: undefined,
+    });
+    document.body.innerHTML = `
+      <div
+        data-mandu-island="explicit-island"
+        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
+        data-props="${serializeProps({ label: "data-props" }).replace(/"/g, "&quot;")}"
+        data-hydrate="load"
+      ></div>
+    `;
+    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {};
+    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
+
+    const runtime = await evaluateGeneratedHydrationRuntime();
+    runtime.hydrateIslands();
+
+    await waitForRuntimeAssertion(() =>
+      (globalThis as typeof globalThis & { __MANDU_TEST_EXPLICIT_ISLAND_DATA__?: { label?: string } }).__MANDU_TEST_EXPLICIT_ISLAND_DATA__?.label === "data-props"
+    );
+  });
+
+  test("runtime falls back to route-level server data when boundary-local props are absent", async () => {
+    const modulePath = path.join(rootDir, ".mandu", "client", "runtime-route-data-fallback.js");
+    await writeFile(
+      modulePath,
+      `
+        export default function RouteFallbackBoundary(props) {
+          globalThis.__MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__ = props;
+          return null;
+        }
+      `,
+      "utf-8",
+    );
+    Object.assign(globalThis, {
+      __MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__: undefined,
+    });
+    document.body.innerHTML = `
+      <div
+        data-mandu-island="route-fallback--0"
+        data-mandu-boundary-id="route-fallback--0"
+        data-mandu-route-id="route-fallback"
+        data-mandu-src="${pathToFileURL(modulePath).href}?t=${Date.now()}"
+        data-hydrate="load"
+      ></div>
+    `;
+    (window as typeof window & { __MANDU_DATA__?: unknown; __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_DATA__ = {
+      "route-fallback": { serverData: { label: "route-level" } },
+    };
+    (window as typeof window & { __MANDU_ROOTS__?: Map<string, unknown> }).__MANDU_ROOTS__ = new Map();
+
+    const runtime = await evaluateGeneratedHydrationRuntime();
+    runtime.hydrateIslands();
+
+    await waitForRuntimeAssertion(() =>
+      (globalThis as typeof globalThis & { __MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__?: { label?: string } }).__MANDU_TEST_ROUTE_DATA_FALLBACK_PROPS__?.label === "route-level"
+    );
+  });
+
+  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 });
+      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 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 });
+      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";\n' +
+          'import { useState } from "react";\n' +
+          "export default function LoginPage() {\n" +
+          '  const [email, setEmail] = useState("");\n' +
+          '  return <form><input value={email} onChange={(event) => setEmail(event.currentTarget.value)} /></form>;\n' +
+          "}\n",
+        "utf-8",
+      );
+
+      const routeClientResult = await runBuildInSubprocess(routeClientRoot, "server-page-route-client-import");
+      expect(routeClientResult.success).toBe(true);
+      const bundlePath = path.join(routeClientRoot, ".mandu", "client", "login.island.js");
+      expect(await Bun.file(bundlePath).exists()).toBe(true);
+
+      const bundleSource = await readFile(bundlePath, "utf-8");
+      expect(bundleSource).not.toContain("var LoginPage = LoginPage;");
+      const parseResult = await Bun.build({
+        entrypoints: [bundlePath],
+        target: "browser",
+        external: ["react", "react-dom", "react-dom/client", "react/jsx-dev-runtime"],
+      });
+      expect(parseResult.success).toBe(true);
+    } finally {
+      await rm(routeClientRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("bundles route-level named client exports without requiring a default export", async () => {
+    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 });
+      await writeFile(
+        path.join(routeClientRoot, "package.json"),
+        JSON.stringify({ name: "mandu-route-named-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";\n' +
+          'import { useState } from "react";\n' +
+          "export function LoginPage() {\n" +
+          '  const [email, setEmail] = useState("");\n' +
+          '  return <form><input value={email} onChange={(event) => setEmail(event.currentTarget.value)} /></form>;\n' +
+          "}\n",
+        "utf-8",
+      );
+
+      const routeClientResult = await runBuildInSubprocess(routeClientRoot, "server-page-route-named-client-import");
+      if (!routeClientResult.success) {
+        console.error("[named route client] errors:", routeClientResult.errors);
+      }
+      expect(routeClientResult.success).toBe(true);
+      const bundlePath = path.join(routeClientRoot, ".mandu", "client", "login.island.js");
+      expect(await Bun.file(bundlePath).exists()).toBe(true);
+
+      const bundleSource = await readFile(bundlePath, "utf-8");
+      expect(bundleSource).toContain("LoginPage");
+      expect(bundleSource).not.toContain("Client islands cannot use server-side modules");
+      const parseResult = await Bun.build({
+        entrypoints: [bundlePath],
+        target: "browser",
+        external: ["react", "react-dom", "react-dom/client", "react/jsx-dev-runtime"],
+      });
+      expect(parseResult.success).toBe(true);
+    } finally {
+      await rm(routeClientRoot, { recursive: true, force: true });
+    }
+  });
+
+  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 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 });
+      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 });
+    }
+  });
+});
+
+describe.skipIf(skipBundlerTests)("buildClientBundles client boundaries", () => {
+  async function createBoundaryFixture(prefix: string): Promise<string> {
+    const boundaryRoot = await mkRepoTempDir(prefix);
+    await mkdir(path.join(boundaryRoot, "app", "boundary"), { recursive: true });
+    await mkdir(path.join(boundaryRoot, "src", "client"), { recursive: true });
+    await writeFile(
+      path.join(boundaryRoot, "package.json"),
+      JSON.stringify({ name: "mandu-boundary-test", type: "module" }, null, 2),
+      "utf-8",
+    );
+    await writeFile(
+      path.join(boundaryRoot, "app", "boundary", "page.tsx"),
+      "export default function Page() { return null; }\n",
+      "utf-8",
+    );
+    await writeFile(
+      path.join(boundaryRoot, "src", "client", "BoundaryWidget.client.tsx"),
+      `
+        import React from "react";
+
+        export default function WrongDefault({ label }) {
+          return React.createElement("p", null, "default:" + label);
+        }
+
+        export function BoundaryWidget({ label }) {
+          return React.createElement("button", null, "named:" + label);
+        }
+      `,
+      "utf-8",
+    );
+    return boundaryRoot;
+  }
+
+  test("emits boundary bundle manifest entries", async () => {
+    const boundaryRoot = await createBoundaryFixture("bundler-boundary-");
+    try {
+      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary");
+
+      if (!boundaryResult.success) {
+        console.error("[build.test boundary] errors:", boundaryResult.errors);
+      }
+      expect(boundaryResult.success).toBe(true);
+      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]).toMatchObject({
+        route: "boundary-demo",
+        module: "src/client/BoundaryWidget.client.tsx",
+        exportName: "BoundaryWidget",
+        hydrate: "visible",
+      });
+      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]?.js).toMatch(
+        /^\/\.mandu\/client\/boundary-demo--0\.boundary\.js$/,
+      );
+      expect(boundaryResult.manifest?.bundles?.["boundary-demo"]).toBeUndefined();
+
+      const refreshGlobal = globalThis as typeof globalThis & {
+        $RefreshReg$?: unknown;
+        $RefreshSig$?: unknown;
+      };
+      refreshGlobal.$RefreshReg$ = () => {};
+      refreshGlobal.$RefreshSig$ = () => (type: unknown) => type;
+      try {
+        const boundaryBundle = await import(
+          `${pathToFileURL(path.join(boundaryRoot, ".mandu", "client", "boundary-demo--0.boundary.js")).href}?t=${Date.now()}`
+        );
+        const React = await import("react");
+        const { renderToStaticMarkup } = await import("react-dom/server");
+
+        expect(typeof boundaryBundle.default).toBe("function");
+        expect(typeof boundaryBundle.BoundaryWidget).toBe("function");
+        expect(renderToStaticMarkup(React.createElement(boundaryBundle.default, { label: "ok" }))).toContain("named:ok");
+        expect(renderToStaticMarkup(React.createElement(boundaryBundle.BoundaryWidget, { label: "ok" }))).toContain("named:ok");
+      } finally {
+        delete refreshGlobal.$RefreshReg$;
+        delete refreshGlobal.$RefreshSig$;
+      }
+    } finally {
+      await rm(boundaryRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("snapshots route and bundle boundary metadata", async () => {
+    const boundaryRoot = await createBoundaryFixture("bundler-boundary-snapshot-");
+    try {
+      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary");
+      expect(boundaryResult.success).toBe(true);
+
+      toMatchSnapshot(
+        {
+          routes: boundaryResult.manifest?.routes?.map((route) => ({
+            id: route.id,
+            module: route.module,
+            componentModule: route.componentModule,
+            boundaries: route.boundaries,
+          })),
+          bundleBoundaries: boundaryResult.manifest?.boundaries,
+        },
+        {
+          testFile: path.join(import.meta.dir, "build.test.ts"),
+          name: "client boundary manifest metadata",
+        },
+      );
+    } finally {
+      await rm(boundaryRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("updates boundary manifest entries in target-route builds", async () => {
+    const boundaryRoot = await createBoundaryFixture("bundler-boundary-target-");
+    try {
+      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-target");
+      expect(boundaryResult.success).toBe(true);
+      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]?.js).toBe(
+        "/.mandu/client/boundary-demo--0.boundary.js",
+      );
+    } finally {
+      await rm(boundaryRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("fails before manifest generation when boundary ids are duplicated", async () => {
+    const boundaryRoot = await createBoundaryFixture("bundler-boundary-duplicate-");
+    try {
+      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-duplicate-id");
+
+      expect(boundaryResult.success).toBe(false);
+      expect(boundaryResult.errors.join("\n")).toContain("MANDU_BOUNDARY_DUPLICATE_ID");
+      expect(boundaryResult.errors.join("\n")).toContain("boundary-demo--0");
+    } finally {
+      await rm(boundaryRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("updates boundary manifest entries when framework bundles are skipped", async () => {
+    const boundaryRoot = await createBoundaryFixture("bundler-boundary-skip-");
+    try {
+      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-skip-framework");
+      expect(boundaryResult.success).toBe(true);
+      expect(boundaryResult.manifest?.boundaries?.["boundary-demo--0"]?.js).toBe(
+        "/.mandu/client/boundary-demo--0.boundary.js",
+      );
+    } finally {
+      await rm(boundaryRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("builds manifest-generated boundaries from route-owned server wrappers", async () => {
+    const boundaryRoot = await mkRepoTempDir("bundler-boundary-generated-wrapper-");
+    try {
+      await mkdir(path.join(boundaryRoot, "app", "account", "components"), { recursive: true });
+      await writeFile(
+        path.join(boundaryRoot, "package.json"),
+        JSON.stringify({ name: "mandu-boundary-generated-wrapper-test", type: "module" }, null, 2),
+        "utf-8",
+      );
+      await writeFile(
+        path.join(boundaryRoot, "app", "account", "page.tsx"),
+        `
+          import { AccountShell } from "./components/AccountShell";
+
+          export default function Page() {
+            return <main><AccountShell name="Ada" /></main>;
+          }
+        `,
+        "utf-8",
+      );
+      await writeFile(
+        path.join(boundaryRoot, "app", "account", "components", "AccountShell.tsx"),
+        `
+          import { AccountCard } from "./AccountCard.client";
+
+          export function AccountShell({ name }) {
+            return <AccountCard name={name} />;
+          }
+        `,
+        "utf-8",
+      );
+      await writeFile(
+        path.join(boundaryRoot, "app", "account", "components", "AccountCard.client.tsx"),
+        `
+          import React from "react";
+          export function AccountCard({ name }) {
+            return React.createElement("button", null, name);
+          }
+        `,
+        "utf-8",
+      );
+
+      const boundaryResult = await runBuildInSubprocess(boundaryRoot, "client-boundary-generated-transitive");
+
+      if (!boundaryResult.success) {
+        console.error("[build.test generated boundary] errors:", boundaryResult.errors);
+      }
+      expect(boundaryResult.success).toBe(true);
+      expect(boundaryResult.manifest?.boundaries?.["account--0"]).toMatchObject({
+        route: "account",
+        module: "app/account/components/AccountCard.client.tsx",
+        exportName: "AccountCard",
+        hydrate: "visible",
+      });
+      expect(boundaryResult.manifest?.boundaries?.["account--0"]?.js).toBe(
+        "/.mandu/client/account--0.boundary.js",
+      );
+      expect(boundaryResult.manifest?.bundles?.account).toBeUndefined();
+      expect(await Bun.file(path.join(boundaryRoot, ".mandu", "client", "account--0.boundary.js")).exists()).toBe(true);
+    } finally {
+      await rm(boundaryRoot, { recursive: true, force: true });
+    }
+  });
+});