@rangojs/router 0.0.0-experimental.259 → 0.0.0-experimental.26

package/src/vite/discovery/bundle-postprocess.ts

@@ -6,9 +6,9 @@
  */
 
 import { resolve } from "node:path";
-import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { evictHandlerCode } from "../utils/bundle-analysis.js";
+import { copyStagedBuildAssets } from "../utils/prerender-utils.js";
 import type { DiscoveryState } from "./state.js";
 
 /**
@@ -17,11 +17,11 @@ import type { DiscoveryState } from "./state.js";
  */
 export function postprocessBundle(state: DiscoveryState): void {
   const hasPrerenderData =
-    state.prerenderCollectedData &&
-    Object.keys(state.prerenderCollectedData).length > 0;
+    state.prerenderManifestEntries &&
+    Object.keys(state.prerenderManifestEntries).length > 0;
   const hasStaticData =
-    state.staticCollectedData &&
-    Object.keys(state.staticCollectedData).length > 0;
+    state.staticManifestEntries &&
+    Object.keys(state.staticManifestEntries).length > 0;
   if (!hasPrerenderData && !hasStaticData) return;
 
   // Find RSC entry (recorded in generateBundle, fallback to dist/rsc/index.js)
@@ -88,36 +88,30 @@ export function postprocessBundle(state: DiscoveryState): void {
   state.staticHandlerChunkInfo = null;
 
   // 2. Write prerender data as separate importable asset modules
-  // and inject a manifest import into the RSC entry.
+  // and inject a lazy manifest loader into the RSC entry.
   if (hasPrerenderData && existsSync(rscEntryPath)) {
     const rscCode = readFileSync(rscEntryPath, "utf-8");
-    if (!rscCode.includes("__PRERENDER_MANIFEST")) {
+    // Check for the specific injection marker to avoid double-injection.
+    if (!rscCode.includes("__prerender-manifest.js")) {
       try {
-        const assetsDir = resolve(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
-
-        const manifestEntries: string[] = [];
-        let totalBytes = 0;
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.prerenderManifestEntries!),
+        );
 
-        for (const [key, entry] of Object.entries(
-          state.prerenderCollectedData!,
+        const manifestMap: Record<string, string> = {};
+        for (const [key, assetFileName] of Object.entries(
+          state.prerenderManifestEntries!,
         )) {
-          const entryJson = JSON.stringify(entry);
-          const contentHash = createHash("sha256")
-            .update(entryJson)
-            .digest("hex")
-            .slice(0, 8);
-          const assetFileName = `__pr-${contentHash}.js`;
-          const assetPath = resolve(assetsDir, assetFileName);
-          const assetCode = `export default ${entryJson};\n`;
-          writeFileSync(assetPath, assetCode);
-          totalBytes += Buffer.byteLength(assetCode);
-          manifestEntries.push(
-            `${JSON.stringify(key)}:()=>import("./assets/${assetFileName}")`,
-          );
+          manifestMap[key] = `./assets/${assetFileName}`;
         }
 
-        const manifestCode = `const m={${manifestEntries.join(",")}};export default m;\n`;
+        const manifestCode = [
+          `const m=JSON.parse('${JSON.stringify(manifestMap).replace(/'/g, "\\'")}');`,
+          `export function loadPrerenderAsset(s){return import(s)}`,
+          `export default m;`,
+          "",
+        ].join("\n");
         const manifestPath = resolve(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js",
@@ -125,12 +119,12 @@ export function postprocessBundle(state: DiscoveryState): void {
         writeFileSync(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
 
-        const injection = `import __pm from "./__prerender-manifest.js";\nglobalThis.__PRERENDER_MANIFEST = __pm;\n`;
+        const injection = `globalThis.__loadPrerenderManifestModule = () => import("./__prerender-manifest.js");\n`;
         writeFileSync(rscEntryPath, injection + rscCode);
 
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
-          `[rsc-router] Wrote prerender assets (${totalKB} KB total, ${Object.keys(state.prerenderCollectedData!).length} entries)`,
+          `[rsc-router] Wrote prerender assets (${totalKB} KB total, ${Object.keys(state.prerenderManifestEntries!).length} entries)`,
         );
       } catch (err: any) {
         throw new Error(
@@ -146,29 +140,15 @@ export function postprocessBundle(state: DiscoveryState): void {
     const rscCode = readFileSync(rscEntryPath, "utf-8");
     if (!rscCode.includes("__STATIC_MANIFEST")) {
       try {
-        const assetsDir = resolve(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
-
         const manifestEntries: string[] = [];
-        let totalBytes = 0;
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.staticManifestEntries!),
+        );
 
-        for (const [handlerId, { encoded, handles }] of Object.entries(
-          state.staticCollectedData!,
+        for (const [handlerId, assetFileName] of Object.entries(
+          state.staticManifestEntries!,
         )) {
-          const contentHash = createHash("sha256")
-            .update(encoded)
-            .digest("hex")
-            .slice(0, 8);
-          const assetFileName = `__st-${contentHash}.js`;
-          const assetPath = resolve(assetsDir, assetFileName);
-          // Store both the Flight payload and handle data
-          const hasHandles = Object.keys(handles).length > 0;
-          const exportValue = hasHandles
-            ? JSON.stringify({ encoded, handles })
-            : JSON.stringify(encoded);
-          const assetCode = `export default ${exportValue};\n`;
-          writeFileSync(assetPath, assetCode);
-          totalBytes += Buffer.byteLength(assetCode);
           manifestEntries.push(
             `${JSON.stringify(handlerId)}:()=>import("./assets/${assetFileName}")`,
           );
@@ -192,7 +172,7 @@ export function postprocessBundle(state: DiscoveryState): void {
 
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
-          `[rsc-router] Wrote static assets (${totalKB} KB total, ${Object.keys(state.staticCollectedData!).length} entries)`,
+          `[rsc-router] Wrote static assets (${totalKB} KB total, ${Object.keys(state.staticManifestEntries!).length} entries)`,
         );
       } catch (err: any) {
         throw new Error(

package/src/vite/discovery/discover-routers.ts

@@ -6,7 +6,11 @@
  * router, and builds route tries for O(path_length) matching.
  */
 
-import { buildCombinedRouteMapForRouterFile } from "../../build/generate-route-types.js";
+import {
+  buildCombinedRouteMapForRouterFile,
+  formatNestedRouterConflictError,
+  findNestedRouterConflict,
+} from "../../build/generate-route-types.js";
 import {
   flattenLeafEntries,
   buildRouteToStaticPrefix,
@@ -44,9 +48,8 @@ export async function discoverRouters(
     // No RSC routers found directly. Check for host routers with lazy handlers
     // that need to be resolved to trigger sub-app createRouter() calls.
     try {
-      const hostMod = await rscEnv.runner.import("@rangojs/router/host");
       const hostRegistry: Map<string, any> | undefined =
-        hostMod.HostRouterRegistry;
+        serverMod.HostRouterRegistry;
 
       if (hostRegistry && hostRegistry.size > 0) {
         console.log(
@@ -85,7 +88,7 @@ export async function discoverRouters(
         }
       }
     } catch {
-      // @rangojs/router/host not available or import failed, skip
+      // Host-router discovery is best-effort; skip if unavailable
     }
 
     // If still no routers after host router resolution, fail
@@ -98,14 +101,28 @@ export async function discoverRouters(
 
   // Import build utilities for manifest generation
   const buildMod = await rscEnv.runner.import("@rangojs/router/build");
-  const generateManifest = buildMod.generateManifest;
-
-  state.mergedRouteManifest = {};
-  state.mergedPrecomputedEntries = [];
-  state.perRouterManifests = [];
-  state.perRouterManifestDataMap = new Map();
-  state.perRouterPrecomputedMap = new Map();
-  state.perRouterTrieMap = new Map();
+  const generateManifestFull = buildMod.generateManifestFull;
+
+  const nestedRouterConflict = findNestedRouterConflict(
+    [...registry.values()]
+      .map((router) => router.__sourceFile)
+      .filter(
+        (sourceFile): sourceFile is string => typeof sourceFile === "string",
+      ),
+  );
+  if (nestedRouterConflict) {
+    throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
+  }
+
+  // Build into local variables first. Only commit to state after the
+  // full pass succeeds, so a failed re-discovery preserves the last
+  // known-good state instead of leaving it partially wiped.
+  const newMergedRouteManifest: Record<string, string> = {};
+  const newMergedPrecomputedEntries: PrecomputedEntry[] = [];
+  const newPerRouterManifests: typeof state.perRouterManifests = [];
+  const newPerRouterManifestDataMap = new Map<string, any>();
+  const newPerRouterPrecomputedMap = new Map<string, PrecomputedEntry[]>();
+  const newPerRouterTrieMap = new Map<string, any>();
   let mergedRouteAncestry: Record<string, string[]> = {};
   let mergedRouteTrailingSlash: Record<string, string> = {};
 
@@ -114,11 +131,11 @@ export async function discoverRouters(
   const allManifests: Array<{ id: string; manifest: any }> = [];
 
   for (const [id, router] of registry) {
-    if (!router.urlpatterns || !generateManifest) {
+    if (!router.urlpatterns || !generateManifestFull) {
       continue;
     }
 
-    const manifest = generateManifest(router.urlpatterns, routerMountIndex);
+    const manifest = generateManifestFull(router.urlpatterns, routerMountIndex);
     routerMountIndex++;
     allManifests.push({ id, manifest });
     const routeCount = Object.keys(manifest.routeManifest).length;
@@ -128,7 +145,7 @@ export async function discoverRouters(
     const dynamicRoutes = routeCount - staticRoutes;
 
     // Merge into the combined manifest
-    Object.assign(state.mergedRouteManifest, manifest.routeManifest);
+    Object.assign(newMergedRouteManifest, manifest.routeManifest);
 
     // Compute factory-only prefixes: dot-prefixed groups in the runtime
     // manifest that the static parser cannot see. These are routes created
@@ -152,7 +169,7 @@ export async function discoverRouters(
       if (factoryOnlyPrefixes.size === 0) factoryOnlyPrefixes = undefined;
     }
 
-    state.perRouterManifests.push({
+    newPerRouterManifests.push({
       id,
       routeManifest: manifest.routeManifest,
       routeSearchSchemas: manifest.routeSearchSchemas,
@@ -175,18 +192,18 @@ export async function discoverRouters(
     flattenLeafEntries(
       manifest.prefixTree,
       manifest.routeManifest,
-      state.mergedPrecomputedEntries,
+      newMergedPrecomputedEntries,
     );
 
     // Store per-router manifest and precomputed entries for isolated virtual modules.
-    state.perRouterManifestDataMap.set(id, manifest.routeManifest);
+    newPerRouterManifestDataMap.set(id, manifest.routeManifest);
     const routerPrecomputed: PrecomputedEntry[] = [];
     flattenLeafEntries(
       manifest.prefixTree,
       manifest.routeManifest,
       routerPrecomputed,
     );
-    state.perRouterPrecomputedMap.set(id, routerPrecomputed);
+    newPerRouterPrecomputedMap.set(id, routerPrecomputed);
 
     console.log(
       `[rsc-router] Router "${id}" -> ${routeCount} routes ` +
@@ -214,10 +231,8 @@ export async function discoverRouters(
   }
 
   // Build route trie from merged manifest + ancestry
-  if (
-    state.mergedRouteManifest &&
-    Object.keys(state.mergedRouteManifest).length > 0
-  ) {
+  let newMergedRouteTrie: any = null;
+  if (Object.keys(newMergedRouteManifest).length > 0) {
     const buildRouteTrie = buildMod.buildRouteTrie;
     if (buildRouteTrie && mergedRouteAncestry) {
       // Build routeToStaticPrefix from saved manifests
@@ -252,8 +267,8 @@ export async function discoverRouters(
         }
       }
 
-      state.mergedRouteTrie = buildRouteTrie(
-        state.mergedRouteManifest,
+      newMergedRouteTrie = buildRouteTrie(
+        newMergedRouteManifest,
         mergedRouteAncestry,
         routeToStaticPrefix,
         Object.keys(mergedRouteTrailingSlash).length > 0
@@ -305,11 +320,22 @@ export async function discoverRouters(
             ? manifest.responseTypeRoutes
             : undefined,
         );
-        state.perRouterTrieMap.set(id, perRouterTrie);
+        newPerRouterTrieMap.set(id, perRouterTrie);
       }
     }
   }
 
+  // Commit all local state to the shared discovery state atomically.
+  // This ensures a failed re-discovery (e.g. from a transient module
+  // evaluation error) preserves the last known-good state.
+  state.mergedRouteManifest = newMergedRouteManifest;
+  state.mergedPrecomputedEntries = newMergedPrecomputedEntries;
+  state.perRouterManifests = newPerRouterManifests;
+  state.perRouterManifestDataMap = newPerRouterManifestDataMap;
+  state.perRouterPrecomputedMap = newPerRouterPrecomputedMap;
+  state.perRouterTrieMap = newPerRouterTrieMap;
+  state.mergedRouteTrie = newMergedRouteTrie;
+
   // Expand prerender routes and render static handlers (build mode only)
   await expandPrerenderRoutes(state, rscEnv, registry, allManifests);
   await renderStaticHandlers(state, rscEnv, registry);

package/src/vite/discovery/prerender-collection.ts

@@ -9,16 +9,18 @@
 import { contextSet } from "../../context-var.js";
 import {
   encodePathParam,
-  escapeRegExp,
+  substituteRouteParams,
   runWithConcurrency,
   groupByConcurrency,
   notifyOnError,
+  stageBuildAssetModule,
 } from "../utils/prerender-utils.js";
 import type { DiscoveryState } from "./state.js";
 
 /**
  * Expand prerender routes into concrete URLs and render them via the
- * RSC runner. Stores collected data in state.prerenderCollectedData.
+ * RSC runner. Stages asset modules and stores key-to-file entries in
+ * state.prerenderManifestEntries.
  */
 export async function expandPrerenderRoutes(
   state: DiscoveryState,
@@ -33,6 +35,7 @@ export async function expandPrerenderRoutes(
     routeName: string;
     concurrency: number;
     buildVars?: Record<string, any>;
+    isPassthroughRoute?: boolean;
   };
   const entries: PrerenderEntry[] = [];
 
@@ -44,19 +47,8 @@ export async function expandPrerenderRoutes(
   const getParamsReverse = (name: string, params?: Record<string, string>) => {
     const pattern = allRoutes[name];
     if (!pattern) throw new Error(`Unknown route: "${name}"`);
-    let result = pattern;
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        // Strip constraint syntax: :param(a|b) -> value
-        const escaped = escapeRegExp(key);
-        result = result.replace(
-          new RegExp(`:${escaped}(\\([^)]*\\))?`),
-          encodeURIComponent(value),
-        );
-        result = result.replace(`*${key}`, encodeURIComponent(value));
-      }
-    }
-    return result;
+    if (!params) return pattern;
+    return substituteRouteParams(pattern, params);
   };
 
   for (const { manifest } of allManifests) {
@@ -65,6 +57,8 @@ export async function expandPrerenderRoutes(
     for (const routeName of manifest.prerenderRoutes) {
       const pattern = manifest.routeManifest[routeName];
       if (!pattern) continue;
+      const def = defs[routeName];
+      const isPassthroughRoute = !!def?.options?.passthrough;
       const hasDynamic = pattern.includes(":") || pattern.includes("*");
       if (!hasDynamic) {
         // Static route: use pattern directly (strip trailing slash for URL)
@@ -72,10 +66,10 @@ export async function expandPrerenderRoutes(
           urlPath: pattern.replace(/\/$/, "") || "/",
           routeName,
           concurrency: 1,
+          isPassthroughRoute,
         });
       } else {
         // Dynamic route: call getParams() to enumerate param combinations
-        const def = defs[routeName];
         if (def?.getParams) {
           try {
             const buildVars: Record<string, any> = {};
@@ -92,19 +86,11 @@ export async function expandPrerenderRoutes(
               Object.keys(buildVars).length > 0 ||
               Object.getOwnPropertySymbols(buildVars).length > 0;
             for (const params of paramsList) {
-              let url = pattern;
-              for (const [key, value] of Object.entries(
+              let url = substituteRouteParams(
+                pattern,
                 params as Record<string, string>,
-              )) {
-                const encoded = encodePathParam(value);
-                // Strip constraint syntax: :param(a|b) -> value
-                const escaped = escapeRegExp(key);
-                url = url.replace(
-                  new RegExp(`:${escaped}(\\([^)]*\\))?`),
-                  encoded,
-                );
-                url = url.replace(`*${key}`, encoded);
-              }
+                encodePathParam,
+              );
               // Anonymous wildcard fallback: use conventional keys if provided
               if (url.includes("*")) {
                 const wildcardValue =
@@ -119,6 +105,7 @@ export async function expandPrerenderRoutes(
                 routeName,
                 concurrency,
                 ...(hasBuildVars ? { buildVars } : {}),
+                isPassthroughRoute,
               });
             }
           } catch (err: any) {
@@ -165,7 +152,7 @@ export async function expandPrerenderRoutes(
 
   const { hashParams } = await rscEnv.runner.import("@rangojs/router/build");
 
-  const collectedData: Record<string, any> = {};
+  const manifestEntries: Record<string, string> = {};
   let doneCount = 0;
   let skipCount = 0;
   const startTotal = performance.now();
@@ -187,21 +174,45 @@ export async function expandPrerenderRoutes(
               entry.urlPath,
               {},
               entry.buildVars,
+              entry.isPassthroughRoute,
             );
             if (!result) continue;
+
+            // Handler returned ctx.passthrough() — skip manifest entry
+            if (result.passthrough) {
+              const elapsed = (performance.now() - startUrl).toFixed(0);
+              console.log(
+                `[rsc-router]   PASS ${entry.urlPath.padEnd(40)} (${elapsed}ms) - live fallback`,
+              );
+              doneCount++;
+              break;
+            }
+
             const paramHash = hashParams(result.params || {});
-            collectedData[`${result.routeName}/${paramHash}`] = {
+            const mainKey = `${result.routeName}/${paramHash}`;
+            const mainValue = JSON.stringify({
               segments: result.segments,
               handles: result.handles,
-            };
+            });
+            manifestEntries[mainKey] = stageBuildAssetModule(
+              state.projectRoot,
+              "__pr",
+              mainValue,
+            );
             if (result.interceptSegments?.length) {
-              collectedData[`${result.routeName}/${paramHash}/i`] = {
+              const interceptKey = `${result.routeName}/${paramHash}/i`;
+              const interceptValue = JSON.stringify({
                 segments: [...result.segments, ...result.interceptSegments],
                 handles: {
                   ...result.handles,
                   ...(result.interceptHandles || {}),
                 },
-              };
+              });
+              manifestEntries[interceptKey] = stageBuildAssetModule(
+                state.projectRoot,
+                "__pr",
+                interceptValue,
+              );
             }
             const elapsed = (performance.now() - startUrl).toFixed(0);
             console.log(
@@ -247,7 +258,7 @@ export async function expandPrerenderRoutes(
 
   const totalElapsed = (performance.now() - startTotal).toFixed(0);
   if (doneCount > 0) {
-    state.prerenderCollectedData = collectedData;
+    state.prerenderManifestEntries = manifestEntries;
   }
   const parts = [`${doneCount} done`];
   if (skipCount > 0) parts.push(`${skipCount} skipped`);
@@ -259,7 +270,8 @@ export async function expandPrerenderRoutes(
 /**
  * Render Static handlers at build time. Each Static handler is called
  * with a synthetic BuildContext and its output is RSC-serialized.
- * Stores collected data in state.staticCollectedData.
+ * Stages asset modules and stores handlerId-to-file entries in
+ * state.staticManifestEntries.
  */
 export async function renderStaticHandlers(
   state: DiscoveryState,
@@ -273,10 +285,7 @@ export async function renderStaticHandlers(
   )
     return;
 
-  const collected: Record<
-    string,
-    { encoded: string; handles: Record<string, unknown[]> }
-  > = {};
+  const manifestEntries: Record<string, string> = {};
   let staticDone = 0;
   let staticSkip = 0;
   let totalStaticCount = 0;
@@ -319,7 +328,15 @@ export async function renderStaticHandlers(
             (def as any).$$routePrefix,
           );
           if (result) {
-            collected[def.$$id] = result;
+            const hasHandles = Object.keys(result.handles).length > 0;
+            const exportValue = hasHandles
+              ? JSON.stringify(result)
+              : JSON.stringify(result.encoded);
+            manifestEntries[def.$$id] = stageBuildAssetModule(
+              state.projectRoot,
+              "__st",
+              exportValue,
+            );
             const elapsed = (performance.now() - startHandler).toFixed(0);
             console.log(
               `[rsc-router]   OK   ${name.padEnd(40)} (${elapsed}ms)`,
@@ -358,7 +375,7 @@ export async function renderStaticHandlers(
 
   const totalStaticElapsed = (performance.now() - startStatic).toFixed(0);
   if (staticDone > 0) {
-    state.staticCollectedData = collected;
+    state.staticManifestEntries = manifestEntries;
   }
   const staticParts = [`${staticDone} done`];
   if (staticSkip > 0) staticParts.push(`${staticSkip} skipped`);

package/src/vite/discovery/route-types-writer.ts

@@ -15,20 +15,20 @@ import {
 } from "../../build/generate-route-types.js";
 import type { DiscoveryState } from "./state.js";
 import { markSelfGenWrite } from "./self-gen-tracking.js";
+import { isAutoGeneratedRouteName } from "../../route-name.js";
 
 /**
  * Filter out auto-generated route names from a manifest.
- * Routes with names starting with "$" are internal (auto-generated from
- * patterns for unnamed routes) and should not appear in the typed gen file.
- * This keeps the runtime writer's output consistent with the static parser,
- * which never produces these names.
+ * Unnamed routes get "$path_"-prefixed names at runtime (see path-helper.ts).
+ * These should not appear in the typed gen file. User-defined names
+ * containing "$" (e.g. "$admin") are valid and preserved.
  */
 function filterUserNamedRoutes(
   manifest: Record<string, string>,
 ): Record<string, string> {
   const filtered: Record<string, string> = {};
   for (const [name, pattern] of Object.entries(manifest)) {
-    if (!name.startsWith("$")) {
+    if (!isAutoGeneratedRouteName(name)) {
       filtered[name] = pattern;
     }
   }
@@ -222,8 +222,8 @@ export function supplementGenFilesWithRuntimeRoutes(
     };
 
     for (const [name, pattern] of Object.entries(routeManifest)) {
-      // Skip auto-generated names
-      if (name.startsWith("$")) continue;
+      // Skip internal runtime-only names from unnamed routes/includes.
+      if (isAutoGeneratedRouteName(name)) continue;
       const dotIdx = name.indexOf(".");
       if (dotIdx <= 0) continue;
       const prefix = name.substring(0, dotIdx + 1);

package/src/vite/discovery/state.ts

@@ -15,6 +15,9 @@ export interface PluginOptions {
   staticRouteTypesGeneration?: boolean;
   include?: string[];
   exclude?: string[];
+  // Mutable ref for deferred auto-discovery (node preset).
+  // The auto-discover config() hook populates this before configResolved.
+  routerPathRef?: { path?: string };
 }
 
 export interface PrecomputedEntry {
@@ -53,11 +56,8 @@ export interface DiscoveryState {
   perRouterPrecomputedMap: Map<string, PrecomputedEntry[]>;
   perRouterManifestDataMap: Map<string, Record<string, string>>;
 
-  prerenderCollectedData: Record<string, any> | null;
-  staticCollectedData: Record<
-    string,
-    { encoded: string; handles: Record<string, unknown[]> }
-  > | null;
+  prerenderManifestEntries: Record<string, string> | null;
+  staticManifestEntries: Record<string, string> | null;
   handlerChunkInfo: ChunkInfo | null;
   staticHandlerChunkInfo: ChunkInfo | null;
   rscEntryFileName: string | null;
@@ -93,8 +93,8 @@ export function createDiscoveryState(
     perRouterPrecomputedMap: new Map(),
     perRouterManifestDataMap: new Map(),
 
-    prerenderCollectedData: null,
-    staticCollectedData: null,
+    prerenderManifestEntries: null,
+    staticManifestEntries: null,
     handlerChunkInfo: null,
     staticHandlerChunkInfo: null,
     rscEntryFileName: null,

package/src/vite/discovery/virtual-module-codegen.ts

@@ -42,7 +42,7 @@ export function generateRoutesManifestModule(state: DiscoveryState): string {
         const genPath = join(
           routerDir,
           `${routerBasename}.named-routes.gen.js`,
-        );
+        ).replaceAll("\\", "/");
         const varName = `_r${varIdx++}`;
         genFileImports.push(
           `import { NamedRoutes as ${varName} } from ${JSON.stringify(genPath)};`,
@@ -176,7 +176,10 @@ export function generatePerRouterModule(
       /\.(tsx?|jsx?)$/,
       "",
     );
-    const genPath = join(routerDir, `${routerBasename}.named-routes.gen.js`);
+    const genPath = join(
+      routerDir,
+      `${routerBasename}.named-routes.gen.js`,
+    ).replaceAll("\\", "/");
     lines.push(`import { NamedRoutes as _r } from ${JSON.stringify(genPath)};`);
     lines.push(
       `function __flat(r) { const o = {}; for (const [k, v] of Object.entries(r)) o[k] = typeof v === "string" ? v : v.path; return o; }`,