@rangojs/router 0.0.0-experimental.9eb4192e → 0.0.0-experimental.a014d2b7

package/src/vite/plugins/version-plugin.ts

@@ -1,5 +1,6 @@
 import { parseAst, type Plugin } from "vite";
 import { VIRTUAL_IDS, getVirtualVersionContent } from "./virtual-entries.js";
+import { hasUseClientDirective } from "../utils/directive-prologue.js";
 
 interface ClientModuleSignature {
   key: string;
@@ -16,30 +17,17 @@ function normalizeModuleId(id: string): string {
 function getClientModuleSignature(
   source: string,
 ): ClientModuleSignature | undefined {
+  // Same leading-directive sniff the rango HMR plugin uses (shared helper, so the
+  // two agree on what counts as a client module). A parse failure yields false.
+  if (!hasUseClientDirective(source)) return undefined;
+
   let program: any;
   try {
-    program = parseAst(source, { jsx: true });
+    program = parseAst(source, { lang: "tsx" });
   } catch {
     return undefined;
   }
 
-  let isUseClient = false;
-  for (const node of program.body ?? []) {
-    if (
-      node?.type === "ExpressionStatement" &&
-      node.expression?.type === "Literal" &&
-      typeof node.expression.value === "string"
-    ) {
-      if (node.expression.value === "use client") {
-        isUseClient = true;
-      }
-      continue;
-    }
-    break;
-  }
-
-  if (!isUseClient) return undefined;
-
   const exports = new Set<string>();
   let hasDefault = false;
   let hasExportAll = false;
@@ -133,14 +121,13 @@ export function createVersionPlugin(): Plugin {
   let currentVersion = buildVersion;
   let isDev = false;
   let server: any = null;
+  let resolvedCacheDir: string | undefined;
   const clientModuleSignatures = new Map<string, ClientModuleSignature>();
 
   let versionCounter = 0;
   const bumpVersion = (reason: string) => {
-    // Use timestamp + counter to guarantee uniqueness even when multiple
-    // bumps happen within the same millisecond (e.g. cascading HMR events).
     currentVersion = Date.now().toString(16) + String(++versionCounter);
-    console.log(`[rsc-router] ${reason}, version updated: ${currentVersion}`);
+    console.log(`[rango] ${reason}, version updated: ${currentVersion}`);
 
     const rscEnv = server?.environments?.rsc;
     const versionMod = rscEnv?.moduleGraph?.getModuleById(
@@ -157,6 +144,9 @@ export function createVersionPlugin(): Plugin {
 
     configResolved(config) {
       isDev = config.command === "serve";
+      resolvedCacheDir = config.cacheDir
+        ? String(config.cacheDir).replace(/\\/g, "/")
+        : undefined;
     },
 
     configureServer(devServer) {
@@ -203,19 +193,15 @@ export function createVersionPlugin(): Plugin {
       return null;
     },
 
-    // Track RSC module changes and update version
     async hotUpdate(ctx) {
       if (!isDev) return;
 
-      // Check if this is an RSC environment update (not client/ssr)
-      // RSC modules affect server-rendered content and cached payloads
-      // In Vite 6, environment is accessed via `this.environment`
       const isRscModule = this.environment?.name === "rsc";
 
       if (!isRscModule) return;
 
-      // Skip re-bumping when the version virtual module itself is invalidated
-      // (our own bumpVersion() invalidates it, which re-triggers hotUpdate).
+      if (isViteDepCachePath(ctx.file, resolvedCacheDir)) return;
+
       if (
         ctx.modules.length === 1 &&
         ctx.modules[0].id === "\0" + VIRTUAL_IDS.version
@@ -230,9 +216,6 @@ export function createVersionPlugin(): Plugin {
           const source = await ctx.read();
           const nextSignature = getClientModuleSignature(source);
           if (nextSignature) {
-            // "use client" file — compare export signatures.
-            // client-component-hmr may have cleared ctx.modules, so we
-            // cannot rely on ctx.modules.length for these files.
             clientModuleSignatures.set(filePath, nextSignature);
             if (
               previousSignature &&
@@ -243,20 +226,11 @@ export function createVersionPlugin(): Plugin {
           } else {
             clientModuleSignatures.delete(filePath);
             if (!previousSignature) {
-              // Not and never was "use client" — use module graph check.
-              // ctx.modules is reliable for pure server files (only
-              // client-component-hmr clears it for "use client" modules).
               if (ctx.modules.length === 0) return;
             }
-            // Was "use client" but directive removed — boundary changed,
-            // bump below.
           }
-        } catch {
-          // Fail open: if we can't read or parse the update, invalidate.
-        }
+        } catch {}
       } else {
-        // Non-code file (json, css, etc.) — only bump if it's actually
-        // referenced by the RSC module graph.
         if (ctx.modules.length === 0) return;
       }
 
@@ -264,3 +238,26 @@ export function createVersionPlugin(): Plugin {
     },
   };
 }
+
+export function isViteDepCachePath(
+  filePath: string | undefined,
+  cacheDir?: string,
+): boolean {
+  if (!filePath) return false;
+  const normalized = filePath.replace(/\\/g, "/");
+
+  if (cacheDir) {
+    const normalizedCacheDir = cacheDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (
+      normalized === normalizedCacheDir ||
+      normalized.startsWith(normalizedCacheDir + "/")
+    ) {
+      return true;
+    }
+  }
+
+  return (
+    /\/node_modules\/\.vite[^/]*\//.test(normalized) ||
+    normalized.includes("/.vite-isolated/")
+  );
+}

package/src/vite/plugins/virtual-entries.ts

@@ -1,8 +1,3 @@
-/**
- * Default virtual entry file contents for rsc-router.
- * These are used when users don't provide their own entry files.
- */
-
 export const VIRTUAL_ENTRY_BROWSER: string = `
 import {
   createFromReadableStream,
@@ -14,7 +9,7 @@ import {
 import { createElement, StrictMode } from "react";
 import { hydrateRoot } from "react-dom/client";
 import { rscStream } from "@rangojs/router/internal/deps/html-stream-client";
-import { initBrowserApp, RSCRouter } from "@rangojs/router/browser";
+import { initBrowserApp, Rango } from "@rangojs/router/browser";
 
 async function initializeApp() {
   const deps = {
@@ -25,11 +20,16 @@ async function initializeApp() {
     createTemporaryReferenceSet,
   };
 
-  await initBrowserApp({ rscStream, deps });
+  // initBrowserApp resolves the initial payload and returns the browser app
+  // context, including strictMode (default true) from createRouter. StrictMode
+  // is the default; createRouter({ strictMode: false }) ships the opt-out in the
+  // payload metadata. StrictMode emits no DOM, so toggling never changes markup.
+  const { strictMode } = await initBrowserApp({ rscStream, deps });
 
+  const app = createElement(Rango);
   hydrateRoot(
     document,
-    createElement(StrictMode, null, createElement(RSCRouter))
+    strictMode === false ? app : createElement(StrictMode, null, app)
   );
 }
 
@@ -52,9 +52,31 @@ export const renderHTML = createSSRHandler({
 `.trim();
 
 /**
- * Generate the RSC entry content with the specified router path
+ * Virtual modules an RSC entry must import at startup to register the data the
+ * request handler needs before the first request arrives:
+ *
+ * - routes-manifest: the pre-generated route map so href()/matching work on a
+ *   cold start (full map in build, in-memory no-op in dev).
+ * - loader-manifest: setLoaderImports() for fetchable loaders. Critical for
+ *   serverless/multi-process deployments and for fetchable loaders reachable
+ *   only through a client component — without it those loaders are never
+ *   registered for the _rsc_loader endpoint and fail in production.
+ *
+ * Single source of truth: both the generated virtual RSC entry below and the
+ * custom-entry injector (version-injector) consume this list, so a new
+ * bootstrap manifest cannot be added to one path and forgotten on the other.
+ * That exact drift (loader-manifest present here but missing from the injector)
+ * is what left fetchable loaders unresolved on custom worker entries.
  */
+export const RSC_ENTRY_BOOTSTRAP_IMPORTS: readonly string[] = [
+  "virtual:rsc-router/routes-manifest",
+  "virtual:rsc-router/loader-manifest",
+];
+
 export function getVirtualEntryRSC(routerPath: string): string {
+  const bootstrapImports = RSC_ENTRY_BOOTSTRAP_IMPORTS.map(
+    (id) => `import "${id}";`,
+  ).join("\n");
   return `
 import {
   renderToReadableStream,
@@ -68,15 +90,9 @@ import { router } from "${routerPath}";
 import { createRSCHandler } from "@rangojs/router/internal/rsc-handler";
 import { VERSION } from "@rangojs/router:version";
 
-// Import loader manifest to ensure all fetchable loaders are registered at startup
-// This is critical for serverless/multi-process deployments where the loader module
-// might not be imported before a GET request arrives
-import "virtual:rsc-router/loader-manifest";
-
-// Import pre-generated route manifest so href() works immediately on cold start.
-// In build mode, this contains the full route map generated at build time.
-// In dev mode, this is a no-op (manifest is populated in-memory by the discovery plugin).
-import "virtual:rsc-router/routes-manifest";
+// Startup bootstrap imports (routes + loader manifests). See
+// RSC_ENTRY_BOOTSTRAP_IMPORTS — the same list the custom-entry injector uses.
+${bootstrapImports}
 
 // Lazily create the handler on first request so that ESM live bindings
 // have resolved by the time we read \`router\`. During HMR the module may
@@ -87,6 +103,11 @@ export default function handler(request, env) {
     _handler = createRSCHandler({
       router,
       version: VERSION,
+      // Forward the router's CSP nonce provider. createRSCHandler reads the
+      // provider only from options.nonce; without this, createRouter({ nonce })
+      // is silently dropped on the Node preset (the Cloudflare path wires it via
+      // router.fetch). router.nonce is undefined when unconfigured, a safe no-op.
+      nonce: router.nonce,
       deps: {
         renderToReadableStream,
         decodeReply,
@@ -104,9 +125,6 @@ export default function handler(request, env) {
 `.trim();
 }
 
-/**
- * Virtual module IDs
- */
 export const VIRTUAL_IDS = {
   browser: "virtual:rsc-router/entry.browser.js",
   ssr: "virtual:rsc-router/entry.ssr.js",
@@ -114,10 +132,6 @@ export const VIRTUAL_IDS = {
   version: "@rangojs/router:version",
 } as const;
 
-/**
- * Virtual module content for version.
- * Exports VERSION - a timestamp that changes on server restart (dev) or at build time (production).
- */
 export function getVirtualVersionContent(version: string): string {
   return `export const VERSION = ${JSON.stringify(version)};`;
 }

package/src/vite/rango.ts

@@ -1,4 +1,4 @@
-import type { PluginOption } from "vite";
+import { type PluginOption } from "vite";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { exposeActionId } from "./plugins/expose-action-id.js";
@@ -18,20 +18,31 @@ import {
 import { findRouterFiles } from "../build/generate-route-types.js";
 import { createVersionPlugin } from "./plugins/version-plugin.js";
 import {
-  sharedEsbuildOptions,
+  sharedRolldownOptions,
   createVirtualEntriesPlugin,
   onwarn,
   getManualChunks,
 } from "./utils/shared-utils.js";
+import {
+  resolveClientChunks,
+  type ClientChunkContext,
+} from "./utils/client-chunks.js";
 import type { RangoOptions } from "./plugin-types.js";
 import { printBanner, rangoVersion } from "./utils/banner.js";
 import { createVersionInjectorPlugin } from "./plugins/version-injector.js";
 import { createCjsToEsmPlugin } from "./plugins/cjs-to-esm.js";
 import { createRouterDiscoveryPlugin } from "./router-discovery.js";
 import { performanceTracksPlugin } from "./plugins/performance-tracks.js";
-import { createRangoDebugger } from "./debug.js";
+import { createRangoDebugger, NS } from "./debug.js";
+
+const debugConfig = createRangoDebugger(NS.config);
 
-const debugConfig = createRangoDebugger("rango:config");
+// The leading-directive 'use client' sniff is shared with version-plugin's
+// getClientModuleSignature so the two cannot drift. Imported for local use by the
+// HMR transform below and re-exported because the E8 sniff test imports it from
+// this module.
+import { hasUseClientDirective } from "./utils/directive-prologue.js";
+export { hasUseClientDirective };
 
 /**
  * Vite plugin for @rangojs/router.
@@ -62,6 +73,12 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
   const resolvedOptions: RangoOptions = options ?? { preset: "node" };
   const preset = resolvedOptions.preset ?? "node";
   const showBanner = resolvedOptions.banner ?? true;
+  const clientChunksOption = resolvedOptions.clientChunks ?? true;
+  const useBuiltInClientChunks = clientChunksOption === true;
+  const clientChunkCtx: ClientChunkContext | undefined = useBuiltInClientChunks
+    ? { fallbackRefs: new Set<string>() }
+    : undefined;
+  const clientChunks = resolveClientChunks(clientChunksOption, clientChunkCtx);
   debugConfig?.("rango(%s) setup start", preset);
 
   const plugins: PluginOption[] = [];
@@ -103,14 +120,8 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
   const prerenderEnabled = true;
 
   if (preset === "cloudflare") {
-    // Cloudflare preset: configure entries for cloudflare worker setup
-    // Router is not needed here - worker.rsc.tsx imports it directly
-
-    // Dynamically import @vitejs/plugin-rsc
     const { default: rsc } = await import("@vitejs/plugin-rsc");
 
-    // Only client and ssr entries - rsc entry is handled by cloudflare plugin
-    // Always use virtual modules for cloudflare preset
     const finalEntries: { client: string; ssr: string } = {
       client: VIRTUAL_IDS.browser,
       ssr: VIRTUAL_IDS.ssr,
@@ -121,16 +132,21 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
       enforce: "pre",
 
       config() {
-        // Configure environments for cloudflare deployment
         return {
-          // Exclude rsc-router modules from optimization to prevent module duplication
-          // This ensures the same Context instance is used by both browser entry and RSC proxy modules
           optimizeDeps: {
             exclude: excludeDeps,
-            esbuildOptions: sharedEsbuildOptions,
+            rolldownOptions: sharedRolldownOptions,
           },
           resolve: {
             alias: rangoAliases,
+            // Force a single React/React-DOM copy across all three RSC
+            // environments. RSC requires exactly one react/react-dom instance
+            // per environment runtime; consumer install topologies (pnpm
+            // strict layout, experimental React pins, third-party "use client"
+            // packages) can otherwise resolve duplicate copies, causing
+            // "Invalid hook call" / lost context. Child environments inherit
+            // this root dedupe, and Vite merges it with any consumer dedupe.
+            dedupe: ["react", "react-dom"],
           },
           build: {
             rollupOptions: { onwarn },
@@ -139,30 +155,22 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
             client: {
               build: {
                 rollupOptions: {
+                  onwarn,
                   output: {
                     manualChunks: getManualChunks,
                   },
                 },
               },
-              // Pre-bundle rsc-html-stream to prevent discovery during first request
-              // Exclude rsc-router modules to ensure same Context instance
               optimizeDeps: {
                 include: [nested("rsc-html-stream/client")],
                 exclude: excludeDeps,
-                esbuildOptions: sharedEsbuildOptions,
+                rolldownOptions: sharedRolldownOptions,
               },
             },
             ssr: {
-              // Build SSR inside RSC directory so wrangler can deploy self-contained dist/rsc
               build: {
                 outDir: "./dist/rsc/ssr",
               },
-              resolve: {
-                // Ensure single React instance in SSR child environment
-                dedupe: ["react", "react-dom"],
-              },
-              // Pre-bundle SSR entry and React for proper module linking with childEnvironments
-              // All deps must be listed to avoid late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
               optimizeDeps: {
                 entries: [finalEntries.ssr],
                 include: [
@@ -178,14 +186,11 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                   ),
                 ],
                 exclude: excludeDeps,
-                esbuildOptions: sharedEsbuildOptions,
+                rolldownOptions: sharedRolldownOptions,
               },
             },
             rsc: {
-              // RSC environment needs exclude list and esbuild options
-              // Exclude rsc-router modules to prevent createContext in RSC environment
               optimizeDeps: {
-                // Pre-bundle all RSC deps to prevent late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
                 include: [
                   "react",
                   "react/jsx-runtime",
@@ -195,7 +200,7 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                   ),
                 ],
                 exclude: excludeDeps,
-                esbuildOptions: sharedEsbuildOptions,
+                rolldownOptions: sharedRolldownOptions,
               },
             },
           },
@@ -216,26 +221,16 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
     });
 
     plugins.push(createVirtualEntriesPlugin(finalEntries));
-
-    // Dev-only: RSDW client patch for React Performance Tracks
     plugins.push(performanceTracksPlugin());
-
-    // Add RSC plugin with cloudflare-specific options
-    // Note: loadModuleDevProxy should NOT be used with childEnvironments
-    // since SSR runs in workerd alongside RSC
     plugins.push(
       rsc({
         entries: finalEntries,
         serverHandler: false,
+        clientChunks,
       }) as PluginOption,
     );
-
-    // Deduplicate client references from third-party packages in dev mode.
-    // Prevents module duplication when server components import "use client"
-    // packages that are also imported directly by client components.
     plugins.push(clientRefDedup());
   } else {
-    // Auto-discover router using Vite's resolved root (not process.cwd())
     plugins.push({
       name: "@rangojs/router:auto-discover",
       config(userConfig) {
@@ -256,20 +251,17 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                 "  - " + (f.startsWith(root) ? f.slice(root.length + 1) : f),
             )
             .join("\n");
-          throw new Error(`[rsc-router] Multiple routers found:\n${list}`);
+          throw new Error(`[rango] Multiple routers found:\n${list}`);
         }
-        // 0 found: routerRef.path stays undefined, warn at startup via discovery plugin
       },
     });
 
-    // Always use virtual entries for client, ssr, and rsc
     const finalEntries = {
       client: VIRTUAL_IDS.browser,
       ssr: VIRTUAL_IDS.ssr,
       rsc: VIRTUAL_IDS.rsc,
     };
 
-    // Dynamically import @vitejs/plugin-rsc
     const { default: rsc } = await import("@vitejs/plugin-rsc");
 
     let hasWarnedDuplicate = false;
@@ -282,18 +274,27 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
         return {
           optimizeDeps: {
             exclude: excludeDeps,
-            esbuildOptions: sharedEsbuildOptions,
+            rolldownOptions: sharedRolldownOptions,
           },
           build: {
             rollupOptions: { onwarn },
           },
           resolve: {
             alias: rangoAliases,
+            // Force a single React/React-DOM copy across all three RSC
+            // environments. RSC requires exactly one react/react-dom instance
+            // per environment runtime; consumer install topologies (pnpm
+            // strict layout, experimental React pins, third-party "use client"
+            // packages) can otherwise resolve duplicate copies, causing
+            // "Invalid hook call" / lost context. Child environments inherit
+            // this root dedupe, and Vite merges it with any consumer dedupe.
+            dedupe: ["react", "react-dom"],
           },
           environments: {
             client: {
               build: {
                 rollupOptions: {
+                  onwarn,
                   output: {
                     manualChunks: getManualChunks,
                   },
@@ -308,7 +309,7 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                   nested("rsc-html-stream/client"),
                 ],
                 exclude: excludeDeps,
-                esbuildOptions: sharedEsbuildOptions,
+                rolldownOptions: sharedRolldownOptions,
                 entries: [VIRTUAL_IDS.browser],
               },
             },
@@ -327,7 +328,7 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                   ),
                 ],
                 exclude: excludeDeps,
-                esbuildOptions: sharedEsbuildOptions,
+                rolldownOptions: sharedRolldownOptions,
               },
             },
             rsc: {
@@ -341,7 +342,13 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                     "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
                   ),
                 ],
-                esbuildOptions: sharedEsbuildOptions,
+                // Vite 8 does not propagate the top-level optimizeDeps.exclude
+                // (set in config()) to non-client envs, so the rsc env must set
+                // it explicitly — mirroring the node ssr env and the cloudflare
+                // rsc env. Without it a strict-pnpm npm-installed app can try to
+                // pre-bundle the router's own subpath entries and fail.
+                exclude: excludeDeps,
+                rolldownOptions: sharedRolldownOptions,
               },
             },
           },
@@ -366,42 +373,24 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
         if (rscMinimalCount > 1 && !hasWarnedDuplicate) {
           hasWarnedDuplicate = true;
           console.warn(
-            "[rsc-router] Duplicate @vitejs/plugin-rsc detected. " +
+            "[rango] Duplicate @vitejs/plugin-rsc detected. " +
               "Remove rsc() from your vite config — rango() includes it automatically.",
           );
         }
       },
     });
 
-    // Add virtual entries plugin (RSC entry generated lazily from routerRef)
     plugins.push(createVirtualEntriesPlugin(finalEntries, routerRef));
-
-    // Dev-only: RSDW client patch for React Performance Tracks
     plugins.push(performanceTracksPlugin());
-
     plugins.push(
       rsc({
         entries: finalEntries,
+        clientChunks,
       }) as PluginOption,
     );
-
-    // Deduplicate client references from third-party packages in dev mode.
-    // Prevents module duplication when server components import "use client"
-    // packages that are also imported directly by client components.
     plugins.push(clientRefDedup());
   }
 
-  // Fix HMR for "use client" components.
-  //
-  // @vitejs/plugin-rsc's hotUpdate returns undefined for "use client" files
-  // in the RSC environment. Vite then tries to propagate through the RSC
-  // module graph, but the proxy module has no import.meta.hot.accept()
-  // boundary, causing a full page reload. The client env would handle it
-  // fine via React Refresh, but the RSC env's full-reload arrives first.
-  //
-  // Fix: in the RSC env, return [] for "use client" files to signal
-  // "handled, nothing to propagate". The client env is left alone so
-  // React Refresh processes the update normally.
   plugins.push({
     name: "@rangojs/router:client-component-hmr",
     hotUpdate(ctx) {
@@ -420,70 +409,37 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
 
       try {
         const source = readFileSync(file, "utf-8");
-        const trimmed = source.trimStart();
-        if (
-          trimmed.startsWith('"use client"') ||
-          trimmed.startsWith("'use client'")
-        ) {
-          // Consume the update in RSC/SSR envs. The proxy module was already
-          // re-transformed by the RSC plugin's hotUpdate. Without this, Vite
-          // tries to propagate through the RSC/SSR module graph where the proxy
-          // has no import.meta.hot.accept() boundary, triggering a full reload.
-          // The actual component update is handled by React Refresh in the
-          // client environment.
+        if (hasUseClientDirective(source)) {
           return [];
         }
-      } catch {
-        // File deleted/moved during HMR, let default handling proceed
-      }
+      } catch {}
     },
   });
 
   plugins.push(exposeActionId());
-
-  // "use cache" directive transform (enforce: "post"):
-  // Wraps exports with registerCachedFunction() for function-level caching.
   plugins.push(useCacheTransform());
-
-  // Consolidated plugin for create* ID injection (enforce: "post"):
-  // loaders, handles, location state, and prerender handlers.
   plugins.push(exposeInternalIds());
-
-  // Router ID injection runs at normal priority (no enforce) to avoid
-  // changing Vite's dep optimization timing.
   plugins.push(exposeRouterId());
-
-  // Add version virtual module plugin for cache invalidation
   plugins.push(createVersionPlugin());
 
-  // Entry path for discovery: user-specified value (if any) or undefined.
-  // Auto-discovered path is passed separately via routerRef.
-  // Cloudflare preset: deferred to configResolved (read from resolved Vite env config).
   const discoveryEntryPath =
     preset !== "cloudflare" ? routerRef.path : undefined;
-  // Ref for deferred auto-discovery (node preset only, undefined for cloudflare)
   const discoveryRouterRef = preset !== "cloudflare" ? routerRef : undefined;
 
-  // Version injector: auto-injects VERSION and routes-manifest into the RSC entry.
-  // For cloudflare preset, the entry is resolved lazily in configResolved.
-  // For node preset, the virtual entry already includes these imports.
   if (preset === "cloudflare") {
     plugins.push(createVersionInjectorPlugin(undefined));
   }
 
-  // Transform CJS vendor files to ESM for browser compatibility
-  // optimizeDeps.include doesn't work because the file is loaded after initial optimization
   plugins.push(createCjsToEsmPlugin());
-
-  // Router discovery plugin for build-time manifest generation.
-  // For cloudflare, the entry is resolved lazily in configResolved from the RSC environment.
-  // For node, discoveryRouterRef provides the auto-discovered path when not user-specified.
   plugins.push(
     createRouterDiscoveryPlugin(discoveryEntryPath, {
       routerPathRef: discoveryRouterRef,
       enableBuildPrerender: prerenderEnabled,
       buildEnv: options?.buildEnv,
       preset,
+      prerenderOnError: options?.prerender?.onError,
+      discovery: options?.discovery,
+      clientChunkCtx,
     }),
   );