@mandujs/core 0.54.12 → 0.54.14

package/src/router/client-entry.test.ts

@@ -1,14 +1,21 @@
-import { describe, expect, it } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
-import path from "path";
+import { describe, expect, it } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
+import path from "path";
 import {
   findClientComponentImports,
   findRouteLevelClientComponentImport,
   findRouteLevelClientComponentImports,
   resolveRouteLevelClientEntryPath,
-} from "./client-entry";
-
-describe("findClientComponentImports", () => {
+} from "./client-entry";
+
+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));
+}
+
+describe("findClientComponentImports", () => {
   it("detects named .client imports for diagnostics", () => {
     const imports = findClientComponentImports(`
       import { LoginForm, SubmitButton as Button } from "@/client/widgets/login-form/LoginForm.client";
@@ -40,10 +47,11 @@ describe("findClientComponentImports", () => {
       }
     `);
 
-    expect(routeClient).toEqual({
-      module: "@/client/pages/login/LoginPage.client",
-      localName: "LoginPage",
-    });
+    expect(routeClient).toEqual({
+      module: "@/client/pages/login/LoginPage.client",
+      localName: "LoginPage",
+      exportName: "default",
+    });
   });
 
   it("promotes a fragment wrapper with head-only elements and a bare client component", () => {
@@ -58,10 +66,11 @@ describe("findClientComponentImports", () => {
       }
     `);
 
-    expect(routeClient).toEqual({
-      module: "@/client/pages/home/HomeApp.client",
-      localName: "HomeApp",
-    });
+    expect(routeClient).toEqual({
+      module: "@/client/pages/home/HomeApp.client",
+      localName: "HomeApp",
+      exportName: "default",
+    });
   });
 
   it("detects a named-imported client component when the page returns only that component", () => {
@@ -73,11 +82,28 @@ describe("findClientComponentImports", () => {
       }
     `);
 
-    expect(routeClient).toEqual({
-      module: "@/client/pages/notifications/NotificationsPage.client",
-      localName: "NotificationsPage",
-    });
-  });
+    expect(routeClient).toEqual({
+      module: "@/client/pages/notifications/NotificationsPage.client",
+      localName: "NotificationsPage",
+      exportName: "NotificationsPage",
+    });
+  });
+
+  it("preserves the source export name for aliased named imports", () => {
+    const routeClient = findRouteLevelClientComponentImport(`
+      import { NotificationsPage as PageIsland } from "@/client/pages/notifications/NotificationsPage.client";
+
+      export default function Page() {
+        return <PageIsland />;
+      }
+    `);
+
+    expect(routeClient).toEqual({
+      module: "@/client/pages/notifications/NotificationsPage.client",
+      localName: "PageIsland",
+      exportName: "NotificationsPage",
+    });
+  });
 
   it("promotes embedded client imports inside a larger server page", () => {
     const routeClient = findRouteLevelClientComponentImport(`
@@ -91,10 +117,11 @@ describe("findClientComponentImports", () => {
       }
     `);
 
-    expect(routeClient).toEqual({
-      module: "@/client/pages/home/HomeApp.client",
-      localName: "HomeApp",
-    });
+    expect(routeClient).toEqual({
+      module: "@/client/pages/home/HomeApp.client",
+      localName: "HomeApp",
+      exportName: "default",
+    });
   });
 
   it("promotes client imports when the page wrapper passes props", () => {
@@ -106,10 +133,11 @@ describe("findClientComponentImports", () => {
       }
     `);
 
-    expect(routeClient).toEqual({
-      module: "@/client/pages/pledges/PledgePage.client",
-      localName: "PledgePage",
-    });
+    expect(routeClient).toEqual({
+      module: "@/client/pages/pledges/PledgePage.client",
+      localName: "PledgePage",
+      exportName: "default",
+    });
   });
 
   it("detects multiple rendered client imports in a server shell", () => {
@@ -130,14 +158,16 @@ describe("findClientComponentImports", () => {
     `);
 
     expect(routeClients).toEqual([
-      {
-        module: "@/client/widgets/comments-section/CommentsSection.client",
-        localName: "CommentsSection",
-      },
-      {
-        module: "@/client/widgets/pledge-actions/PledgeActions.client",
-        localName: "PledgeActions",
-      },
+      {
+        module: "@/client/widgets/comments-section/CommentsSection.client",
+        localName: "CommentsSection",
+        exportName: "CommentsSection",
+      },
+      {
+        module: "@/client/widgets/pledge-actions/PledgeActions.client",
+        localName: "PledgeActions",
+        exportName: "PledgeActions",
+      },
     ]);
   });
 
