@rangojs/router 0.0.0-experimental.e9c0b2f2 → 0.0.0-experimental.ea9f40f2

package/dist/vite/index.js

@@ -1,6 +1,6 @@
 // src/vite/rango.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
 
 // src/vite/plugins/expose-action-id.ts
 import MagicString from "magic-string";
@@ -2212,9 +2212,14 @@ initializeApp().catch(console.error);
 `.trim();
 var VIRTUAL_ENTRY_SSR = `
 import { createFromReadableStream } from "@rangojs/router/internal/deps/ssr";
-import { renderToReadableStream } from "react-dom/server.edge";
+import { renderToReadableStream, resume } from "react-dom/server.edge";
+import { prerender } from "react-dom/static.edge";
 import { injectRSCPayload } from "@rangojs/router/internal/deps/html-stream-server";
-import { createSSRHandler } from "@rangojs/router/ssr";
+import {
+  createSSRHandler,
+  createShellCaptureHandler,
+  createShellResumeHandler,
+} from "@rangojs/router/ssr";
 
 export const renderHTML = createSSRHandler({
   createFromReadableStream,
@@ -2223,8 +2228,35 @@ export const renderHTML = createSSRHandler({
   loadBootstrapScriptContent: () =>
     import.meta.viteRsc.loadBootstrapScriptContent("index"),
 });
+
+export const captureShellHTML = createShellCaptureHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  prerender,
+  resume,
+  loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+});
+
+export const resumeShellHTML = createShellResumeHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  prerender,
+  resume,
+  loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+});
 `.trim();
+var RSC_ENTRY_BOOTSTRAP_IMPORTS = [
+  "virtual:rsc-router/routes-manifest",
+  "virtual:rsc-router/loader-manifest"
+];
 function getVirtualEntryRSC(routerPath) {
+  const bootstrapImports = RSC_ENTRY_BOOTSTRAP_IMPORTS.map(
+    (id) => `import "${id}";`
+  ).join("\n");
   return `
 import {
   renderToReadableStream,
@@ -2238,15 +2270,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 \u2014 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
@@ -2281,7 +2307,7 @@ export default function handler(request, env) {
 function getVirtualEntryRSCHost(hostEntryPath) {
   return `
 import * as __hostEntry from "${hostEntryPath}";
-import { NoRouteMatchError } from "@rangojs/router/host";
+import { isNoRouteMatchError } from "@rangojs/router/host";
 
 // Register every sub-app's fetchable loaders + route manifests at startup, same
 // as the single-router entry. Discovery's host fallback populates these for all
@@ -2291,11 +2317,12 @@ import "virtual:rsc-router/routes-manifest";
 
 // The host entry module must export the HostRouter instance (createHostRouter()),
 // as a default export or a named \`hostRouter\`/\`router\` export. A Cloudflare-style
-// \`export default { fetch }\` object is not a HostRouter and is rejected here.
+// \`export default { fetch }\` object is not a HostRouter and is rejected (on first
+// request; see the lazy resolution below).
 // We require BOTH .match() and .host(): a regular createRouter() also exposes
 // .match(), so matching on .match() alone would accept an ordinary router and then
 // return its MatchResult (not a Response) at runtime. .host() is unique to a
-// HostRouter, so it disambiguates a mistaken \`hostRouter\` path at build time.
+// HostRouter, so it disambiguates a mistaken \`hostRouter\` path.
 // Exports are read dynamically (m[name]) so Rollup does not emit IMPORT_IS_UNDEFINED
 // warnings for the named exports a default-only host module legitimately omits.
 const __resolveHostRouter = (m) => {
@@ -2310,13 +2337,14 @@ const __resolveHostRouter = (m) => {
   }
   return undefined;
 };
-const hostRouter = __resolveHostRouter(__hostEntry);
 
-if (!hostRouter) {
-  throw new Error(
-    "[rango] The host entry (${hostEntryPath}) must export a HostRouter instance (createHostRouter()) for the node/vercel preset: a default export, or a named 'hostRouter'/'router' export. An ordinary createRouter() is not a host router (it has no .host()), and a Cloudflare-style 'export default { fetch }' object is not supported on this preset."
-  );
-}
+// Resolve + validate the HostRouter lazily on first request, mirroring the
+// single-router entry's \`_handler\`. During HMR the host module can re-evaluate
+// before its createHostRouter() export has resolved; validating at module-
+// evaluation time would then throw a spurious "must export a HostRouter" error
+// overlay for a perfectly valid app. Resolving on first request lets the live
+// binding settle first.
+let _hostRouter;
 
 // input = { env, ctx } from the launcher / node server. The host router threads
 // it unchanged to each matched sub-app's handler and cache factory.
@@ -2324,10 +2352,22 @@ if (!hostRouter) {
 // an unmatched host into a response: catch NoRouteMatchError and return 404
 // (parity with the documented Cloudflare catch). Other errors propagate.
 export default async function handler(request, input) {
+  if (!_hostRouter) {
+    _hostRouter = __resolveHostRouter(__hostEntry);
+    if (!_hostRouter) {
+      throw new Error(
+        "[rango] The host entry (${hostEntryPath}) must export a HostRouter instance (createHostRouter()) for the node/vercel preset: a default export, or a named 'hostRouter'/'router' export. An ordinary createRouter() is not a host router (it has no .host()), and a Cloudflare-style 'export default { fetch }' object is not supported on this preset."
+      );
+    }
+  }
   try {
-    return await hostRouter.match(request, input);
+    return await _hostRouter.match(request, input);
   } catch (err) {
-    if (err instanceof NoRouteMatchError) {
+    // isNoRouteMatchError also matches by name: a workspace with a duplicated
+    // @rangojs/router copy can throw a NoRouteMatchError whose prototype differs
+    // from this module's import, so a bare instanceof would turn an
+    // unmatched-host 404 into a 500.
+    if (isNoRouteMatchError(err)) {
       return new Response("Not Found", { status: 404 });
     }
     throw err;
@@ -2353,7 +2393,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.e9c0b2f2",
+  version: "0.0.0-experimental.ea9f40f2",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -2533,7 +2573,7 @@ var package_default = {
   },
   dependencies: {
     "@types/debug": "^4.1.12",
-    "@vitejs/plugin-rsc": "^0.5.26",
+    "@vitejs/plugin-rsc": "^0.5.27",
     debug: "^4.4.1",
     "magic-string": "^0.30.17",
     picomatch: "^4.0.4",
@@ -2543,6 +2583,8 @@ var package_default = {
   },
   devDependencies: {
     "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.9.0",
+    "@opentelemetry/sdk-trace-base": "^2.9.0",
     "@playwright/test": "^1.49.1",
     "@shared/e2e": "workspace:*",
     "@testing-library/dom": "^10.4.1",
@@ -2550,24 +2592,24 @@ var package_default = {
     "@types/node": "^24.10.1",
     "@types/react": "catalog:",
     "@types/react-dom": "catalog:",
-    esbuild: "^0.27.0",
+    esbuild: "^0.28.1",
     "happy-dom": "^20.10.1",
-    jiti: "^2.6.1",
+    jiti: "^2.7.0",
     react: "catalog:",
     "react-dom": "catalog:",
     typescript: "^5.3.0",
-    vitest: "^4.0.0"
+    vitest: "^4.1.9"
   },
   peerDependencies: {
-    "@cloudflare/vite-plugin": "^1.38.0",
+    "@cloudflare/vite-plugin": "^1.42.1",
     "@opentelemetry/api": "^1.9.0",
     "@playwright/test": "^1.49.1",
     "@testing-library/react": ">=16",
     "@vercel/functions": "^3.0.0",
-    "@vitejs/plugin-rsc": "^0.5.26",
+    "@vitejs/plugin-rsc": "^0.5.27",
     react: ">=19.2.6 <20",
     "react-dom": ">=19.2.6 <20",
-    vite: "^8.0.0",
+    vite: "^8.0.16",
     vitest: ">=3"
   },
   peerDependenciesMeta: {
@@ -2866,6 +2908,96 @@ function extractNamePrefixFromInclude(node) {
   }
   return null;
 }
+function thenSelectsNonDefaultMember(expr) {
+  const findThenCall = (e) => {
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression) && e.expression.name.text === "then") {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findThenCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findThenCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findThenCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findThenCall(e.expression);
+    return null;
+  };
+  const thenCall = findThenCall(expr);
+  if (!thenCall || thenCall.arguments.length === 0) return false;
+  const cb = thenCall.arguments[0];
+  if (!ts3.isArrowFunction(cb) && !ts3.isFunctionExpression(cb)) return false;
+  let ret;
+  if (ts3.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        ret = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    ret = cb.body;
+  }
+  if (!ret) return false;
+  if (ts3.isPropertyAccessExpression(ret)) {
+    return ret.name.text !== "default";
+  }
+  return false;
+}
+function extractDynamicImportSpecifier(node) {
+  let body;
+  if (ts3.isArrowFunction(node) || ts3.isFunctionExpression(node)) {
+    body = node.body;
+  }
+  if (!body) return null;
+  let expr;
+  if (ts3.isBlock(body)) {
+    for (const stmt of body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        expr = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    expr = body;
+  }
+  if (!expr) return null;
+  const findImportCall = (e) => {
+    if (ts3.isCallExpression(e) && e.expression.kind === ts3.SyntaxKind.ImportKeyword) {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findImportCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findImportCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findImportCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findImportCall(e.expression);
+    return null;
+  };
+  const importCall = findImportCall(expr);
+  if (!importCall || importCall.arguments.length === 0) return null;
+  if (thenSelectsNonDefaultMember(expr)) return null;
+  return getStringValue(importCall.arguments[0]);
+}
+function resolveDefaultExportTarget(code, sourceFile) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts3.isExportAssignment(node) && !node.isExportEquals) {
+      const expr = node.expression;
+      if (ts3.isIdentifier(expr)) {
+        result = { variableName: expr.text };
+      } else if (ts3.isCallExpression(expr)) {
+        const callee = expr.expression;
+        if (ts3.isIdentifier(callee) && callee.text === "urls") {
+          result = { inlineBlock: expr.getText(sourceFile) };
+        }
+      }
+      return;
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
 function extractIncludesWithDiagnostics(code, sourceFileArg) {
   const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
@@ -2891,12 +3023,19 @@ function extractIncludesWithDiagnostics(code, sourceFileArg) {
         }
         const secondArg = node.arguments[1];
         const namePrefix = extractNamePrefixFromInclude(node);
+        const dynamicImportSpec = extractDynamicImportSpecifier(secondArg);
         if (ts3.isIdentifier(secondArg)) {
           resolved.push({
             pathPrefix,
             variableName: secondArg.text,
             namePrefix
           });
+        } else if (dynamicImportSpec !== null) {
+          resolved.push({
+            pathPrefix,
+            moduleSpecifier: dynamicImportSpec,
+            namePrefix
+          });
         } else if (ts3.isCallExpression(secondArg)) {
           const callText = secondArg.expression.getText(sourceFile);
           unresolvable.push({
@@ -3000,57 +3139,94 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
       diagnosticsOut.push({ ...entry, sourceFile: filePath });
     }
   }
-  for (const { pathPrefix, variableName, namePrefix } of includes) {
+  for (const inc of includes) {
+    const { pathPrefix, namePrefix } = inc;
     let childResult;
-    const imported = resolveImportedVariable(fullSource, variableName);
-    if (imported) {
-      const targetFile = resolveImportPath(imported.specifier, filePath);
+    if (inc.moduleSpecifier) {
+      const targetFile = resolveImportPath(inc.moduleSpecifier, filePath);
       if (!targetFile) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "file-not-found",
-            sourceFile: filePath,
-            detail: `import "${imported.specifier}" resolved to no file`
-          });
-        }
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to no file`
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        targetFile,
-        imported.exportedName,
-        visited,
-        diagnosticsOut,
-        void 0,
-        memo
-      );
-    } else {
-      const sameFileBlock = extractUrlsBlockForVariable(
-        fullSource,
-        variableName,
-        parseBlock(memo, fullSource)
+      let targetSource;
+      try {
+        targetSource = readSourceMemoized(memo, resolve2(targetFile));
+      } catch (err) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to "${targetFile}" but reading it failed: ${err?.message ?? String(err)}`
+        });
+        continue;
+      }
+      const def = resolveDefaultExportTarget(
+        targetSource,
+        parseBlock(memo, targetSource)
       );
-      if (!sameFileBlock) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "unresolvable-import",
-            sourceFile: filePath,
-            detail: `variable "${variableName}" not found in imports or same-file scope`
-          });
-        }
+      if (!def) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "unresolvable-import",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") has no resolvable \`export default urls(...)\``
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        filePath,
+      if (def.inlineBlock) {
+        childResult = buildCombinedRouteMapWithSearch(
+          targetFile,
+          void 0,
+          visited,
+          diagnosticsOut,
+          def.inlineBlock,
+          memo
+        );
+      } else {
+        const variableName = def.variableName;
+        const resolved = resolveIncludedVariable({
+          variableName,
+          resolutionFile: targetFile,
+          resolutionSource: targetSource,
+          reportFile: filePath,
+          memo,
+          visited,
+          diagnosticsOut,
+          pathPrefix,
+          namePrefix,
+          fileNotFoundDetail: (specifier) => `import("${inc.moduleSpecifier}") default re-exports "${variableName}" from "${specifier}", which resolved to no file`,
+          notFoundDetail: () => `import("${inc.moduleSpecifier}") default "${variableName}" not found in its imports or same-file scope`
+        });
+        if (!resolved) continue;
+        childResult = resolved;
+      }
+    } else if (inc.variableName) {
+      const variableName = inc.variableName;
+      const resolved = resolveIncludedVariable({
         variableName,
+        resolutionFile: filePath,
+        resolutionSource: fullSource,
+        reportFile: filePath,
+        memo,
         visited,
         diagnosticsOut,
-        void 0,
-        memo
-      );
+        pathPrefix,
+        namePrefix,
+        fileNotFoundDetail: (specifier) => `import "${specifier}" resolved to no file`,
+        notFoundDetail: () => `variable "${variableName}" not found in imports or same-file scope`
+      });
+      if (!resolved) continue;
+      childResult = resolved;
+    } else {
+      continue;
     }
     if (namePrefix === null) {
       continue;
@@ -3073,6 +3249,64 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
+function resolveIncludedVariable(opts) {
+  const {
+    variableName,
+    resolutionFile,
+    resolutionSource,
+    reportFile,
+    memo,
+    visited,
+    diagnosticsOut,
+    pathPrefix,
+    namePrefix
+  } = opts;
+  const imported = resolveImportedVariable(resolutionSource, variableName);
+  if (imported) {
+    const targetFile = resolveImportPath(imported.specifier, resolutionFile);
+    if (!targetFile) {
+      diagnosticsOut?.push({
+        pathPrefix,
+        namePrefix,
+        reason: "file-not-found",
+        sourceFile: reportFile,
+        detail: opts.fileNotFoundDetail(imported.specifier)
+      });
+      return null;
+    }
+    return buildCombinedRouteMapWithSearch(
+      targetFile,
+      imported.exportedName,
+      visited,
+      diagnosticsOut,
+      void 0,
+      memo
+    );
+  }
+  const sameFileBlock = extractUrlsBlockForVariable(
+    resolutionSource,
+    variableName,
+    parseBlock(memo, resolutionSource)
+  );
+  if (!sameFileBlock) {
+    diagnosticsOut?.push({
+      pathPrefix,
+      namePrefix,
+      reason: "unresolvable-import",
+      sourceFile: reportFile,
+      detail: opts.notFoundDetail()
+    });
+    return null;
+  }
+  return buildCombinedRouteMapWithSearch(
+    resolutionFile,
+    variableName,
+    visited,
+    diagnosticsOut,
+    void 0,
+    memo
+  );
+}
 function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut, inlineBlock, memo) {
   visited = visited ?? /* @__PURE__ */ new Set();
   memo = memo ?? createScanMemo();
@@ -3685,6 +3919,7 @@ function isViteDepCachePath(filePath, cacheDir) {
 
 // src/vite/utils/shared-utils.ts
 import * as Vite from "vite";
+import { isAbsolute, resolve as resolve4 } from "node:path";
 
 // src/vite/plugins/performance-tracks.ts
 import { readFile } from "node:fs/promises";
@@ -3767,6 +4002,21 @@ var versionRolldownPlugin = {
 var sharedRolldownOptions = {
   plugins: [versionRolldownPlugin, performanceTracksOptimizeDepsPlugin()]
 };
+function normalizeHostRouterEntry(rawInput, root, exists) {
+  const raw = rawInput.replaceAll("\\", "/");
+  const isRelative = raw.startsWith("./") || raw.startsWith("../");
+  const isRooted = raw.startsWith("/") || isAbsolute(rawInput);
+  if (isRooted) return raw;
+  if (isRelative) {
+    if (!exists(resolve4(root, raw))) {
+      throw new Error(
+        `[rango] hostRouter entry not found: "${rawInput}" (resolved under ${root}). Point it at your createHostRouter() module, e.g. rango({ hostRouter: "./src/worker.rsc.tsx" }).`
+      );
+    }
+    return raw;
+  }
+  return exists(resolve4(root, raw)) ? "./" + raw : raw;
+}
 function createVirtualEntriesPlugin(entries, routerPathRef) {
   const virtualModules = {};
   if (entries.client === VIRTUAL_IDS.browser) {
@@ -3982,7 +4232,7 @@ function resolveClientChunks(option, ctx) {
 // src/vite/plugins/vercel-output.ts
 import { rm, mkdir, cp, writeFile } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
-import { resolve as resolve4, join as join3 } from "node:path";
+import { resolve as resolve5, join as join3 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { pathToFileURL } from "node:url";
 var LAUNCHER_SOURCE = `import { toNodeHandler } from "srvx/node";
@@ -4011,9 +4261,55 @@ function assertVercelNodeRuntime(runtime) {
     );
   }
 }
-async function assemble(root, options) {
+function assertValidVercelFunctionName(functionName) {
+  if (!/^[A-Za-z0-9._-]+$/.test(functionName)) {
+    throw new Error(
+      `[rango] preset "vercel": invalid functionName ${JSON.stringify(
+        functionName
+      )}. Use letters, digits, ".", "_" or "-" only (it becomes the .func directory and the routing dest).`
+    );
+  }
+}
+function buildVercelVcConfig(vercel) {
+  const vcConfig = {
+    runtime: vercel.runtime ?? "nodejs22.x",
+    handler: "index.mjs",
+    launcherType: "Nodejs",
+    shouldAddHelpers: false,
+    supportsResponseStreaming: true,
+    maxDuration: vercel.maxDuration ?? 30
+  };
+  if (vercel.memory != null) vcConfig.memory = vercel.memory;
+  if (vercel.regions != null) vcConfig.regions = vercel.regions;
+  return vcConfig;
+}
+function buildVercelOutputConfig(functionName, assetsDir) {
+  const assetsPrefix = assetsDir.replace(/^\/+|\/+$/g, "");
+  const assetHeaderRoute = assetsPrefix ? [
+    {
+      src: `/${escapeRegExp(assetsPrefix)}/(.*)`,
+      headers: { "cache-control": "public, max-age=31536000, immutable" },
+      continue: true
+    }
+  ] : [];
+  return {
+    version: 3,
+    routes: [
+      ...assetHeaderRoute,
+      { handle: "filesystem" },
+      { src: "/(.*)", dest: `/${functionName}` }
+    ]
+  };
+}
+async function assemble(root, options, assetsDir, publicDir) {
   const vercel = options.vercel ?? {};
   assertVercelNodeRuntime(vercel.runtime);
+  const assetsPrefix = assetsDir.replace(/^\/+|\/+$/g, "");
+  if (publicDir && assetsPrefix && existsSync4(join3(publicDir, assetsPrefix))) {
+    console.warn(
+      `[rango] preset "vercel": ${join3(publicDir, assetsPrefix)} exists. Files under public/${assetsPrefix}/ share the /${assetsPrefix}/ URL prefix with hashed build assets and will be served with a one-year immutable cache-control header. Move un-hashed public files out of "${assetsPrefix}/".`
+    );
+  }
   const dist = join3(root, "dist");
   for (const dir of ["client", "rsc", "ssr"]) {
     if (!existsSync4(join3(dist, dir))) {
@@ -4023,6 +4319,7 @@ async function assemble(root, options) {
     }
   }
   const functionName = vercel.functionName ?? "index";
+  assertValidVercelFunctionName(functionName);
   const out = join3(root, ".vercel", "output");
   const funcDir = join3(out, "functions", `${functionName}.func`);
   await rm(out, { recursive: true, force: true });
@@ -4108,33 +4405,13 @@ async function assemble(root, options) {
     join3(funcDir, "package.json"),
     JSON.stringify({ type: "module" }, null, 2) + "\n"
   );
-  const vcConfig = {
-    runtime: vercel.runtime ?? "nodejs22.x",
-    handler: "index.mjs",
-    launcherType: "Nodejs",
-    shouldAddHelpers: false,
-    supportsResponseStreaming: true,
-    maxDuration: vercel.maxDuration ?? 30
-  };
-  if (vercel.memory != null) vcConfig.memory = vercel.memory;
-  if (vercel.regions != null) vcConfig.regions = vercel.regions;
   await writeFile(
     join3(funcDir, ".vc-config.json"),
-    JSON.stringify(vcConfig, null, 2) + "\n"
+    JSON.stringify(buildVercelVcConfig(vercel), null, 2) + "\n"
   );
   await writeFile(
     join3(out, "config.json"),
-    JSON.stringify(
-      {
-        version: 3,
-        routes: [
-          { handle: "filesystem" },
-          { src: "/(.*)", dest: `/${functionName}` }
-        ]
-      },
-      null,
-      2
-    ) + "\n"
+    JSON.stringify(buildVercelOutputConfig(functionName, assetsDir), null, 2) + "\n"
   );
   console.log(
     `[rango] assembled .vercel/output (function: ${functionName}.func)`
@@ -4143,11 +4420,15 @@ async function assemble(root, options) {
 function createVercelOutputPlugin(options) {
   let root = process.cwd();
   let isBuild = false;
+  let assetsDir = "assets";
+  let publicDir = "";
   return {
     name: "@rangojs/router:vercel-output",
     configResolved(config) {
-      root = resolve4(config.root);
+      root = resolve5(config.root);
       isBuild = config.command === "build";
+      assetsDir = config.environments?.client?.build?.assetsDir ?? config.build?.assetsDir ?? "assets";
+      publicDir = config.publicDir || "";
     },
     // buildApp runs once after the whole multi-environment build (rsc, client,
     // ssr), so dist/ is complete here. closeBundle is unusable for this: it
@@ -4157,7 +4438,7 @@ function createVercelOutputPlugin(options) {
       order: "post",
       async handler() {
         if (!isBuild) return;
-        await assemble(root, options);
+        await assemble(root, options, assetsDir, publicDir);
       }
     }
   };
@@ -4190,7 +4471,7 @@ ${dim}   ${reset}${bold}\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550$
 }
 
 // src/vite/plugins/version-injector.ts
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 import * as Vite2 from "vite";
 function createVersionInjectorPlugin(rscEntryPath) {
   let resolvedEntryPath = "";
@@ -4201,7 +4482,7 @@ function createVersionInjectorPlugin(rscEntryPath) {
       let entryPath = rscEntryPath;
       if (!entryPath) entryPath = resolveRscEntryFromConfig(config);
       if (entryPath) {
-        resolvedEntryPath = resolve5(config.root, entryPath);
+        resolvedEntryPath = resolve6(config.root, entryPath);
       }
     },
     transform(code, id) {
@@ -4211,9 +4492,9 @@ function createVersionInjectorPlugin(rscEntryPath) {
       if (normalizedId !== normalizedEntry) {
         return null;
       }
-      const prepend = [
-        `import "virtual:rsc-router/routes-manifest";`
-      ];
+      const prepend = RSC_ENTRY_BOOTSTRAP_IMPORTS.map(
+        (id2) => `import "${id2}";`
+      );
       let newCode = code;
       const needsVersion = code.includes("createRSCHandler") && !code.includes("@rangojs/router:version") && /createRSCHandler\s*\(\s*\{/.test(code);
       if (needsVersion) {
@@ -4310,11 +4591,40 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
 import { createRequire as createRequire3, register } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
+// src/vite/inject-client-debug.ts
+function isRouterInternalDebugId(id) {
+  if (!id.includes("internal-debug")) return false;
+  const norm = id.replace(/\\/g, "/");
+  return /\/internal-debug\.[cm]?[jt]sx?(\?|$)/.test(norm) && (norm.includes("/@rangojs/router/") || norm.includes("/packages/rangojs-router/"));
+}
+function injectClientDebugFlag(id) {
+  if (!isRouterInternalDebugId(id)) return null;
+  return {
+    code: `export const INTERNAL_RANGO_DEBUG = ${!!process.env.INTERNAL_RANGO_DEBUG};
+`,
+    map: null
+  };
+}
+function internalDebugNoCacheMiddleware() {
+  return function rangoInternalDebugNoCache(req, res, next) {
+    if (req.url && isRouterInternalDebugId(req.url)) {
+      const setHeader = res.setHeader.bind(res);
+      res.setHeader = (name, value) => {
+        return setHeader(
+          name,
+          name.toLowerCase() === "cache-control" ? "no-cache" : value
+        );
+      };
+    }
+    next();
+  };
+}
+
 // src/vite/plugins/virtual-stub-plugin.ts
 function createVirtualStubPlugin() {
   const STUB_PREFIXES = [
@@ -4602,15 +4912,36 @@ function checkSelfGenWrite(state, filePath, consume) {
 import { AsyncLocalStorage } from "node:async_hooks";
 
 // src/internal-debug.ts
-var INTERNAL_RANGO_DEBUG = typeof __RANGO_DEBUG__ !== "undefined" ? __RANGO_DEBUG__ : typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_DEBUG);
+var INTERNAL_RANGO_DEBUG = typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_DEBUG);
 
 // src/router/logging.ts
 var routerLogContext = new AsyncLocalStorage();
 
-// src/router/pattern-matching.ts
+// src/router/url-params.ts
+var PATH_SAFE_ESCAPES = {
+  "%3A": ":",
+  "%40": "@",
+  "%24": "$",
+  "%26": "&",
+  "%2B": "+",
+  "%2C": ",",
+  "%3B": ";",
+  "%3D": "="
+};
+function encodePathSegment(value) {
+  return encodeURIComponent(value).replace(
+    /%(?:3A|40|24|26|2B|2C|3B|3D)/gi,
+    (match) => PATH_SAFE_ESCAPES[match.toUpperCase()] ?? match
+  );
+}
+function encodePathRemainder(value, encode = encodePathSegment) {
+  return value.split("/").map(encode).join("/");
+}
+
+// src/router/parse-pattern.ts
 function parsePattern(pattern) {
   const segments = [];
-  const segmentRegex = /\/(:([a-zA-Z_][a-zA-Z0-9_]*)(\(([^)]+)\))?(\?)?([^/]*)|(\*)|([^/]+))/g;
+  const segmentRegex = /\/(:([a-zA-Z_][a-zA-Z0-9_]*)(\(([^)]+)\))?(\?)?([+*])?([^/]*)|(\*)|([^/]+))/g;
   let match;
   while ((match = segmentRegex.exec(pattern)) !== null) {
     const [
@@ -4620,6 +4951,7 @@ function parsePattern(pattern) {
       ,
       constraint,
       optional,
+      repeat,
       suffix,
       wildcard,
       staticText
@@ -4627,17 +4959,38 @@ function parsePattern(pattern) {
     if (wildcard) {
       segments.push({ type: "wildcard", value: "*", optional: false });
     } else if (paramName) {
-      segments.push({
-        type: "param",
-        value: paramName,
-        optional: optional === "?",
-        constraint: constraint ? constraint.split("|") : void 0,
-        suffix: suffix || void 0
-      });
+      if (repeat && !suffix && optional !== "?" && !constraint) {
+        segments.push({
+          type: "wildcard",
+          value: paramName,
+          optional: false,
+          oneOrMore: repeat === "+"
+        });
+      } else {
+        segments.push({
+          type: "param",
+          value: paramName,
+          optional: optional === "?",
+          constraint: constraint ? constraint.split("|") : void 0,
+          // Fold a non-modifier `+`/`*` back into the literal suffix.
+          suffix: (repeat ?? "") + (suffix ?? "") || void 0
+        });
+      }
     } else if (staticText) {
       segments.push({ type: "static", value: staticText, optional: false });
     }
   }
+  for (let i = 0; i < segments.length - 1; i++) {
+    const s = segments[i];
+    if (s.type === "wildcard" && s.value !== "*") {
+      segments[i] = {
+        type: "param",
+        value: s.value,
+        optional: false,
+        suffix: s.oneOrMore ? "+" : "*"
+      };
+    }
+  }
   return segments;
 }
 
@@ -4840,11 +5193,18 @@ function insertSegments(node, segments, index, leafBase, paramNames) {
   } else if (segment.type === "wildcard") {
     const wildLeaf = {
       ...buildLeaf(leafBase, paramNames),
-      pn: "*"
+      pn: segment.value,
+      ...segment.oneOrMore ? { w1: true } : {}
     };
-    const existing = node.w ? { ...node.w } : void 0;
-    const merged = mergeLeaves(existing, wildLeaf);
-    node.w = merged;
+    const existing = node.w;
+    const canMerge = existing === void 0 || Boolean(existing.rt) || Boolean(wildLeaf.rt) || existing.pn === wildLeaf.pn && Boolean(existing.w1) === Boolean(wildLeaf.w1);
+    if (canMerge) {
+      const merged = mergeLeaves(
+        existing ? { ...existing } : void 0,
+        wildLeaf
+      );
+      node.w = merged;
+    }
   }
 }
 
@@ -4944,15 +5304,25 @@ import {
   statSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 function encodePathParam(value) {
-  return String(value).split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  return encodePathRemainder(String(value), encodeURIComponent);
 }
 function substituteRouteParams(pattern, params, encode = encodeURIComponent) {
   let result = pattern;
   let hadOmittedOptional = false;
   for (const [key, value] of Object.entries(params)) {
     const escaped = escapeRegExp(key);
+    const catchAllRe = new RegExp(`:${escaped}[+*]`);
+    if (catchAllRe.test(result)) {
+      if (value === "") {
+        result = result.replace(catchAllRe, "");
+        hadOmittedOptional = true;
+      } else {
+        result = result.replace(catchAllRe, encodePathRemainder(value, encode));
+      }
+      continue;
+    }
     if (value === "") {
       result = result.replace(
         new RegExp(`:${escaped}(\\([^)]*\\))?(?!\\?)`),
@@ -5067,7 +5437,7 @@ function resolvePrerenderError(registry, error, onError, label, elapsed, phase,
   throw error;
 }
 function getStagedAssetDir(projectRoot) {
-  return resolve6(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
+  return resolve7(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
 }
 function resetStagedBuildAssets(projectRoot) {
   rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
@@ -5077,7 +5447,7 @@ function stageBuildAssetModule(projectRoot, prefix, exportValue) {
   mkdirSync(stagedDir, { recursive: true });
   const contentHash = createHash4("sha256").update(exportValue).digest("hex").slice(0, 8);
   const fileName = `${prefix}-${contentHash}.js`;
-  const filePath = resolve6(stagedDir, fileName);
+  const filePath = resolve7(stagedDir, fileName);
   if (!existsSync5(filePath)) {
     writeFileSync2(filePath, `export default ${exportValue};
 `);
@@ -5086,12 +5456,12 @@ function stageBuildAssetModule(projectRoot, prefix, exportValue) {
 }
 function copyStagedBuildAssets(projectRoot, fileNames) {
   const stagedDir = getStagedAssetDir(projectRoot);
-  const distAssetsDir = resolve6(projectRoot, "dist/rsc/assets");
+  const distAssetsDir = resolve7(projectRoot, "dist/rsc/assets");
   mkdirSync(distAssetsDir, { recursive: true });
   let totalBytes = 0;
   for (const fileName of new Set(fileNames)) {
-    const stagedPath = resolve6(stagedDir, fileName);
-    const distPath = resolve6(distAssetsDir, fileName);
+    const stagedPath = resolve7(stagedDir, fileName);
+    const distPath = resolve7(distAssetsDir, fileName);
     copyFileSync(stagedPath, distPath);
     totalBytes += statSync(stagedPath).size;
   }
@@ -5532,6 +5902,28 @@ var DiscoveryError = class _DiscoveryError extends Error {
     Object.setPrototypeOf(this, _DiscoveryError.prototype);
   }
 };
+function describeDiscoveryFailure(err, opts = {}) {
+  if (err instanceof DiscoveryError && err.caught.length === 0) {
+    const entry = err.entryPath ?? "the router entry";
+    if (opts.reoptimizeObserved) {
+      return {
+        level: "warn",
+        message: `[rango] No routers found while Vite was re-optimizing dependencies on dev boot. This is transient: routes are served per-request and discovery re-runs automatically, so it clears on the next boot. If routes still 404, confirm ${entry} calls createRouter().`
+      };
+    }
+    return {
+      level: "error",
+      message: `${err.message}
+  Ensure ${entry} calls createRouter() at module top level and that the configured router entry path is correct.`
+    };
+  }
+  const e = err;
+  const detail = e?.stack ?? e?.message ?? String(err);
+  return {
+    level: "error",
+    message: `[rango] Router discovery failed: ${detail}`
+  };
+}
 
 // src/vite/discovery/discover-routers.ts
 var debug10 = createRangoDebugger(NS.discovery);
@@ -5616,7 +6008,7 @@ async function discoverRouters(state, rscEnv) {
     if (!router.urlpatterns || !generateManifestFull) {
       continue;
     }
-    const manifest = generateManifestFull(
+    const manifest = await generateManifestFull(
       router.urlpatterns,
       routerMountIndex,
       {
@@ -5759,8 +6151,45 @@ async function discoverRouters(state, rscEnv) {
   return serverMod;
 }
 
+// src/vite/discovery/dev-prerender-cache.ts
+function payloadBodiesFromResult(result) {
+  const main = JSON.stringify({
+    segments: result.segments,
+    handles: result.handles
+  });
+  const intercept = result.interceptSegments?.length ? JSON.stringify({
+    segments: [...result.segments, ...result.interceptSegments],
+    handles: result.interceptHandles ?? ""
+  }) : main;
+  return { main, intercept };
+}
+function devPrerenderCacheKey(pathname, opts) {
+  return `${pathname}|i=${opts.intercept ? 1 : 0}|p=${opts.passthrough ? 1 : 0}|r=${opts.routeName ?? ""}`;
+}
+var MAX_ENTRIES_PER_ROUTER = 500;
+function createDevPrerenderCache(maxEntriesPerRouter = MAX_ENTRIES_PER_ROUTER) {
+  const buckets = /* @__PURE__ */ new WeakMap();
+  return {
+    get(router, key) {
+      return buckets.get(router)?.get(key);
+    },
+    set(router, key, body) {
+      let bucket = buckets.get(router);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Map();
+        buckets.set(router, bucket);
+      }
+      if (!bucket.has(key) && bucket.size >= maxEntriesPerRouter) {
+        const oldest = bucket.keys().next().value;
+        if (oldest !== void 0) bucket.delete(oldest);
+      }
+      bucket.set(key, body);
+    }
+  };
+}
+
 // src/vite/discovery/route-types-writer.ts
-import { dirname as dirname3, join as join4, resolve as resolve7 } from "node:path";
+import { dirname as dirname3, join as join4, resolve as resolve8 } from "node:path";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync6, unlinkSync as unlinkSync2 } from "node:fs";
 function filterUserNamedRoutes(manifest) {
   const filtered = {};
@@ -5790,7 +6219,7 @@ function writeRouteTypesFiles(state) {
   if (state.perRouterManifests.length === 0) return;
   try {
     const entryDir = dirname3(
-      resolve7(state.projectRoot, state.resolvedEntryPath)
+      resolve8(state.projectRoot, state.resolvedEntryPath)
     );
     const oldCombinedPath = join4(entryDir, "named-routes.gen.ts");
     if (existsSync6(oldCombinedPath)) {
@@ -6001,13 +6430,13 @@ function generatePerRouterModule(state, routerId) {
 }
 
 // src/vite/discovery/bundle-postprocess.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "node:fs";
 function postprocessBundle(state) {
   const hasPrerenderData = state.prerenderManifestEntries && Object.keys(state.prerenderManifestEntries).length > 0;
   const hasStaticData = state.staticManifestEntries && Object.keys(state.staticManifestEntries).length > 0;
   if (!hasPrerenderData && !hasStaticData) return;
-  const rscEntryPath = resolve8(
+  const rscEntryPath = resolve9(
     state.projectRoot,
     "dist/rsc",
     state.rscEntryFileName ?? "index.js"
@@ -6028,7 +6457,7 @@ function postprocessBundle(state) {
   ];
   for (const target of evictionTargets) {
     for (const info of target.infos) {
-      const chunkPath = resolve8(state.projectRoot, "dist/rsc", info.fileName);
+      const chunkPath = resolve9(state.projectRoot, "dist/rsc", info.fileName);
       try {
         const code = readFileSync5(chunkPath, "utf-8");
         const result = evictHandlerCode(
@@ -6073,7 +6502,7 @@ function postprocessBundle(state) {
           `export default m;`,
           ""
         ].join("\n");
-        const manifestPath = resolve8(
+        const manifestPath = resolve9(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js"
         );
@@ -6111,7 +6540,7 @@ function postprocessBundle(state) {
         }
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;
 `;
-        const manifestPath = resolve8(
+        const manifestPath = resolve9(
           state.projectRoot,
           "dist/rsc/__static-manifest.js"
         );
@@ -6143,8 +6572,8 @@ function createDiscoveryGate(s, debug11) {
   let pendingEvents = false;
   const beginGate = () => {
     if (gatePending) return;
-    s.discoveryDone = new Promise((resolve11) => {
-      gateResolver = resolve11;
+    s.discoveryDone = new Promise((resolve12) => {
+      gateResolver = resolve12;
     });
     gatePending = true;
   };
@@ -6236,15 +6665,15 @@ function selectForwardableResolvePlugins(plugins) {
 }
 function pickForwardedRunnerConfig(config) {
   const r = config.resolve ?? {};
-  const resolve11 = {};
-  if (r.alias !== void 0) resolve11.alias = r.alias;
-  if (r.dedupe !== void 0) resolve11.dedupe = r.dedupe;
-  if (r.conditions !== void 0) resolve11.conditions = r.conditions;
-  if (r.mainFields !== void 0) resolve11.mainFields = r.mainFields;
-  if (r.extensions !== void 0) resolve11.extensions = r.extensions;
+  const resolve12 = {};
+  if (r.alias !== void 0) resolve12.alias = r.alias;
+  if (r.dedupe !== void 0) resolve12.dedupe = r.dedupe;
+  if (r.conditions !== void 0) resolve12.conditions = r.conditions;
+  if (r.mainFields !== void 0) resolve12.mainFields = r.mainFields;
+  if (r.extensions !== void 0) resolve12.extensions = r.extensions;
   if (r.preserveSymlinks !== void 0)
-    resolve11.preserveSymlinks = r.preserveSymlinks;
-  if (r.tsconfigPaths !== void 0) resolve11.tsconfigPaths = r.tsconfigPaths;
+    resolve12.preserveSymlinks = r.preserveSymlinks;
+  if (r.tsconfigPaths !== void 0) resolve12.tsconfigPaths = r.tsconfigPaths;
   const userOxc = config.oxc;
   const userJsx = userOxc && typeof userOxc === "object" && typeof userOxc.jsx === "object" && userOxc.jsx !== null ? userOxc.jsx : {};
   const oxc = userOxc && typeof userOxc === "object" ? {
@@ -6252,7 +6681,7 @@ function pickForwardedRunnerConfig(config) {
     jsx: { ...userJsx, runtime: "automatic", importSource: "react" }
   } : { jsx: { runtime: "automatic", importSource: "react" } };
   return {
-    resolve: resolve11,
+    resolve: resolve12,
     define: config.define,
     oxc
   };
@@ -6331,7 +6760,7 @@ async function resolveBuildEnv(option, factoryCtx) {
     }
     try {
       const userRequire = createRequire3(
-        resolve9(factoryCtx.root, "package.json")
+        resolve10(factoryCtx.root, "package.json")
       );
       const wranglerPath = userRequire.resolve("wrangler");
       const { getPlatformProxy } = await import(pathToFileURL2(wranglerPath).href);
@@ -6386,13 +6815,13 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
   let viteMode = "production";
   return {
     name: "@rangojs/router:discovery",
-    config() {
-      const config = {
-        define: {
-          __RANGO_DEBUG__: JSON.stringify(!!process.env.INTERNAL_RANGO_DEBUG)
-        }
-      };
-      return config;
+    // Make INTERNAL_RANGO_DEBUG reach the CLIENT debug logs by just setting the
+    // env var. See injectClientDebugFlag: bakes the resolved flag into the
+    // internal-debug module so FE debug no longer depends on Vite delivering the
+    // `__RANGO_DEBUG__` define to the client (which it does only as an injected
+    // global whose presence varies across consumer setups). Runs in dev and build.
+    transform(_code, id) {
+      return injectClientDebugFlag(id);
     },
     configResolved(config) {
       s.projectRoot = config.root;
@@ -6430,9 +6859,10 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       if (s.isBuildMode) return;
       if (globalThis.__rscRouterDiscoveryActive) return;
       s.devServer = server;
+      server.middlewares.use(internalDebugNoCacheMiddleware());
       let resolveDiscovery;
-      const discoveryPromise = new Promise((resolve11) => {
-        resolveDiscovery = resolve11;
+      const discoveryPromise = new Promise((resolve12) => {
+        resolveDiscovery = resolve12;
       });
       const gate = createDiscoveryGate(s, debugDiscovery);
       const beginDiscoveryGate = gate.beginGate;
@@ -6539,6 +6969,10 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
           );
           console.warn(`[rango] Failed to create temp runner: ${err.message}`);
         }
+        await prerenderTempServer?.close().catch(() => {
+        });
+        prerenderTempServer = null;
+        prerenderNodeRegistry = null;
         return null;
       }
       async function clearTempRegistries(tempRscEnv) {
@@ -6590,6 +7024,15 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
         await importEntryAndRegistry(tempRscEnv);
         return tempRscEnv;
       }
+      const emitDiscoveryFailure = (err, hashBefore, hashAfter) => {
+        const reoptimizeObserved = hashBefore !== void 0 && hashAfter !== void 0 && hashBefore !== hashAfter;
+        const report = describeDiscoveryFailure(err, { reoptimizeObserved });
+        if (report.level === "warn") {
+          console.warn(report.message);
+        } else {
+          console.error(report.message);
+        }
+      };
       const discover = async () => {
         const discoverStart = performance.now();
         const rscEnv = server.environments?.rsc;
@@ -6599,18 +7042,21 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
             globalThis.__rscRouterDiscoveryActive ?? false
           );
           s.devServerOrigin = getDevServerOrigin();
+          let tempRscEnv;
+          let optimizerHashBefore2;
           try {
             await timed(
               debugDiscovery,
               "acquireBuildEnv",
               () => acquireBuildEnv(s, viteCommand, viteMode)
             );
-            const tempRscEnv = await timed(
+            tempRscEnv = await timed(
               debugDiscovery,
               "getOrCreateTempServer",
               () => getOrCreateTempServer()
             );
             if (tempRscEnv) {
+              optimizerHashBefore2 = tempRscEnv.depsOptimizer?.metadata?.browserHash;
               await timed(
                 debugDiscovery,
                 "discoverRouters (cloudflare)",
@@ -6623,9 +7069,10 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
               );
             }
           } catch (err) {
-            console.warn(
-              `[rango] Cloudflare dev discovery failed: ${err.message}
-${err.stack}`
+            emitDiscoveryFailure(
+              err,
+              optimizerHashBefore2,
+              tempRscEnv?.depsOptimizer?.metadata?.browserHash
             );
           }
           debugDiscovery?.(
@@ -6635,6 +7082,7 @@ ${err.stack}`
           resolveDiscovery();
           return;
         }
+        const optimizerHashBefore = rscEnv.depsOptimizer?.metadata?.browserHash;
         try {
           debugDiscovery?.("dev: node path start");
           await timed(
@@ -6644,17 +7092,12 @@ ${err.stack}`
           );
           const serverMod = await timed(
             debugDiscovery,
-            "import @rangojs/router/server",
-            () => rscEnv.runner.import("@rangojs/router/server")
+            "discoverRouters",
+            () => discoverRouters(s, rscEnv)
           );
           if (serverMod?.setManifestReadyPromise) {
             serverMod.setManifestReadyPromise(discoveryPromise);
           }
-          await timed(
-            debugDiscovery,
-            "discoverRouters",
-            () => discoverRouters(s, rscEnv)
-          );
           s.devServerOrigin = getDevServerOrigin();
           timedSync(
             debugDiscovery,
@@ -6667,9 +7110,10 @@ ${err.stack}`
             () => propagateDiscoveryState(rscEnv)
           );
         } catch (err) {
-          console.warn(
-            `[rango] Router discovery failed: ${err.message}
-${err.stack}`
+          emitDiscoveryFailure(
+            err,
+            optimizerHashBefore,
+            rscEnv.depsOptimizer?.metadata?.browserHash
           );
         } finally {
           debugDiscovery?.(
@@ -6685,6 +7129,7 @@ ${err.stack}`
         0
       );
       let mainRegistry = null;
+      const devPrerenderCache = createDevPrerenderCache();
       const propagateDiscoveryState = async (rscEnv) => {
         const serverMod = await rscEnv.runner.import("@rangojs/router/server");
         if (!serverMod) return;
@@ -6754,8 +7199,19 @@ ${err.stack}`
           registry = mainRegistry;
         }
         if (!registry) {
-          if (!prerenderNodeRegistry) {
-            await getOrCreateTempServer();
+          const tempRscEnv = await getOrCreateTempServer();
+          if (tempRscEnv) {
+            try {
+              await importEntryAndRegistry(tempRscEnv);
+            } catch (err) {
+              console.warn(
+                `[rango] Dev prerender module refresh failed: ${err.message}`
+              );
+              res.statusCode = 500;
+              res.end(`Prerender handler error: ${err.message}`);
+              logResult(500, "temp module refresh failed");
+              return;
+            }
           }
           registry = prerenderNodeRegistry;
         }
@@ -6768,8 +7224,29 @@ ${err.stack}`
         const wantIntercept = url.searchParams.get("intercept") === "1";
         const wantRouteName = url.searchParams.get("routeName");
         const wantPassthrough = url.searchParams.get("passthrough") === "1";
+        const variantDims = {
+          passthrough: wantPassthrough,
+          routeName: wantRouteName
+        };
+        const keyMain = devPrerenderCacheKey(pathname, {
+          intercept: false,
+          ...variantDims
+        });
+        const keyIntercept = devPrerenderCacheKey(pathname, {
+          intercept: true,
+          ...variantDims
+        });
+        const requestedKey = wantIntercept ? keyIntercept : keyMain;
         for (const [, routerInstance] of registry) {
           if (!routerInstance.matchForPrerender) continue;
+          const cached = devPrerenderCache.get(routerInstance, requestedKey);
+          if (cached !== void 0) {
+            res.setHeader("content-type", "application/json");
+            res.setHeader("x-rango-prerender-cache", "HIT");
+            res.end(cached);
+            logResult(200, "cache hit");
+            return;
+          }
           try {
             const result = await routerInstance.matchForPrerender(
               pathname,
@@ -6783,19 +7260,16 @@ ${err.stack}`
             if (!result) continue;
             if (result.passthrough) continue;
             if (wantRouteName && result.routeName !== wantRouteName) continue;
+            const bodies = payloadBodiesFromResult(result);
+            devPrerenderCache.set(routerInstance, keyMain, bodies.main);
+            devPrerenderCache.set(
+              routerInstance,
+              keyIntercept,
+              bodies.intercept
+            );
             res.setHeader("content-type", "application/json");
-            let payload;
-            if (wantIntercept && result.interceptSegments?.length) {
-              payload = {
-                segments: [...result.segments, ...result.interceptSegments],
-                // Pre-encoded MERGED handle string from the producer (handles are
-                // Flight-encoded so Promise/ReactNode values survive the wire).
-                handles: result.interceptHandles ?? ""
-              };
-            } else {
-              payload = { segments: result.segments, handles: result.handles };
-            }
-            res.end(JSON.stringify(payload));
+            res.setHeader("x-rango-prerender-cache", "MISS");
+            res.end(wantIntercept ? bodies.intercept : bodies.main);
             logResult(200, `match ${result.routeName}`);
             return;
           } catch (err) {
@@ -7010,7 +7484,7 @@ ${err.stack}`
             if (hasCreateRouter) {
               const nestedRouterConflict = findNestedRouterConflict([
                 ...s.cachedRouterFiles ?? [],
-                resolve9(filePath)
+                resolve10(filePath)
               ]);
               if (nestedRouterConflict) {
                 server.config.logger.error(
@@ -7434,17 +7908,25 @@ async function rango(options) {
       name: "@rangojs/router:auto-discover",
       config(userConfig) {
         if (routerRef.path) return;
-        const root = userConfig.root ? resolve10(process.cwd(), userConfig.root) : process.cwd();
+        const root = userConfig.root ? resolve11(process.cwd(), userConfig.root) : process.cwd();
         const toRootRelative = (abs) => (abs.startsWith(root) ? "./" + abs.slice(root.length + 1) : abs).replaceAll("\\", "/");
         const bulletList = (files) => files.map((f) => "  - " + toRootRelative(f)).join("\n");
         if (explicitHostRouter) {
-          routerRef.path = explicitHostRouter.replaceAll("\\", "/");
+          routerRef.path = normalizeHostRouterEntry(
+            explicitHostRouter,
+            root,
+            existsSync8
+          );
           routerRef.kind = "host";
           return;
         }
         const hostCandidates = findHostRouterFiles(root);
         if (hostCandidates.length === 1) {
-          routerRef.path = toRootRelative(hostCandidates[0]);
+          const hostPath = toRootRelative(hostCandidates[0]);
+          console.info(
+            `[rango] Serving host router entry ${hostPath} (auto-detected). Set the \`hostRouter\` option to override.`
+          );
+          routerRef.path = hostPath;
           routerRef.kind = "host";
           return;
         }
@@ -7484,8 +7966,7 @@ If this is a multi-app host router, export a createHostRouter() instance and set
       enforce: "pre",
       config(_userConfig, configEnv) {
         const vercelDefine = preset === "vercel" && configEnv.command === "build" ? { "process.env.NODE_ENV": JSON.stringify("production") } : void 0;
-        const vercelServerEnv = preset === "vercel" ? { resolve: { noExternal: true } } : void 0;
-        const vercelServerInclude = preset === "vercel" && configEnv.command === "serve" ? ["@vercel/functions"] : [];
+        const vercelServerEnv = preset === "vercel" && configEnv.command === "build" ? { resolve: { noExternal: true } } : void 0;
         return {
           ...vercelDefine ? { define: vercelDefine } : {},
           optimizeDeps: {
@@ -7542,8 +8023,7 @@ If this is a multi-app host router, export a createHostRouter() instance and set
                   "react/jsx-dev-runtime",
                   nested(
                     "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
-                  ),
-                  ...vercelServerInclude
+                  )
                 ],
                 exclude: excludeDeps,
                 rolldownOptions: sharedRolldownOptions
@@ -7559,8 +8039,7 @@ If this is a multi-app host router, export a createHostRouter() instance and set
                   "react/jsx-dev-runtime",
                   nested(
                     "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
-                  ),
-                  ...vercelServerInclude
+                  )
                 ],
                 // Vite 8 does not propagate the top-level optimizeDeps.exclude
                 // (set in config()) to non-client envs, so the rsc env must set
@@ -7738,6 +8217,7 @@ function poke() {
   };
 }
 export {
+  directoryClientChunks,
   poke,
   rango
 };