@@ -150,14 +180,27 @@ describe("findClientComponentImports", () => {
       }
     `);
 
-    expect(routeClient).toEqual({
-      module: "@/client/widgets/pledge-form/PledgeForm",
-      localName: "PledgeForm",
-    });
+    expect(routeClient).toEqual({
+      module: "@/client/widgets/pledge-form/PledgeForm",
+      localName: "PledgeForm",
+      exportName: "PledgeForm",
+    });
+  });
+
+  it("does not promote shared UI primitives to route-level client entries", () => {
+    const routeClient = findRouteLevelClientComponentImport(`
+      import { Button } from "@/client/shared/ui/button";
+
+      export default function Page() {
+        return <main><Button>Open</Button></main>;
+      }
+    `);
+
+    expect(routeClient).toBeNull();
   });
 
-  it("resolves a route-level client entry by reading a use client target without .client in the path", async () => {
-    const rootDir = await mkdtemp(path.join(import.meta.dir, ".tmp-client-entry-"));
+  it("resolves a route-level client entry by reading a use client target without .client in the path", async () => {
+    const rootDir = await mkRepoTempDir("client-entry-");
     try {
       await mkdir(path.join(rootDir, "app", "pledges", "new"), { recursive: true });
       await mkdir(path.join(rootDir, "src", "client", "widgets", "pledge-form"), { recursive: true });

package/src/router/client-entry.ts

@@ -8,12 +8,23 @@ export interface ClientComponentImport {
   names: string[];
 }
 
-export interface RouteLevelClientComponentImport {
-  module: string;
-  localName: string;
-}
-
-const CLIENT_ENTRY_SPECIFIER_PATTERN = /\.(?:client|island)(?:\.[tj]sx?)?$/;
+export interface RouteLevelClientComponentImport {
+  module: string;
+  localName: string;
+  exportName: string;
+}
+
+const CLIENT_ENTRY_SPECIFIER_PATTERN = /\.(?:client|island)(?:\.[tj]sx?)?$/;
+const DEFAULT_EXPORT_NAME = "default";
+
+interface ComponentImportSpecifier {
+  importedName: string;
+  localName: string;
+}
+
+interface ComponentImportRecord extends ClientComponentImport {
+  specifiers: ComponentImportSpecifier[];
+}
 
 export function normalizeRouteModulePath(value: string | undefined): string {
   return (value ?? "").replace(/\\/g, "/").replace(/^\.\//, "");
@@ -45,45 +56,64 @@ async function readRouteModule(rootDir: string, modulePath: string): Promise<str
   }
 }
 
-export function findClientComponentImports(source: string): ClientComponentImport[] {
-  return findComponentImports(source).filter((entry) => clientSpecifierLooksBrowserOnly(entry.module));
-}
-
-function findComponentImports(source: string): ClientComponentImport[] {
-  const imports: ClientComponentImport[] = [];
-  const importFromPattern = /import\s+(?!type\b)([\s\S]*?)\s+from\s+["']([^"']+)["']/g;
-  const sideEffectPattern = /import\s+["']([^"']+)["']/g;
+export function findClientComponentImports(source: string): ClientComponentImport[] {
+  return findComponentImportRecords(source)
+    .filter((entry) => clientSpecifierLooksBrowserOnly(entry.module))
+    .map(toPublicClientComponentImport);
+}
+
+function toPublicClientComponentImport(entry: ComponentImportRecord): ClientComponentImport {
+  return {
+    module: entry.module,
+    kind: entry.kind,
+    names: entry.names,
+  };
+}
+
+function findComponentImportRecords(source: string): ComponentImportRecord[] {
+  const imports: ComponentImportRecord[] = [];
+  const importFromPattern = /import\s+(?!type\b)([\s\S]*?)\s+from\s+["']([^"']+)["']/g;
+  const sideEffectPattern = /import\s+["']([^"']+)["']/g;
 
   for (const match of source.matchAll(importFromPattern)) {
     const clause = (match[1] ?? "").trim();
-    const module = match[2] ?? "";
-    const names: string[] = [];
-    let hasDefault = false;
-    let hasNamed = false;
-    let hasNamespace = false;
+    const module = match[2] ?? "";
+    const names: string[] = [];
+    const specifiers: ComponentImportSpecifier[] = [];
+    let hasDefault = false;
+    let hasNamed = false;
+    let hasNamespace = false;
 
     const namedMatch = clause.match(/\{([^}]*)\}/);
     if (namedMatch) {
       hasNamed = true;
       for (const rawName of namedMatch[1].split(",")) {
-        const name = rawName.trim();
-        if (!name) continue;
-        const parts = name.split(/\s+as\s+/i).map((part) => part.trim()).filter(Boolean);
-        names.push(parts[1] ?? parts[0]);
-      }
-    }
-
-    if (/\*\s+as\s+/.test(clause)) {
-      hasNamespace = true;
-      const namespaceMatch = clause.match(/\*\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)/);
-      if (namespaceMatch?.[1]) names.push(namespaceMatch[1]);
-    }
-
-    const beforeNamed = clause.split("{")[0]?.replace(/,\s*$/, "").trim() ?? "";
-    if (beforeNamed && !beforeNamed.startsWith("*")) {
-      hasDefault = true;
-      names.push(beforeNamed.split(",")[0].trim());
-    }
+        const name = rawName.trim();
+        if (!name) continue;
+        const parts = name.split(/\s+as\s+/i).map((part) => part.trim()).filter(Boolean);
+        const importedName = parts[0] ?? "";
+        const localName = parts[1] ?? importedName;
+        names.push(localName);
+        specifiers.push({ importedName, localName });
+      }
+    }
+
+    if (/\*\s+as\s+/.test(clause)) {
+      hasNamespace = true;
+      const namespaceMatch = clause.match(/\*\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)/);
+      if (namespaceMatch?.[1]) {
+        names.push(namespaceMatch[1]);
+        specifiers.push({ importedName: "*", localName: namespaceMatch[1] });
+      }
+    }
+
+    const beforeNamed = clause.split("{")[0]?.replace(/,\s*$/, "").trim() ?? "";
+    if (beforeNamed && !beforeNamed.startsWith("*")) {
+      hasDefault = true;
+      const localName = beforeNamed.split(",")[0].trim();
+      names.push(localName);
+      specifiers.push({ importedName: DEFAULT_EXPORT_NAME, localName });
+    }
 
     const kind =
       (hasDefault && (hasNamed || hasNamespace))
@@ -94,33 +124,51 @@ function findComponentImports(source: string): ClientComponentImport[] {
             ? "namespace"
             : "default";
 
-    imports.push({ module, kind, names });
-  }
+    imports.push({ module, kind, names, specifiers });
+  }
 
   for (const match of source.matchAll(sideEffectPattern)) {
     const module = match[1] ?? "";
     if (imports.some((entry) => entry.module === module)) continue;
-    imports.push({ module, kind: "side-effect", names: [] });
-  }
-
-  return imports;
+    imports.push({ module, kind: "side-effect", names: [], specifiers: [] });
+  }
+
+  return imports;
 }
 
 export function findRouteLevelClientComponentImport(source: string): RouteLevelClientComponentImport | null {
   return findRouteLevelClientComponentImports(source)[0] ?? null;
 }
 
-export function findRouteLevelClientComponentImports(source: string): RouteLevelClientComponentImport[] {
-  const candidates = findComponentImports(source).flatMap((entry) =>
-    entry.names
-      .filter((localName) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(localName))
-      .map((localName) => ({ module: entry.module, localName }))
-  );
+export function findRouteLevelClientComponentImports(source: string): RouteLevelClientComponentImport[] {
+  const candidates = findComponentImportRecords(source).flatMap((entry) =>
+    isRouteLevelClientEntrySpecifier(entry.module)
+      ? entry.specifiers
+          .filter((specifier) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(specifier.localName))
+          .map((specifier) => ({
+            module: entry.module,
+            localName: specifier.localName,
+            exportName: specifier.importedName,
+          }))
+      : []
+  );
 
   if (candidates.length === 0) return [];
   return defaultExportRendersClientComponents(source, candidates);
 }
 
+function isRouteLevelClientEntrySpecifier(specifier: string): boolean {
+  const normalized = specifier.replace(/\\/g, "/");
+  if (
+    normalized.includes("/client/shared/") ||
+    normalized.startsWith("@/client/shared/") ||
+    normalized.startsWith("src/client/shared/")
+  ) {
+    return false;
+  }
+  return true;
+}
+
 export async function resolveClientImportModulePath(
   rootDir: string,
   importerModule: string,
@@ -138,40 +186,58 @@ export async function resolveClientImportModulePath(
   return null;
 }
 
-export async function resolveRouteLevelClientEntryPath(
-  rootDir: string,
-  routeModule: string,
-  source: string,
-): Promise<string | null> {
-  const routeLevelClientImports = findRouteLevelClientComponentImports(source);
-  for (const routeLevelClientImport of routeLevelClientImports) {
-    const resolved = await resolveClientImportModulePath(rootDir, routeModule, routeLevelClientImport.module);
-    if (!resolved) continue;
-    if (clientSpecifierLooksBrowserOnly(routeLevelClientImport.module)) return resolved;
-
-    const importedSource = await readRouteModule(rootDir, resolved);
-    if (importedSource !== null && hasUseClientDirective(importedSource)) {
-      return resolved;
-    }
-  }
-
-  return null;
-}
-
-export async function shouldPreserveExistingClientModule(
-  route: RouteSpec,
-  clientModule: string,
-  rootDir: string,
-): Promise<boolean> {
-  const source = await readRouteModule(rootDir, clientModule);
-  if (source === null) return false;
-  if (hasUseServerDirective(source)) return false;
-  if (clientModuleIsRouteComponent(route, clientModule)) {
-    if (hasUseClientDirective(source)) return true;
-    return await routeComponentHasResolvableClientEntry(rootDir, clientModule, source);
-  }
-  return true;
-}
+export async function resolveRouteLevelClientEntryPath(
+  rootDir: string,
+  routeModule: string,
+  source: string,
+): Promise<string | null> {
+  return (await resolveRouteLevelClientEntry(rootDir, routeModule, source))?.modulePath ?? null;
+}
+
+export async function resolveRouteLevelClientEntry(
+  rootDir: string,
+  routeModule: string,
+  source: string,
+): Promise<{ modulePath: string; exportName: string } | null> {
+  const routeLevelClientImports = findRouteLevelClientComponentImports(source);
+  for (const routeLevelClientImport of routeLevelClientImports) {
+    const resolved = await resolveClientImportModulePath(rootDir, routeModule, routeLevelClientImport.module);
+    if (!resolved) continue;
+    if (clientSpecifierLooksBrowserOnly(routeLevelClientImport.module)) {
+      return { modulePath: resolved, exportName: routeLevelClientImport.exportName };
+    }
+
+    const importedSource = await readRouteModule(rootDir, resolved);
+    if (importedSource !== null && hasUseClientDirective(importedSource)) {
+      return { modulePath: resolved, exportName: routeLevelClientImport.exportName };
+    }
+  }
+
+  return null;
+}
+
+export async function shouldPreserveExistingClientModule(
+  route: RouteSpec,
+  clientModule: string,
+  rootDir: string,
+): Promise<boolean> {
+  if (!isRouteLevelClientEntrySpecifier(clientModule)) return false;
+  const source = await readRouteModule(rootDir, clientModule);
+  if (source === null) return false;
+  if (hasUseServerDirective(source)) return false;
+  if (clientModuleIsRouteComponent(route, clientModule)) {
+    if (hasUseClientDirective(source)) return true;
+    return await routeComponentHasResolvableClientEntry(rootDir, clientModule, source);
+  }
+
+  if (route.kind !== "page" || !route.componentModule) return false;
+
+  const routeSource = await readRouteModule(rootDir, route.componentModule);
+  if (routeSource === null) return false;
+
+  const currentEntry = await resolveRouteLevelClientEntry(rootDir, route.componentModule, routeSource);
+  return normalizeRouteModulePath(currentEntry?.modulePath) === normalizeRouteModulePath(clientModule);
+}
 
 function resolveImportBasePath(rootDir: string, importerModule: string, specifier: string): string | null {
   const normalized = specifier.replace(/\\/g, "/");
@@ -446,12 +512,13 @@ export async function validateClientModuleForBrowserBundle(
     return `[${route.id}] Client module "${route.clientModule}" has a "use server" directive and cannot be bundled for the browser.`;
   }
 
-  if (clientModuleIsRouteComponent(route) && !hasUseClientDirective(source)) {
-    const realClientEntry = await resolveRouteLevelClientEntryPath(rootDir, route.clientModule, source);
-    if (realClientEntry) {
-      route.clientModule = realClientEntry;
-      return null;
-    }
+  if (clientModuleIsRouteComponent(route) && !hasUseClientDirective(source)) {
+    const realClientEntry = await resolveRouteLevelClientEntry(rootDir, route.clientModule, source);
+    if (realClientEntry) {
+      route.clientModule = realClientEntry.modulePath;
+      route.clientExportName = realClientEntry.exportName;
+      return null;
+    }
     return (
       `[${route.id}] Route component "${route.clientModule}" is configured as clientModule, ` +
       `but it is a server page (missing "use client"). Mandu will not bundle server pages into client islands. ` +

package/src/router/fs-routes.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
+import path from "path";
+import { generateManifest } from "./fs-routes";
+
+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));
+}
+
+describe("generateManifest hydration config", () => {
+  it("does not preserve stale island hydration after the client entry disappears", async () => {
+    const rootDir = await mkRepoTempDir("routes-hydration-stale-");
+    try {
+      await mkdir(path.join(rootDir, "app", "candidates", "[id]"), { recursive: true });
+      await mkdir(path.join(rootDir, "src", "client", "widgets"), { recursive: true });
+      await writeFile(
+        path.join(rootDir, "app", "candidates", "[id]", "page.tsx"),
+        `
+          import { PledgeAccordion } from "@/client/widgets/PledgeAccordion.client";
+          export default function Page() {
+            return <main><PledgeAccordion pledges={[]} /></main>;
+          }
+        `,
+        "utf-8",
+      );
+      await writeFile(
+        path.join(rootDir, "src", "client", "widgets", "PledgeAccordion.client.tsx"),
+        `
+          "use client";
+          export function PledgeAccordion() {
+            return <div />;
+          }
+        `,
+        "utf-8",
+      );
+
+      const first = await generateManifest(rootDir);
+      const firstRoute = first.manifest.routes.find((route) => route.id === "candidates-$id");
+      expect(firstRoute?.clientModule).toContain("PledgeAccordion.client.tsx");
+      expect(firstRoute?.hydration?.strategy).toBe("island");
+
+      await writeFile(
+        path.join(rootDir, "app", "candidates", "[id]", "page.tsx"),
+        `
+          export default function Page() {
+            return <main><details><summary>server only</summary></details></main>;
+          }
+        `,
+        "utf-8",
+      );
+
+      const second = await generateManifest(rootDir);
+      const secondRoute = second.manifest.routes.find((route) => route.id === "candidates-$id");
+      expect(secondRoute?.clientModule).toBeUndefined();
+      expect(secondRoute?.hydration?.strategy).not.toBe("island");
+    } finally {
+      await rm(rootDir, { recursive: true, force: true });
+    }
+  });
+
+  it("reads page-level hydration exports from the current page source", async () => {
+    const rootDir = await mkRepoTempDir("routes-hydration-export-");
+    try {
+      await mkdir(path.join(rootDir, "app", "about"), { recursive: true });
+      await writeFile(
+        path.join(rootDir, "app", "about", "page.tsx"),
+        `
+          export const hydration = { strategy: "none", priority: "idle", preload: true };
+          export default function Page() {
+            return <main>About</main>;
+          }
+        `,
+        "utf-8",
+      );
+
+      const result = await generateManifest(rootDir);
+      const route = result.manifest.routes.find((entry) => entry.id === "about");
+      expect(route?.hydration).toEqual({
+        strategy: "none",
+        priority: "idle",
+        preload: true,
+      });
+    } finally {
+      await rm(rootDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/router/fs-routes.ts

@@ -14,11 +14,11 @@ import { DEFAULT_SCANNER_CONFIG } from "./fs-types";
 import { scanRoutes } from "./fs-scanner";
 import { loadManduConfig } from "../config";
 import type { ManduPlugin, ManduHooks } from "../plugins/hooks";
-import {
-  runOnRouteRegistered,
-  runOnManifestBuilt,
-} from "../plugins/runner";
-import { shouldPreserveExistingClientModule } from "./client-entry";
+import {
+  runOnRouteRegistered,
+  runOnManifestBuilt,
+} from "../plugins/runner";
+import { shouldPreserveExistingClientModule } from "./client-entry";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Types
@@ -87,16 +87,19 @@ export function fsRouteToRouteSpec(fsRoute: FSRouteConfig): RouteSpec {
       ...base,
       kind: "page" as const,
       componentModule: normalizePath(fsRoute.componentModule ?? ""),
-      ...(fsRoute.clientModule
-        ? {
-            clientModule: normalizePath(fsRoute.clientModule),
-            hydration: fsRoute.hydration ?? {
-              strategy: "island" as const,
-              priority: "immediate" as const,
-              preload: false,
-            },
-          }
-        : {}),
+      ...(fsRoute.clientModule
+        ? {
+            clientModule: normalizePath(fsRoute.clientModule),
+            ...(fsRoute.clientExportName ? { clientExportName: fsRoute.clientExportName } : {}),
+            hydration: fsRoute.hydration ?? {
+              strategy: "island" as const,
+              priority: "immediate" as const,
+              preload: false,
+            },
+          }
+        : fsRoute.hydration
+          ? { hydration: fsRoute.hydration }
+          : {}),
       ...(fsRoute.layoutChain && fsRoute.layoutChain.length > 0
         ? { layoutChain: fsRoute.layoutChain.map(normalizePath) }
         : {}),
@@ -309,20 +312,25 @@ export async function generateManifest(
       for (const route of manifest.routes) {
         const prev = existingMap.get(route.id);
         if (!prev) continue;
-        // 사용자가 설정한 clientModule/hydration 보존.
-        // If app/page.tsx used to be a client page and later becomes a server
-        // page, preserving the old clientModule would leak the server graph into
-        // the browser bundle.
-        if (
-          prev.clientModule &&
-          !route.clientModule &&
-          await shouldPreserveExistingClientModule(route, prev.clientModule, rootDir)
-        ) {
-          route.clientModule = prev.clientModule;
-        }
-        if (prev.hydration && !route.hydration) {
-          route.hydration = prev.hydration;
-        }
+        // 사용자가 설정한 clientModule/hydration 보존.
+        // If app/page.tsx used to be a client page and later becomes a server
+        // page, preserving the old clientModule would leak the server graph into
+        // the browser bundle.
+        if (
+          prev.clientModule &&
+          !route.clientModule &&
+          await shouldPreserveExistingClientModule(route, prev.clientModule, rootDir)
+        ) {
+          route.clientModule = prev.clientModule;
+          route.clientExportName = prev.clientExportName;
+        }
+        if (prev.hydration && !route.hydration) {
+          const canPreserveHydration =
+            !!route.clientModule || prev.hydration.strategy === "none";
+          if (canPreserveHydration) {
+            route.hydration = prev.hydration;
+          }
+        }
         // Issue #214 — preserve prerender-time fields (`dynamicParams`,
         // `staticParams`) across manifest rescans. `mandu build`'s prerender
         // phase stamps these onto the manifest; a subsequent `mandu dev`