@rangojs/router 0.0.0-experimental.bd6e11bc → 0.0.0-experimental.bdaf10aa

package/dist/vite/index.js

@@ -1,6 +1,6 @@
 // src/vite/rango.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve9 } 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";
@@ -10,6 +10,13 @@ import fs from "node:fs";
 // src/vite/plugins/expose-id-utils.ts
 import path from "node:path";
 import crypto from "node:crypto";
+
+// src/regex-escape.ts
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/vite/plugins/expose-id-utils.ts
 function normalizePath(p) {
   return p.split(path.sep).join("/");
 }
@@ -158,7 +165,9 @@ function countArgs(code, startPos, endPos) {
   while (i < endPos) {
     const skipped = skipStringOrComment(code, i);
     if (skipped > i) {
-      hasContent = true;
+      const ch = code[i];
+      const isComment = ch === "/" && i + 1 < code.length && (code[i + 1] === "/" || code[i + 1] === "*");
+      if (!isComment) hasContent = true;
       i = skipped;
       continue;
     }
@@ -187,8 +196,59 @@ function findStatementEnd(code, pos) {
   }
   return i;
 }
-function escapeRegExp(input) {
-  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function findCallParenAfterGenerics(code, afterCalleeIndex) {
+  let i = afterCalleeIndex;
+  while (i < code.length) {
+    const skipped = skipStringOrComment(code, i);
+    if (skipped > i) {
+      i = skipped;
+      continue;
+    }
+    if (/\s/.test(code[i])) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  if (i >= code.length) return -1;
+  if (code[i] === "(") return i;
+  if (code[i] === "<") {
+    let depth = 0;
+    while (i < code.length) {
+      const skipped = skipStringOrComment(code, i);
+      if (skipped > i) {
+        i = skipped;
+        continue;
+      }
+      const ch = code[i];
+      if (ch === "<") {
+        depth++;
+      } else if (ch === ">") {
+        depth--;
+        if (depth === 0) {
+          i++;
+          break;
+        }
+      }
+      i++;
+    }
+    if (depth !== 0) return -1;
+    while (i < code.length) {
+      const skipped = skipStringOrComment(code, i);
+      if (skipped > i) {
+        i = skipped;
+        continue;
+      }
+      if (/\s/.test(code[i])) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    if (i < code.length && code[i] === "(") return i;
+    return -1;
+  }
+  return -1;
 }
 
 // src/vite/debug.ts
@@ -431,7 +491,6 @@ function exposeActionId() {
         counterTransform?.record(id, performance.now() - start);
       }
     },
-    // Build mode: renderChunk runs after all transforms and bundling complete
     renderChunk(code, chunk) {
       const start = counterRender ? performance.now() : 0;
       try {
@@ -473,10 +532,10 @@ import path4 from "node:path";
 function isDirectivePrologueStatement(node) {
   return node?.type === "ExpressionStatement" && typeof node.directive === "string";
 }
-function findImportInsertionPos(code, parseAst4) {
+function findImportInsertionPos(code, parseAst5) {
   let program;
   try {
-    program = parseAst4(code, { lang: "tsx" });
+    program = parseAst5(code, { lang: "tsx" });
   } catch {
     return 0;
   }
@@ -513,10 +572,10 @@ function walkNode(node, parent, ancestors, enter) {
   }
   ancestors.pop();
 }
-function findHandlerCalls(code, fnName, parseAst4) {
+function findHandlerCalls(code, fnName, parseAst5) {
   let program;
   try {
-    program = parseAst4(code, { lang: "tsx" });
+    program = parseAst5(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -588,18 +647,18 @@ function getImportedLocalNamesFromProgram(program, importedName) {
   }
   return localNames;
 }
-function getImportedLocalNames(code, importedName, parseAst4) {
+function getImportedLocalNames(code, importedName, parseAst5) {
   try {
-    const program = parseAst4(code, { lang: "tsx" });
+    const program = parseAst5(code, { lang: "tsx" });
     return getImportedLocalNamesFromProgram(program, importedName);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
-function extractImportDeclarations(code, parseAst4) {
+function extractImportDeclarations(code, parseAst5) {
   let program;
   try {
-    program = parseAst4(code, { lang: "tsx" });
+    program = parseAst5(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -623,13 +682,18 @@ function isInertExpression(node) {
         (e) => e === null || isInertExpression(e)
       );
     case "ObjectExpression":
-      return (node.properties ?? []).every(
-        (p) => p.type === "Property" && (!p.computed || isInertExpression(p.key)) && isInertExpression(p.value)
-      );
+      return (node.properties ?? []).every((p) => {
+        if (p.type === "SpreadElement" || p.type === "RestElement") {
+          return isInertExpression(p.argument);
+        }
+        return p.type === "Property" && (!p.computed || isInertExpression(p.key)) && isInertExpression(p.value);
+      });
     case "UnaryExpression":
       return isInertExpression(node.argument);
     case "BinaryExpression":
       return isInertExpression(node.left) && isInertExpression(node.right);
+    case "LogicalExpression":
+      return isInertExpression(node.left) && isInertExpression(node.right);
     case "ConditionalExpression":
       return isInertExpression(node.test) && isInertExpression(node.consequent) && isInertExpression(node.alternate);
     case "SpreadElement":
@@ -651,10 +715,10 @@ function isSafeVariableDeclaration(node, handlerNames) {
     (d) => isSafeDeclaratorInit(d.init) && !(d.init?.type === "CallExpression" && d.init.callee?.type === "Identifier" && handlerNames.has(d.init.callee.name))
   );
 }
-function extractModuleLevelDeclarations(code, parseAst4, handlerNames) {
+function extractModuleLevelDeclarations(code, parseAst5, handlerNames) {
   let program;
   try {
-    program = parseAst4(code, { lang: "tsx" });
+    program = parseAst5(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -685,17 +749,17 @@ function extractModuleLevelDeclarations(code, parseAst4, handlerNames) {
   }
   return declarations;
 }
-function transformInlineHandlers(fnName, virtualPrefix, s, code, filePath, virtualRegistry, moduleId, parseAst4) {
-  const sites = findHandlerCalls(code, fnName, parseAst4);
+function transformInlineHandlers(fnName, virtualPrefix, s, code, filePath, virtualRegistry, moduleId, parseAst5) {
+  const sites = findHandlerCalls(code, fnName, parseAst5);
   const inlineSites = sites.filter((site) => site.exportInfo === null);
   if (inlineSites.length === 0) return false;
-  const imports = extractImportDeclarations(code, parseAst4);
-  const staticNames = getImportedLocalNames(code, "Static", parseAst4);
-  const prerenderNames = getImportedLocalNames(code, "Prerender", parseAst4);
+  const imports = extractImportDeclarations(code, parseAst5);
+  const staticNames = getImportedLocalNames(code, "Static", parseAst5);
+  const prerenderNames = getImportedLocalNames(code, "Prerender", parseAst5);
   const handlerNames = /* @__PURE__ */ new Set([...staticNames, ...prerenderNames]);
   const declarations = extractModuleLevelDeclarations(
     code,
-    parseAst4,
+    parseAst5,
     handlerNames
   );
   const importStatements = [];
@@ -718,7 +782,7 @@ function transformInlineHandlers(fnName, virtualPrefix, s, code, filePath, virtu
   }
   if (importStatements.length > 0) {
     const importBlock = importStatements.join("\n") + "\n";
-    const insertionPos = findImportInsertionPos(code, parseAst4);
+    const insertionPos = findImportInsertionPos(code, parseAst5);
     if (insertionPos === 0) {
       s.prepend(importBlock);
     } else {
@@ -751,25 +815,55 @@ function isLineTerminator(ch) {
   const c = ch.charCodeAt(0);
   return c === 10 || c === 13 || c === 8232 || c === 8233;
 }
+var REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "do",
+  "else",
+  "yield",
+  "await",
+  "case",
+  "throw"
+]);
+function isRegexPositionAt(code, slashPos, prevChar) {
+  if (prevChar === void 0) return true;
+  if (prevChar === ")" || prevChar === "]" || prevChar === "}") return false;
+  if (!/[\w$]/.test(prevChar)) return true;
+  let k = slashPos - 1;
+  while (k >= 0 && /\s/.test(code[k])) k--;
+  const wordEnd = k + 1;
+  while (k >= 0 && /[\w$]/.test(code[k])) k--;
+  return REGEX_PRECEDING_KEYWORDS.has(code.slice(k + 1, wordEnd));
+}
 function makeCodeClassifier(code) {
   const n = code.length;
   let i = 0;
   let skipStart = -1;
   let skipEnd = -1;
+  let lastSig;
   return (q) => {
     if (q >= skipStart && q < skipEnd) return false;
     while (i < n && i <= q) {
       const c = code[i];
       const d = i + 1 < n ? code[i + 1] : "";
       let end = -1;
+      let transparent = false;
       if (c === "/" && d === "/") {
         let j = i + 2;
         while (j < n && !isLineTerminator(code[j])) j++;
         end = j;
+        transparent = true;
       } else if (c === "/" && d === "*") {
         let j = i + 2;
         while (j < n && !(code[j] === "*" && code[j + 1] === "/")) j++;
         end = Math.min(n, j + 2);
+        transparent = true;
       } else if (c === '"' || c === "'" || c === "`") {
         let j = i + 1;
         while (j < n) {
@@ -784,6 +878,29 @@ function makeCodeClassifier(code) {
           j++;
         }
         end = j;
+      } else if (c === "/" && d !== "/" && d !== "*" && isRegexPositionAt(code, i, lastSig)) {
+        let j = i + 1;
+        let inClass = false;
+        let closed = false;
+        while (j < n && !isLineTerminator(code[j])) {
+          const r = code[j];
+          if (r === "\\") {
+            j += 2;
+            continue;
+          }
+          if (r === "[") inClass = true;
+          else if (r === "]") inClass = false;
+          else if (r === "/" && !inClass) {
+            j++;
+            closed = true;
+            break;
+          }
+          j++;
+        }
+        if (closed) {
+          while (j < n && /[a-z]/.test(code[j])) j++;
+          end = j;
+        }
       }
       if (end >= 0) {
         if (q < end) {
@@ -792,7 +909,9 @@ function makeCodeClassifier(code) {
           return false;
         }
         i = end;
+        if (!transparent) lastSig = "x";
       } else {
+        if (!/\s/.test(c)) lastSig = c;
         i++;
       }
     }
@@ -851,13 +970,23 @@ function isExportOnlyFile(code, bindings) {
   return true;
 }
 function createCallPattern(fnNames) {
-  return new RegExp(
-    `\\b(?:${fnNames.map(escapeRegExp).join("|")})\\s*(?:<[^>]*>\\s*)?\\(`,
-    "g"
+  return new RegExp(`\\b(?:${fnNames.map(escapeRegExp).join("|")})\\b`, "g");
+}
+function createCallStartIndices(code, fnNames) {
+  return codeMatchIndices(code, createCallPattern(fnNames)).filter(
+    (index) => findCallParenAfterGenerics(
+      code,
+      index + matchedNameLength(code, index)
+    ) !== -1
   );
 }
+function matchedNameLength(code, index) {
+  let i = index;
+  while (i < code.length && /[A-Za-z0-9_$]/.test(code[i])) i++;
+  return i - index;
+}
 function countCreateCallsForNames(code, fnNames) {
-  return codeMatchIndices(code, createCallPattern(fnNames)).length;
+  return createCallStartIndices(code, fnNames).length;
 }
 function offsetToLineColumn(code, index) {
   let line = 1;
@@ -873,7 +1002,7 @@ function offsetToLineColumn(code, index) {
 }
 function findUnsupportedCreateCallSites(code, fnNames, supportedBindings) {
   const supported = new Set(supportedBindings.map((b) => b.callExprStart));
-  return codeMatchIndices(code, createCallPattern(fnNames)).filter((index) => !supported.has(index)).map((index) => offsetToLineColumn(code, index));
+  return createCallStartIndices(code, fnNames).filter((index) => !supported.has(index)).map((index) => offsetToLineColumn(code, index));
 }
 function getImportedFnNames(code, importedName) {
   const importPattern = /import\s*\{([^}]*)\}\s*from\s*["']@rangojs\/router(?:\/[^"']*)?["']/g;
@@ -1067,11 +1196,13 @@ function generateClientLoaderStubs(bindings, code, filePath, isBuild) {
   if (!isExportOnlyFile(code, bindings)) return null;
   const lines = [];
   for (const binding of bindings) {
-    for (const name of binding.exportNames) {
-      const loaderId = makeStubId(filePath, name, isBuild);
-      lines.push(
-        `export const ${name} = { __brand: "loader", $$id: "${loaderId}" };`
-      );
+    const primaryName = binding.exportNames[0];
+    const loaderId = makeStubId(filePath, primaryName, isBuild);
+    lines.push(
+      `export const ${primaryName} = { __brand: "loader", $$id: "${loaderId}" };`
+    );
+    for (const alias of binding.exportNames.slice(1)) {
+      lines.push(`export const ${alias} = ${primaryName};`);
     }
   }
   return { code: lines.join("\n") + "\n" };
@@ -1092,22 +1223,13 @@ ${binding.localName}.$$id = "${loaderId}";`;
 }
 
 // src/vite/plugins/expose-ids/handler-transform.ts
-function analyzeCreateHandleArgs(code, startPos, endPos) {
-  const content = code.slice(startPos, endPos).trim();
-  return { hasArgs: content.length > 0 };
-}
-function transformHandles(bindings, s, code, filePath, isBuild) {
+function transformHandles(bindings, s, filePath, isBuild) {
   let hasChanges = false;
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
-    const args = analyzeCreateHandleArgs(
-      code,
-      binding.callOpenParenPos + 1,
-      binding.callCloseParenPos
-    );
     const handleId = makeStubId(filePath, exportName, isBuild);
     let paramInjection;
-    if (!args.hasArgs) {
+    if (binding.argCount === 0) {
       paramInjection = `undefined, "${handleId}"`;
     } else {
       paramInjection = `, "${handleId}"`;
@@ -1182,36 +1304,68 @@ import MagicString2 from "magic-string";
 import path3 from "node:path";
 import { createHash } from "node:crypto";
 var debug2 = createRangoDebugger(NS.transform);
-function transformRouter(code, filePath, routerFnNames, absolutePath) {
+function skipLeadingTrivia(code, start, end) {
+  let i = start;
+  while (i < end) {
+    const skipped = skipStringOrComment(code, i);
+    if (skipped > i) {
+      i = skipped;
+      continue;
+    }
+    if (/\s/.test(code[i])) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+function transformRouter(code, filePath, routerFnNames, absolutePath, warn) {
   const pat = new RegExp(
-    `\\b(?:${routerFnNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\s*(?:<[^>]*>)?\\s*\\(`,
+    `\\b(?:${routerFnNames.map(escapeRegExp).join("|")})\\b`,
     "g"
   );
   let match;
   const s = new MagicString2(code);
   let changed = false;
+  const unsupportedSites = [];
   const basename2 = path3.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
   const routeNamesImport = `./${basename2}.named-routes.gen.js`;
   const routeNamesVar = `__rsc_rn`;
+  const codeOffsets = new Set(codeMatchIndices(code, pat));
+  pat.lastIndex = 0;
   while ((match = pat.exec(code)) !== null) {
+    if (!codeOffsets.has(match.index)) continue;
     const callStart = match.index;
-    const parenPos = match.index + match[0].length - 1;
+    const calleeEnd = match.index + match[0].length;
+    const parenPos = findCallParenAfterGenerics(code, calleeEnd);
+    if (parenPos === -1) continue;
     const closeParen = findMatchingParen(code, parenPos + 1);
     const callArgs = code.slice(parenPos + 1, closeParen);
-    if (callArgs.includes("$$id")) continue;
+    if (callArgs.includes(`$$routeNames: ${routeNamesVar}`)) continue;
+    const sourceFilePath = absolutePath ?? filePath;
     const lineNumber = code.slice(0, callStart).split("\n").length;
     const hash = createHash("sha256").update(`${filePath}:${lineNumber}`).digest("hex").slice(0, 8);
-    changed = true;
-    const sourceFilePath = absolutePath ?? filePath;
     const injected = ` $$id: "${hash}", $$sourceFile: "${sourceFilePath}", $$routeNames: ${routeNamesVar},`;
-    const afterParen = callArgs.trimStart();
-    if (afterParen.startsWith("{")) {
-      const bracePos = code.indexOf("{", parenPos + 1);
-      s.appendRight(bracePos + 1, injected);
-    } else if (afterParen.startsWith(")")) {
+    const argsContentStart = skipLeadingTrivia(code, parenPos + 1, closeParen);
+    const firstArgChar = code[argsContentStart];
+    if (firstArgChar === "{") {
+      changed = true;
+      s.appendRight(argsContentStart + 1, injected);
+    } else if (argsContentStart >= closeParen - 1) {
+      changed = true;
       s.appendRight(parenPos + 1, `{${injected} }`);
+    } else {
+      const lastNl = code.lastIndexOf("\n", callStart - 1);
+      const column = callStart - (lastNl + 1) + 1;
+      unsupportedSites.push({ line: lineNumber, column });
     }
   }
+  if (unsupportedSites.length > 0 && warn) {
+    warn(
+      buildUnsupportedShapeWarning(filePath, "createRouter", unsupportedSites)
+    );
+  }
   if (!changed) return null;
   s.prepend(
     `import { NamedRoutes as ${routeNamesVar} } from "${routeNamesImport}";
@@ -1245,11 +1399,13 @@ function exposeRouterId() {
       try {
         const filePath = normalizePath(path3.relative(projectRoot, id));
         const routerFnNames = getImportedFnNames(code, "createRouter");
+        const warn = typeof this.warn === "function" ? (message) => this.warn(message) : void 0;
         return transformRouter(
           code,
           filePath,
           routerFnNames,
-          normalizePath(id)
+          normalizePath(id),
+          warn
         );
       } finally {
         counter?.record(id, performance.now() - start);
@@ -1345,6 +1501,7 @@ ${lazyImports.join(",\n")}
     // --------------- Loader pre-scan (build mode) ---------------
     async buildStart() {
       if (!isBuild) return;
+      if (this.environment && this.environment.name !== "rsc") return;
       const fs2 = await import("node:fs/promises");
       const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage"]);
       async function scanDir(dir) {
@@ -1729,7 +1886,6 @@ ${lazyImports.join(",\n")}
           changed = transformHandles(
             getBindings(code, fnNames),
             s,
-            code,
             filePath,
             isBuild
           ) || changed;
@@ -1806,8 +1962,8 @@ function useCacheTransform() {
         } = rscTransforms;
         let ast;
         try {
-          const { parseAst: parseAst4 } = await import("vite");
-          ast = parseAst4(code, { lang: "tsx" });
+          const { parseAst: parseAst5 } = await import("vite");
+          ast = parseAst5(code, { lang: "tsx" });
         } catch {
           return;
         }
@@ -1841,7 +1997,7 @@ function useCacheTransform() {
   };
 }
 function transformFileLevelUseCache(code, ast, filePath, sourceId, isBuild, isLayoutOrTemplate, transformWrapExport) {
-  const nonFunctionExports = [];
+  const unconfirmedExports = [];
   const { exportNames, output } = transformWrapExport(code, ast, {
     runtime: (value, name) => {
       const funcId = isBuild ? hashId(filePath, name) : `${filePath}#${name}`;
@@ -1850,16 +2006,17 @@ function transformFileLevelUseCache(code, ast, filePath, sourceId, isBuild, isLa
     rejectNonAsyncFunction: false,
     filter: (name, meta) => {
       if (name === "default" && isLayoutOrTemplate) return false;
-      if (meta.isFunction === false) {
-        nonFunctionExports.push(name);
+      if (meta.isFunction !== true) {
+        unconfirmedExports.push(name);
         return false;
       }
       return true;
     }
   });
-  if (nonFunctionExports.length > 0) {
+  if (unconfirmedExports.length > 0) {
+    const plural = unconfirmedExports.length > 1;
     throw new Error(
-      `[rango:use-cache] File-level "use cache" in ${sourceId} cannot wrap non-function export${nonFunctionExports.length > 1 ? "s" : ""}: ${nonFunctionExports.map((n) => `"${n}"`).join(", ")}. Only function exports can be cached. Either remove "use cache" from the file level and add it inside individual functions, or move the non-function exports to a separate module.`
+      `[rango:use-cache] File-level "use cache" in ${sourceId} only wraps exports that are statically-confirmed functions. ${plural ? "These exports are" : "This export is"} not: ${unconfirmedExports.map((n) => `"${n}"`).join(", ")}. Declare them directly (export async function foo() {} or export const foo = async () => {}). A factory or otherwise statically-indeterminate initializer (export const foo = makeCached(fn)) is rejected even if it returns a function at runtime -- rewrite it as a direct async function, or move non-function exports to a separate module.`
     );
   }
   if (exportNames.length === 0) {
@@ -1997,7 +2154,6 @@ function clientRefDedup() {
       if (this.environment?.name !== "client") return;
       if (!importer?.includes(CLIENT_IN_SERVER_PROXY_PREFIX)) return;
       if (!source.includes("/node_modules/")) return;
-      if (!importer) return;
       const packageName = extractPackageName(source);
       if (!packageName) return;
       if (clientExclude.includes(packageName)) return;
@@ -2039,11 +2195,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(Rango))
+    strictMode === false ? app : createElement(StrictMode, null, app)
   );
 }
 
@@ -2051,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,
@@ -2062,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,
@@ -2077,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
@@ -2096,6 +2283,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,
@@ -2112,6 +2304,77 @@ export default function handler(request, env) {
 }
 `.trim();
 }
+function getVirtualEntryRSCHost(hostEntryPath) {
+  return `
+import * as __hostEntry from "${hostEntryPath}";
+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
+// mounted sub-apps, so the aggregate manifests cover the whole host tree.
+import "virtual:rsc-router/loader-manifest";
+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 (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.
+// 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) => {
+  for (const name of ["default", "hostRouter", "router"]) {
+    const candidate = m[name];
+    if (
+      candidate &&
+      typeof candidate.match === "function" &&
+      typeof candidate.host === "function"
+    )
+      return candidate;
+  }
+  return undefined;
+};
+
+// 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.
+// On node/vercel rango owns this entry, so there is no user worker to translate
+// 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);
+  } catch (err) {
+    // 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;
+  }
+}
+`.trim();
+}
 var VIRTUAL_IDS = {
   browser: "virtual:rsc-router/entry.browser.js",
   ssr: "virtual:rsc-router/entry.ssr.js",
@@ -2130,7 +2393,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.bd6e11bc",
+  version: "0.0.0-experimental.bdaf10aa",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -2240,6 +2503,16 @@ var package_default = {
       "react-server": "./src/cache/cache-runtime.ts",
       default: "./src/cache/cache-runtime.ts"
     },
+    "./cloudflare": {
+      types: "./src/cloudflare/index.ts",
+      "react-server": "./src/cloudflare/index.ts",
+      default: "./src/cloudflare/index.ts"
+    },
+    "./vercel": {
+      types: "./src/vercel/index.ts",
+      "react-server": "./src/vercel/index.ts",
+      default: "./src/vercel/index.ts"
+    },
     "./theme": {
       types: "./src/theme/index.ts",
       default: "./src/theme/index.ts"
@@ -2288,7 +2561,7 @@ var package_default = {
     tag: "experimental"
   },
   scripts: {
-    build: "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && mkdir -p dist/vite/plugins && cp src/vite/plugins/cloudflare-protocol-loader-hook.mjs dist/vite/plugins/cloudflare-protocol-loader-hook.mjs && pnpm dlx esbuild src/testing/vitest.ts --bundle --format=esm --outfile=dist/testing/vitest.js --platform=node --packages=external && pnpm dlx esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node' && chmod +x dist/bin/rango.js",
+    build: "pnpm exec esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && mkdir -p dist/vite/plugins && cp src/vite/plugins/cloudflare-protocol-loader-hook.mjs dist/vite/plugins/cloudflare-protocol-loader-hook.mjs && pnpm exec esbuild src/testing/vitest.ts --bundle --format=esm --outfile=dist/testing/vitest.js --platform=node --packages=external && pnpm exec esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node' && chmod +x dist/bin/rango.js",
     prepublishOnly: "pnpm build",
     typecheck: "tsc --noEmit && tsc -p tsconfig.strict-check.json --noEmit && tsc -p tsconfig.augment-check.json --noEmit",
     test: "playwright test",
@@ -2300,14 +2573,18 @@ 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.3",
+    picomatch: "^4.0.4",
     "rsc-html-stream": "^0.0.7",
+    srvx: "^0.11.15",
     tinyexec: "^0.3.2"
   },
   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",
@@ -2315,40 +2592,51 @@ 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",
-    "@vitejs/plugin-rsc": "^0.5.26",
+    "@vercel/functions": "^3.0.0",
+    "@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: {
     "@cloudflare/vite-plugin": {
       optional: true
     },
+    "@opentelemetry/api": {
+      optional: true
+    },
     "@playwright/test": {
       optional: true
     },
     "@testing-library/react": {
       optional: true
     },
+    "@vercel/functions": {
+      optional: true
+    },
     vite: {
       optional: true
     },
     vitest: {
       optional: true
     }
+  },
+  engines: {
+    node: "^20.19.0 || >=22.12.0"
   }
 };
 
@@ -2422,10 +2710,10 @@ function extractParamsFromPattern(pattern) {
 function formatRouteEntry(key, pattern, _params, search) {
   const hasSearch = search && Object.keys(search).length > 0;
   if (!hasSearch) {
-    return `  ${key}: "${pattern}",`;
+    return `  ${key}: ${JSON.stringify(pattern)},`;
   }
-  const searchBody = Object.entries(search).map(([k, v]) => `${k}: "${v}"`).join(", ");
-  return `  ${key}: { path: "${pattern}", search: { ${searchBody} } },`;
+  const searchBody = Object.entries(search).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
+  return `  ${key}: { path: ${JSON.stringify(pattern)}, search: { ${searchBody} } },`;
 }
 
 // src/build/route-types/ast-route-extraction.ts
@@ -2451,8 +2739,8 @@ function extractObjectStringProperties(node) {
 }
 
 // src/build/route-types/ast-route-extraction.ts
-function extractRoutesFromSource(code) {
-  const sourceFile = ts2.createSourceFile(
+function extractRoutesFromSource(code, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts2.createSourceFile(
     "input.tsx",
     code,
     ts2.ScriptTarget.Latest,
@@ -2532,16 +2820,44 @@ export const NamedRoutes = {
 ${objectBody}
 } as const;
 
+// Aliased so the augmentation below does not pay a homomorphic mapped-type
+// instantiation per route; \`as const\` already makes the members readonly.
+type NamedRoutesShape = typeof NamedRoutes;
+
 declare global {
   namespace Rango {
-    interface GeneratedRouteMap extends Readonly<typeof NamedRoutes> {}
+    interface GeneratedRouteMap extends NamedRoutesShape {}
   }
 }
 `;
 }
 
 // src/build/route-types/scan-filter.ts
+import { join, relative } from "node:path";
 import picomatch from "picomatch";
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/__tests__/**",
+  "**/__mocks__/**",
+  "**/dist/**",
+  "**/coverage/**",
+  "**/*.test.{ts,tsx,js,jsx}",
+  "**/*.spec.{ts,tsx,js,jsx}"
+];
+function createScanFilter(root, opts) {
+  const { include, exclude } = opts;
+  const hasInclude = include && include.length > 0;
+  const hasCustomExclude = exclude !== void 0;
+  if (!hasInclude && !hasCustomExclude) return void 0;
+  const effectiveExclude = exclude ?? DEFAULT_EXCLUDE_PATTERNS;
+  const includeMatcher = hasInclude ? picomatch(include) : null;
+  const excludeMatcher = effectiveExclude.length > 0 ? picomatch(effectiveExclude) : null;
+  return (absolutePath) => {
+    const rel = relative(root, absolutePath);
+    if (excludeMatcher && excludeMatcher(rel)) return false;
+    if (includeMatcher) return includeMatcher(rel);
+    return true;
+  };
+}
 
 // src/build/route-types/per-module-writer.ts
 import ts4 from "typescript";
@@ -2550,6 +2866,33 @@ import ts4 from "typescript";
 import { readFileSync, existsSync as existsSync2 } from "node:fs";
 import { dirname, resolve as resolve2 } from "node:path";
 import ts3 from "typescript";
+function createScanMemo() {
+  return { files: /* @__PURE__ */ new Map(), blockSourceFiles: /* @__PURE__ */ new Map() };
+}
+function parseBlock(memo, block) {
+  if (memo) {
+    const cached = memo.blockSourceFiles.get(block);
+    if (cached) return cached;
+  }
+  const sf = ts3.createSourceFile(
+    "input.tsx",
+    block,
+    ts3.ScriptTarget.Latest,
+    true,
+    ts3.ScriptKind.TSX
+  );
+  if (memo) memo.blockSourceFiles.set(block, sf);
+  return sf;
+}
+function readSourceMemoized(memo, realPath) {
+  if (memo) {
+    const cached = memo.files.get(realPath);
+    if (cached !== void 0) return cached;
+  }
+  const source = readFileSync(realPath, "utf-8");
+  if (memo) memo.files.set(realPath, source);
+  return source;
+}
 function extractNamePrefixFromInclude(node) {
   if (node.arguments.length >= 3) {
     const thirdArg = node.arguments[2];
@@ -2565,8 +2908,98 @@ function extractNamePrefixFromInclude(node) {
   }
   return null;
 }
-function extractIncludesWithDiagnostics(code) {
-  const sourceFile = ts3.createSourceFile(
+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",
     code,
     ts3.ScriptTarget.Latest,
@@ -2590,12 +3023,19 @@ function extractIncludesWithDiagnostics(code) {
         }
         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({
@@ -2620,7 +3060,7 @@ function extractIncludesWithDiagnostics(code) {
   return { resolved, unresolvable };
 }
 function resolveImportedVariable(code, localName) {
-  const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
+  const importRegex = /import\s*(?:[\w$]+\s*,\s*)?\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
   let match;
   while ((match = importRegex.exec(code)) !== null) {
     const imports = match[1];
@@ -2657,8 +3097,8 @@ function resolveImportPath(importSpec, fromFile) {
   }
   return null;
 }
-function extractUrlsBlockForVariable(code, varName) {
-  const sourceFile = ts3.createSourceFile(
+function extractUrlsBlockForVariable(code, varName, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
     code,
     ts3.ScriptTarget.Latest,
@@ -2680,67 +3120,113 @@ function extractUrlsBlockForVariable(code, varName) {
   visit(sourceFile);
   return result;
 }
-function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut, diagnosticsOut) {
+function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut, diagnosticsOut, memo) {
   const routeMap = {};
-  const localRoutes = extractRoutesFromSource(block);
+  const blockSourceFile = parseBlock(memo, block);
+  const localRoutes = extractRoutesFromSource(block, blockSourceFile);
   for (const { name, pattern, search } of localRoutes) {
     routeMap[name] = pattern;
     if (search && searchSchemasOut) {
       searchSchemasOut[name] = search;
     }
   }
-  const { resolved: includes, unresolvable } = extractIncludesWithDiagnostics(block);
+  const { resolved: includes, unresolvable } = extractIncludesWithDiagnostics(
+    block,
+    blockSourceFile
+  );
   if (diagnosticsOut) {
     for (const entry of unresolvable) {
       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
-      );
-    } else {
-      const sameFileBlock = extractUrlsBlockForVariable(
-        fullSource,
-        variableName
+      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
-      );
+        diagnosticsOut,
+        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;
@@ -2763,8 +3249,67 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
-function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut, inlineBlock) {
+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();
   const realPath = resolve2(filePath);
   const key = variableName ? `${realPath}:${variableName}` : realPath;
   if (visited.has(key)) {
@@ -2774,7 +3319,7 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
   visited.add(key);
   let source;
   try {
-    source = readFileSync(realPath, "utf-8");
+    source = readSourceMemoized(memo, realPath);
   } catch {
     return { routes: {}, searchSchemas: {} };
   }
@@ -2782,7 +3327,11 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
   if (inlineBlock) {
     block = inlineBlock;
   } else if (variableName) {
-    const extracted = extractUrlsBlockForVariable(source, variableName);
+    const extracted = extractUrlsBlockForVariable(
+      source,
+      variableName,
+      parseBlock(memo, source)
+    );
     if (!extracted) return { routes: {}, searchSchemas: {} };
     block = extracted;
   } else {
@@ -2795,7 +3344,8 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
     realPath,
     visited,
     searchSchemas,
-    diagnosticsOut
+    diagnosticsOut,
+    memo
   );
   visited.delete(key);
   return { routes, searchSchemas };
@@ -2810,7 +3360,7 @@ import {
   readdirSync
 } from "node:fs";
 import {
-  join,
+  join as join2,
   dirname as dirname2,
   resolve as resolve3,
   sep,
@@ -2833,7 +3383,10 @@ var ROUTER_CALL_PATTERN_G = /\bcreateRouter\s*[<(]/g;
 function isRoutableSourceFile(name) {
   return (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".jsx")) && !name.includes(".gen.") && !name.includes(".test.") && !name.includes(".spec.");
 }
-function findRouterFilesRecursive(dir, filter, results) {
+function isExcludedScanDir(name) {
+  return name === "node_modules" || name === "dist" || name === "coverage" || name === "__tests__" || name === "__mocks__" || name.startsWith(".");
+}
+function findCallSiteFilesRecursive(dir, pattern, patternG, stopAtMatchDir, filter, results) {
   let entries;
   try {
     entries = readdirSync(dir, { withFileTypes: true });
@@ -2844,32 +3397,36 @@ function findRouterFilesRecursive(dir, filter, results) {
     return;
   }
   const childDirs = [];
-  const routerFilesInDir = [];
+  const matchesInDir = [];
   for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage" || entry.name === "__tests__" || entry.name === "__mocks__" || entry.name.startsWith("."))
-        continue;
-      childDirs.push(fullPath);
+      if (!isExcludedScanDir(entry.name)) childDirs.push(fullPath);
       continue;
     }
     if (!isRoutableSourceFile(entry.name)) continue;
     if (filter && !filter(fullPath)) continue;
     try {
       const source = readFileSync2(fullPath, "utf-8");
-      if (ROUTER_CALL_PATTERN.test(source) && firstCodeMatchIndex(source, ROUTER_CALL_PATTERN_G) >= 0) {
-        routerFilesInDir.push(fullPath);
+      if (pattern.test(source) && firstCodeMatchIndex(source, patternG) >= 0) {
+        matchesInDir.push(fullPath);
       }
     } catch {
       continue;
     }
   }
-  if (routerFilesInDir.length > 0) {
-    results.push(...routerFilesInDir);
-    return;
-  }
-  for (const childDir of childDirs) {
-    findRouterFilesRecursive(childDir, filter, results);
+  results.push(...matchesInDir);
+  if (!stopAtMatchDir || matchesInDir.length === 0) {
+    for (const childDir of childDirs) {
+      findCallSiteFilesRecursive(
+        childDir,
+        pattern,
+        patternG,
+        stopAtMatchDir,
+        filter,
+        results
+      );
+    }
   }
 }
 function findNestedRouterConflict(routerFiles) {
@@ -3006,7 +3563,7 @@ function applyBasenameToRoutes(result, basename2) {
 }
 function genFileTsPath(sourceFile) {
   const base = pathBasename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
-  return join(dirname2(sourceFile), `${base}.named-routes.gen.ts`);
+  return join2(dirname2(sourceFile), `${base}.named-routes.gen.ts`);
 }
 function resolveSearchSchemas(publicRouteNames, runtimeSchemas, sourceFile) {
   if (runtimeSchemas && Object.keys(runtimeSchemas).length > 0) {
@@ -3067,12 +3624,33 @@ function buildCombinedRouteMapForRouterFile(routerFilePath) {
 }
 function findRouterFiles(root, filter) {
   const result = [];
-  findRouterFilesRecursive(root, filter, result);
+  findCallSiteFilesRecursive(
+    root,
+    ROUTER_CALL_PATTERN,
+    ROUTER_CALL_PATTERN_G,
+    true,
+    filter,
+    result
+  );
+  return result;
+}
+var HOST_ROUTER_CALL_PATTERN = /\bcreateHostRouter\s*[<(]/;
+var HOST_ROUTER_CALL_PATTERN_G = /\bcreateHostRouter\s*[<(]/g;
+function findHostRouterFiles(root, filter) {
+  const result = [];
+  findCallSiteFilesRecursive(
+    root,
+    HOST_ROUTER_CALL_PATTERN,
+    HOST_ROUTER_CALL_PATTERN_G,
+    false,
+    filter,
+    result
+  );
   return result;
 }
 function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
   try {
-    const oldCombinedPath = join(root, "src", "named-routes.gen.ts");
+    const oldCombinedPath = join2(root, "src", "named-routes.gen.ts");
     if (existsSync3(oldCombinedPath)) {
       unlinkSync(oldCombinedPath);
       console.log(
@@ -3133,7 +3711,28 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
 }
 
 // src/vite/plugins/version-plugin.ts
+import { parseAst as parseAst4 } from "vite";
+
+// src/vite/utils/directive-prologue.ts
 import { parseAst as parseAst3 } from "vite";
+function hasUseClientDirective(source) {
+  let program;
+  try {
+    program = parseAst3(source, { lang: "tsx" });
+  } catch {
+    return 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") return true;
+      continue;
+    }
+    break;
+  }
+  return false;
+}
+
+// src/vite/plugins/version-plugin.ts
 function isCodeModule(id) {
   return /\.(tsx?|jsx?)($|\?)/.test(id);
 }
@@ -3141,23 +3740,13 @@ function normalizeModuleId(id) {
   return id.split("?", 1)[0];
 }
 function getClientModuleSignature(source) {
+  if (!hasUseClientDirective(source)) return void 0;
   let program;
   try {
-    program = parseAst3(source, { lang: "tsx" });
+    program = parseAst4(source, { lang: "tsx" });
   } catch {
     return void 0;
   }
-  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 void 0;
   const exports = /* @__PURE__ */ new Set();
   let hasDefault = false;
   let hasExportAll = false;
@@ -3282,7 +3871,6 @@ function createVersionPlugin() {
       }
       return null;
     },
-    // Track RSC module changes and update version
     async hotUpdate(ctx) {
       if (!isDev) return;
       const isRscModule = this.environment?.name === "rsc";
@@ -3331,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";
@@ -3359,9 +3948,6 @@ function performanceTracksOptimizeDepsPlugin() {
   const RSDW_CLIENT_RE = /react-server-dom-webpack-client\.browser\.(development|production)\.js$/;
   return {
     name: "@rangojs/router:performance-tracks-optimize-deps",
-    // Vite 8 optimizes deps with Rolldown (Rollup-style plugin pipeline), so the
-    // pre-bundled RSDW client is patched via load() rather than esbuild's onLoad.
-    // Returning code overrides Rolldown's default filesystem read for the module.
     async load(id) {
       const cleanId = id.split("?")[0] ?? id;
       if (!RSDW_CLIENT_RE.test(cleanId)) return null;
@@ -3416,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) {
@@ -3449,7 +4050,7 @@ function createVirtualEntriesPlugin(entries, routerPathRef) {
         if (virtualId === VIRTUAL_IDS.rsc && routerPathRef?.path) {
           const raw = routerPathRef.path.startsWith(".") ? "/" + routerPathRef.path.slice(2) : routerPathRef.path;
           const absoluteRouterPath = raw.replaceAll("\\", "/");
-          return getVirtualEntryRSC(absoluteRouterPath);
+          return routerPathRef.kind === "host" ? getVirtualEntryRSCHost(absoluteRouterPath) : getVirtualEntryRSC(absoluteRouterPath);
         }
       }
       return null;
@@ -3504,7 +4105,7 @@ function getManualChunks(id) {
 }
 
 // src/vite/plugins/client-ref-hashing.ts
-import { relative } from "node:path";
+import { relative as relative2 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 var debug7 = createRangoDebugger(NS.transform);
 var CLIENT_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-package-proxy/";
@@ -3521,10 +4122,10 @@ function computeProductionHash(projectRoot, refKey) {
     const absPath = decodeURIComponent(
       refKey.slice(CLIENT_IN_SERVER_PKG_PROXY_PREFIX.length)
     );
-    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith(FS_PREFIX)) {
     const absPath = refKey.slice(FS_PREFIX.length - 1);
-    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith("/")) {
     toHash = refKey.slice(1);
   } else {
@@ -3551,7 +4152,6 @@ function hashClientRefs(projectRoot) {
   const counter = createCounter(debug7, "hash-client-refs");
   return {
     name: "@rangojs/router:hash-client-refs",
-    // Run after the RSC plugin's transform (default enforce is normal)
     enforce: "post",
     applyToEnvironment(env) {
       return env.name === "rsc";
@@ -3602,31 +4202,246 @@ function directoryClientChunks(meta, ctx) {
   if (isSharedRuntime(meta)) {
     return void 0;
   }
-  if (ctx?.fallbackRefs.size && ctx.fallbackRefs.has(hashRefKey(meta.normalizedId))) {
-    debugChunks?.("fallback %s -> app-fallback", meta.normalizedId);
-    return "app-fallback";
+  if (ctx?.fallbackRefs.size && ctx.fallbackRefs.has(hashRefKey(meta.normalizedId))) {
+    debugChunks?.("fallback %s -> app-fallback", meta.normalizedId);
+    return "app-fallback";
+  }
+  const segments = meta.normalizedId.split("/").filter(Boolean);
+  const dirCount = segments.length - 1;
+  if (dirCount >= 1) {
+    for (let i = 0; i < dirCount - 1; i++) {
+      if (ROUTE_ROOT_DIRS.has(segments[i].toLowerCase())) {
+        const group = `app-${sanitizeGroup(segments[i + 1])}`;
+        debugChunks?.("split %s -> %s", meta.normalizedId, group);
+        return group;
+      }
+    }
+  }
+  debugChunks?.(
+    "shared %s (no route-root marker; inherits default grouping)",
+    meta.normalizedId
+  );
+  return void 0;
+}
+function resolveClientChunks(option, ctx) {
+  if (!option) return void 0;
+  if (option === true) return (meta) => directoryClientChunks(meta, ctx);
+  return option;
+}
+
+// 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 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";
+import { waitUntil } from "@vercel/functions";
+import rscHandler from "./rsc/index.js";
+
+// The Vercel Node launcher invokes a Node (req, res) handler, not a Web fetch
+// handler. srvx's toNodeHandler bridges the Rango Web fetch handler and pipes
+// the streamed Response to the Node response (set supportsResponseStreaming).
+const onVercel = Boolean(process.env.VERCEL);
+
+const fetchHandler = (request) =>
+  rscHandler(request, {
+    env: process.env,
+    // Forward Vercel's waitUntil so cache writes / revalidation run off the
+    // response path. Omitted off-platform so those writes settle inline.
+    ctx: onVercel ? { waitUntil } : undefined,
+  });
+
+export default toNodeHandler(fetchHandler);
+`;
+function assertVercelNodeRuntime(runtime) {
+  if (runtime != null && !runtime.startsWith("nodejs")) {
+    throw new Error(
+      `[rango] preset "vercel": runtime "${runtime}" is not supported. This preset emits a Node serverless function; use a "nodejs*" runtime (default "nodejs22.x"). The Edge runtime is not supported.`
+    );
+  }
+}
+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))) {
+      throw new Error(
+        `[rango] preset "vercel": missing dist/${dir}. Run the production build first.`
+      );
+    }
+  }
+  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 });
+  await mkdir(funcDir, { recursive: true });
+  await cp(join3(dist, "client"), join3(out, "static"), { recursive: true });
+  await cp(join3(dist, "rsc"), join3(funcDir, "rsc"), { recursive: true });
+  await cp(join3(dist, "ssr"), join3(funcDir, "ssr"), { recursive: true });
+  if (existsSync4(join3(dist, "static"))) {
+    await cp(join3(dist, "static"), join3(funcDir, "static"), {
+      recursive: true
+    });
+  }
+  const rangoRequire = createRequire2(import.meta.url);
+  let srvxNodePath;
+  try {
+    srvxNodePath = rangoRequire.resolve("srvx/node");
+  } catch {
+    throw new Error(
+      '[rango] preset "vercel" requires "srvx" (a dependency of @rangojs/router). Reinstall dependencies.'
+    );
+  }
+  const appRequire = createRequire2(join3(root, "package.json"));
+  const resolveEsbuildPath = () => {
+    try {
+      const viteRequire = createRequire2(appRequire.resolve("vite"));
+      return viteRequire.resolve("esbuild");
+    } catch {
+    }
+    try {
+      return appRequire.resolve("esbuild");
+    } catch {
+    }
+    return rangoRequire.resolve("esbuild");
+  };
+  let esbuildModule;
+  try {
+    esbuildModule = await import(pathToFileURL(resolveEsbuildPath()).href);
+  } catch {
+    throw new Error(
+      '[rango] preset "vercel" requires "esbuild" to bundle the function launcher. It ships with Vite; reinstall dependencies (or add esbuild to your app dependencies).'
+    );
+  }
+  const esbuildBuild = esbuildModule.build ?? esbuildModule.default?.build;
+  if (typeof esbuildBuild !== "function") {
+    throw new Error('[rango] preset "vercel": could not load esbuild.build.');
   }
-  const segments = meta.normalizedId.split("/").filter(Boolean);
-  const dirCount = segments.length - 1;
-  if (dirCount >= 1) {
-    for (let i = 0; i < dirCount - 1; i++) {
-      if (ROUTE_ROOT_DIRS.has(segments[i].toLowerCase())) {
-        const group = `app-${sanitizeGroup(segments[i + 1])}`;
-        debugChunks?.("split %s -> %s", meta.normalizedId, group);
-        return group;
-      }
+  try {
+    await esbuildBuild({
+      stdin: {
+        contents: LAUNCHER_SOURCE,
+        resolveDir: root,
+        sourcefile: "func-entry.mjs",
+        loader: "js"
+      },
+      outfile: join3(funcDir, "index.mjs"),
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node18",
+      alias: { "srvx/node": srvxNodePath },
+      plugins: [
+        {
+          name: "external-rsc-entry",
+          setup(b) {
+            b.onResolve({ filter: /^\.\/rsc\/index\.js$/ }, () => ({
+              path: "./rsc/index.js",
+              external: true
+            }));
+          }
+        }
+      ]
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/@vercel\/functions/.test(message)) {
+      throw new Error(
+        '[rango] preset "vercel": could not resolve "@vercel/functions". Add it to your app dependencies (it also backs VercelCacheStore).\n' + message
+      );
     }
+    throw error;
   }
-  debugChunks?.(
-    "shared %s (no route-root marker; inherits default grouping)",
-    meta.normalizedId
+  await writeFile(
+    join3(funcDir, "package.json"),
+    JSON.stringify({ type: "module" }, null, 2) + "\n"
+  );
+  await writeFile(
+    join3(funcDir, ".vc-config.json"),
+    JSON.stringify(buildVercelVcConfig(vercel), null, 2) + "\n"
+  );
+  await writeFile(
+    join3(out, "config.json"),
+    JSON.stringify(buildVercelOutputConfig(functionName, assetsDir), null, 2) + "\n"
+  );
+  console.log(
+    `[rango] assembled .vercel/output (function: ${functionName}.func)`
   );
-  return void 0;
 }
-function resolveClientChunks(option, ctx) {
-  if (!option) return void 0;
-  if (option === true) return (meta) => directoryClientChunks(meta, ctx);
-  return option;
+function createVercelOutputPlugin(options) {
+  let root = process.cwd();
+  let isBuild = false;
+  let assetsDir = "assets";
+  let publicDir = "";
+  return {
+    name: "@rangojs/router:vercel-output",
+    configResolved(config) {
+      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
+    // fires per environment, and twice for ssr (the server-reference scan and
+    // the real build), so it would run before dist/client exists.
+    buildApp: {
+      order: "post",
+      async handler() {
+        if (!isBuild) return;
+        await assemble(root, options, assetsDir, publicDir);
+      }
+    }
+  };
 }
 
 // src/vite/utils/banner.ts
@@ -3656,7 +4471,7 @@ ${dim}   ${reset}${bold}\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550$
 }
 
 // src/vite/plugins/version-injector.ts
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 import * as Vite2 from "vite";
 function createVersionInjectorPlugin(rscEntryPath) {
   let resolvedEntryPath = "";
@@ -3667,7 +4482,7 @@ function createVersionInjectorPlugin(rscEntryPath) {
       let entryPath = rscEntryPath;
       if (!entryPath) entryPath = resolveRscEntryFromConfig(config);
       if (entryPath) {
-        resolvedEntryPath = resolve4(config.root, entryPath);
+        resolvedEntryPath = resolve6(config.root, entryPath);
       }
     },
     transform(code, id) {
@@ -3677,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) {
@@ -3715,13 +4530,17 @@ function createVersionInjectorPlugin(rscEntryPath) {
 // src/vite/plugins/cjs-to-esm.ts
 var debug8 = createRangoDebugger(NS.transform);
 function createCjsToEsmPlugin() {
+  let isProduction = false;
   return {
     name: "@rangojs/router:cjs-to-esm",
     enforce: "pre",
+    configResolved(config) {
+      isProduction = config.isProduction;
+    },
     transform(code, id) {
       const cleanId = id.split("?")[0].replaceAll("\\", "/");
       if (cleanId.includes("vendor/react-server-dom/client.browser.js")) {
-        const isProd = process.env.NODE_ENV === "production";
+        const isProd = isProduction;
         const cjsFile = isProd ? "./cjs/react-server-dom-webpack-client.browser.production.js" : "./cjs/react-server-dom-webpack-client.browser.development.js";
         debug8?.("cjs-to-esm entry redirect %s", id);
         return {
@@ -3772,10 +4591,39 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
-import { createRequire as createRequire2, register } from "node:module";
-import { pathToFileURL } from "node:url";
+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() {
@@ -4060,7 +4908,93 @@ function checkSelfGenWrite(state, filePath, consume) {
   }
 }
 
-// src/vite/utils/manifest-utils.ts
+// src/router/logging.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/internal-debug.ts
+var INTERNAL_RANGO_DEBUG = typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_DEBUG);
+
+// src/router/logging.ts
+var routerLogContext = new AsyncLocalStorage();
+
+// 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;
+  let match;
+  while ((match = segmentRegex.exec(pattern)) !== null) {
+    const [
+      ,
+      ,
+      paramName,
+      ,
+      constraint,
+      optional,
+      repeat,
+      suffix,
+      wildcard,
+      staticText
+    ] = match;
+    if (wildcard) {
+      segments.push({ type: "wildcard", value: "*", optional: false });
+    } else if (paramName) {
+      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;
+}
+
+// src/build/prefix-tree-utils.ts
 function flattenLeafEntries(prefixTree, routeManifest, result) {
   function visit(node, ancestorStaticPrefixes) {
     const children = node.children || {};
@@ -4101,6 +5035,226 @@ function buildRouteToStaticPrefix(prefixTree, result) {
     visit(node);
   }
 }
+
+// src/build/route-trie.ts
+function buildRouteTrie(routeManifest, routeAncestry, routeToStaticPrefix, routeTrailingSlash, prerenderRouteNames, passthroughRouteNames, responseTypeRoutes) {
+  const root = {};
+  for (const [routeName, pattern] of Object.entries(routeManifest)) {
+    const ancestry = routeAncestry[routeName] || [];
+    const staticPrefix = routeToStaticPrefix[routeName] || "";
+    const trailingSlash = routeTrailingSlash?.[routeName];
+    const responseType = responseTypeRoutes?.[routeName];
+    const hasTrailingSlash = pattern.length > 1 && pattern.endsWith("/");
+    const normalizedPattern = hasTrailingSlash ? pattern.slice(0, -1) : pattern;
+    const segments = parsePattern(normalizedPattern);
+    insertRoute(root, segments, 0, {
+      n: routeName,
+      sp: staticPrefix,
+      a: ancestry,
+      ...trailingSlash ? { ts: trailingSlash } : {},
+      ...prerenderRouteNames?.has(routeName) ? { pr: true } : {},
+      ...passthroughRouteNames?.has(routeName) ? { pt: true } : {},
+      ...responseType ? { rt: responseType } : {}
+    });
+  }
+  sortSuffixParams(root);
+  return root;
+}
+function sortSuffixParams(node) {
+  if (node.xp) {
+    const sorted = {};
+    for (const suffix of Object.keys(node.xp).sort(
+      (a, b) => b.length - a.length
+    )) {
+      sorted[suffix] = node.xp[suffix];
+    }
+    node.xp = sorted;
+    for (const child of Object.values(node.xp)) {
+      sortSuffixParams(child.c);
+    }
+  }
+  if (node.s) {
+    for (const child of Object.values(node.s)) {
+      sortSuffixParams(child);
+    }
+  }
+  if (node.p) {
+    sortSuffixParams(node.p.c);
+  }
+}
+function buildPerRouterTrie(manifest) {
+  const ancestry = manifest._routeAncestry;
+  if (!ancestry || Object.keys(ancestry).length === 0) {
+    return null;
+  }
+  const routeToStaticPrefix = {};
+  for (const name of Object.keys(manifest.routeManifest)) {
+    routeToStaticPrefix[name] = "";
+  }
+  if (manifest.prefixTree) {
+    buildRouteToStaticPrefix(manifest.prefixTree, routeToStaticPrefix);
+  }
+  return buildRouteTrie(
+    manifest.routeManifest,
+    ancestry,
+    routeToStaticPrefix,
+    manifest.routeTrailingSlash,
+    manifest.prerenderRoutes ? new Set(manifest.prerenderRoutes) : void 0,
+    manifest.passthroughRoutes ? new Set(manifest.passthroughRoutes) : void 0,
+    manifest.responseTypeRoutes
+  );
+}
+function insertRoute(node, segments, index, leaf) {
+  const constraints = {};
+  for (const seg of segments) {
+    if (seg.type === "param") {
+      if (seg.constraint) {
+        constraints[seg.value] = seg.constraint;
+      }
+    }
+  }
+  const leafBase = {
+    ...leaf,
+    ...Object.keys(constraints).length > 0 ? { cv: constraints } : {}
+  };
+  insertSegments(node, segments, index, leafBase, []);
+}
+function toVariant(leaf, responseType) {
+  return leaf.pa ? { routeKey: leaf.n, responseType, pa: leaf.pa } : { routeKey: leaf.n, responseType };
+}
+function mergeLeaves(existing, leaf) {
+  if (!existing) return leaf;
+  if (existing.rt && leaf.rt) {
+    const merged = leaf;
+    merged.nv = existing.nv || [];
+    merged.nv.push(toVariant(existing, existing.rt));
+    return merged;
+  }
+  if (leaf.rt && !existing.rt) {
+    if (!existing.nv) {
+      existing.nv = [];
+      existing.rf = true;
+    }
+    existing.nv.push(toVariant(leaf, leaf.rt));
+    return existing;
+  }
+  if (!leaf.rt && existing.rt) {
+    if (!leaf.nv) leaf.nv = [];
+    if (existing.nv) leaf.nv.push(...existing.nv);
+    leaf.nv.push(toVariant(existing, existing.rt));
+    return leaf;
+  }
+  return leaf;
+}
+function mergeLeaf(node, leaf) {
+  node.r = mergeLeaves(node.r, leaf);
+}
+function buildLeaf(leafBase, paramNames) {
+  return paramNames.length > 0 ? { ...leafBase, pa: [...paramNames] } : { ...leafBase };
+}
+function insertSegments(node, segments, index, leafBase, paramNames) {
+  if (index >= segments.length) {
+    mergeLeaf(node, buildLeaf(leafBase, paramNames));
+    return;
+  }
+  const segment = segments[index];
+  if (segment.type === "static") {
+    if (!node.s) node.s = {};
+    if (!node.s[segment.value]) node.s[segment.value] = {};
+    insertSegments(
+      node.s[segment.value],
+      segments,
+      index + 1,
+      leafBase,
+      paramNames
+    );
+  } else if (segment.type === "param") {
+    if (segment.optional) {
+      insertSegments(node, segments, index + 1, leafBase, paramNames);
+    }
+    if (segment.suffix) {
+      if (!node.xp) node.xp = {};
+      if (!node.xp[segment.suffix]) {
+        node.xp[segment.suffix] = { n: segment.value, c: {} };
+      }
+      insertSegments(node.xp[segment.suffix].c, segments, index + 1, leafBase, [
+        ...paramNames,
+        segment.value
+      ]);
+    } else {
+      if (!node.p) {
+        node.p = { n: segment.value, c: {} };
+      }
+      insertSegments(node.p.c, segments, index + 1, leafBase, [
+        ...paramNames,
+        segment.value
+      ]);
+    }
+  } else if (segment.type === "wildcard") {
+    const wildLeaf = {
+      ...buildLeaf(leafBase, paramNames),
+      pn: segment.value,
+      ...segment.oneOrMore ? { w1: true } : {}
+    };
+    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;
+    }
+  }
+}
+
+// src/build/collect-fallback-refs.ts
+var CLIENT_REF = /* @__PURE__ */ Symbol.for("react.client.reference");
+var MAX_DEPTH = 40;
+var SYNTHETIC_PROPS = {
+  error: new Error("rango: build-time fallback-chunk discovery"),
+  reset: () => {
+  },
+  pathname: "/",
+  info: { componentStack: "" }
+};
+function isReactNodeLike(v) {
+  return Array.isArray(v) || typeof v === "object" && v !== null && "$$typeof" in v;
+}
+function walkElementTree(node, report, depth) {
+  if (node == null || depth > MAX_DEPTH) return;
+  if (Array.isArray(node)) {
+    for (const child of node) walkElementTree(child, report, depth + 1);
+    return;
+  }
+  if (typeof node !== "object") return;
+  const el = node;
+  const type = el.type;
+  if (type?.$$typeof === CLIENT_REF && typeof type.$$id === "string") {
+    report(type.$$id.split("#")[0]);
+  }
+  const props = el.props;
+  if (props && typeof props === "object") {
+    walkElementTree(props.children, report, depth + 1);
+    for (const key in props) {
+      if (key === "children") continue;
+      const value = props[key];
+      if (isReactNodeLike(value)) walkElementTree(value, report, depth + 1);
+    }
+  }
+}
+function collectFallbackClientRefs(boundary, report) {
+  try {
+    let node = boundary;
+    if (typeof node === "function") {
+      node = node(SYNTHETIC_PROPS);
+    }
+    walkElementTree(node, report, 0);
+  } catch {
+  }
+}
+
+// src/vite/utils/manifest-utils.ts
 function jsonParseExpression(value) {
   const json = JSON.stringify(value);
   const escaped = json.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -4108,6 +5262,9 @@ function jsonParseExpression(value) {
 }
 
 // src/context-var.ts
+function hasContextVars(variables) {
+  return Object.keys(variables).length > 0 || Object.getOwnPropertySymbols(variables).length > 0;
+}
 var NON_CACHEABLE_KEYS = /* @__PURE__ */ Symbol.for(
   "rango:non-cacheable-keys"
 );
@@ -4141,24 +5298,31 @@ function contextSet(variables, keyOrVar, value, options) {
 import { createHash as createHash4 } from "node:crypto";
 import {
   copyFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync,
   rmSync,
   statSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
-function escapeRegExp2(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+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 = escapeRegExp2(key);
+    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}(\\([^)]*\\))?(?!\\?)`),
@@ -4191,13 +5355,24 @@ async function runWithConcurrency(items, concurrency, fn) {
     return;
   }
   let nextIndex = 0;
+  let firstError;
+  let failed = false;
   async function worker() {
-    while (nextIndex < items.length) {
+    while (nextIndex < items.length && !failed) {
       const idx = nextIndex++;
-      await fn(items[idx]);
+      try {
+        await fn(items[idx]);
+      } catch (err) {
+        if (!failed) {
+          failed = true;
+          firstError = err;
+        }
+        return;
+      }
     }
   }
   await Promise.all(Array.from({ length: limit }, () => worker()));
+  if (failed) throw firstError;
 }
 function groupByConcurrency(entries) {
   const map = /* @__PURE__ */ new Map();
@@ -4244,8 +5419,25 @@ function notifyOnError(registry, error, phase, routeKey, pathname, skipped) {
     break;
   }
 }
+function resolvePrerenderError(registry, error, onError, label, elapsed, phase, routeKey, pathname) {
+  const isSkip = error?.name === "Skip";
+  if (isSkip || onError === "warn") {
+    if (isSkip) {
+      console.log(`[rango]   SKIP ${label} (${elapsed}ms) - ${error.message}`);
+    } else {
+      console.warn(
+        `[rango]   WARN ${label} (${elapsed}ms) - render error, not pre-rendered (prerender.onError: "warn"): ${error.message}`
+      );
+    }
+    notifyOnError(registry, error, phase, routeKey, pathname, true);
+    return;
+  }
+  console.error(`[rango]   FAIL ${label} (${elapsed}ms) - ${error.message}`);
+  notifyOnError(registry, error, phase, routeKey, pathname);
+  throw error;
+}
 function getStagedAssetDir(projectRoot) {
-  return resolve5(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 });
@@ -4255,8 +5447,8 @@ 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 = resolve5(stagedDir, fileName);
-  if (!existsSync4(filePath)) {
+  const filePath = resolve7(stagedDir, fileName);
+  if (!existsSync5(filePath)) {
     writeFileSync2(filePath, `export default ${exportValue};
 `);
   }
@@ -4264,12 +5456,12 @@ function stageBuildAssetModule(projectRoot, prefix, exportValue) {
 }
 function copyStagedBuildAssets(projectRoot, fileNames) {
   const stagedDir = getStagedAssetDir(projectRoot);
-  const distAssetsDir = resolve5(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 = resolve5(stagedDir, fileName);
-    const distPath = resolve5(distAssetsDir, fileName);
+    const stagedPath = resolve7(stagedDir, fileName);
+    const distPath = resolve7(distAssetsDir, fileName);
     copyFileSync(stagedPath, distPath);
     totalBytes += statSync(stagedPath).size;
   }
@@ -4360,7 +5552,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
                 (performance.now() - getParamsStart).toFixed(1)
               );
               const concurrency = def.options?.concurrency ?? 1;
-              const hasBuildVars = Object.keys(buildVars).length > 0 || Object.getOwnPropertySymbols(buildVars).length > 0;
+              const hasBuildVars = hasContextVars(buildVars);
               for (const params of paramsList) {
                 let url = substituteRouteParams(
                   pattern,
@@ -4445,6 +5637,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   const manifestEntries = {};
   let doneCount = 0;
   let skipCount = 0;
+  const prerenderOnError = state.opts?.prerenderOnError ?? "fail";
   const startTotal = performance.now();
   const groups = groupByConcurrency(entries);
   for (const group of groups) {
@@ -4487,10 +5680,9 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
               const interceptKey = `${result.routeName}/${paramHash}/i`;
               const interceptValue = JSON.stringify({
                 segments: [...result.segments, ...result.interceptSegments],
-                handles: {
-                  ...result.handles,
-                  ...result.interceptHandles || {}
-                }
+                // interceptHandles is the pre-encoded MERGED (main + intercept)
+                // handle string (the producer merged before encoding).
+                handles: result.interceptHandles ?? ""
               });
               manifestEntries[interceptKey] = stageBuildAssetModule(
                 state.projectRoot,
@@ -4505,34 +5697,19 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
             doneCount++;
             break;
           } catch (err) {
-            if (err.name === "Skip") {
-              const elapsed2 = (performance.now() - startUrl).toFixed(0);
-              console.log(
-                `[rango]   SKIP ${entry.urlPath.padEnd(40)} (${elapsed2}ms) - ${err.message}`
-              );
-              skipCount++;
-              notifyOnError(
-                registry,
-                err,
-                "prerender",
-                entry.routeName,
-                entry.urlPath,
-                true
-              );
-              break;
-            }
             const elapsed = (performance.now() - startUrl).toFixed(0);
-            console.error(
-              `[rango]   FAIL ${entry.urlPath.padEnd(40)} (${elapsed}ms) - ${err.message}`
-            );
-            notifyOnError(
+            resolvePrerenderError(
               registry,
               err,
+              prerenderOnError,
+              entry.urlPath.padEnd(40),
+              elapsed,
               "prerender",
               entry.routeName,
               entry.urlPath
             );
-            throw err;
+            skipCount++;
+            break;
           }
         }
       }
@@ -4567,6 +5744,7 @@ async function renderStaticHandlers(state, rscEnv, registry) {
   let staticDone = 0;
   let staticSkip = 0;
   let totalStaticCount = 0;
+  const prerenderOnError = state.opts?.prerenderOnError ?? "fail";
   for (const [, exportNames] of state.resolvedStaticModules) {
     totalStaticCount += exportNames.length;
   }
@@ -4600,7 +5778,7 @@ async function renderStaticHandlers(state, rscEnv, registry) {
             !state.isBuildMode
           );
           if (result) {
-            const hasHandles = Object.keys(result.handles).length > 0;
+            const hasHandles = result.handles !== "";
             const exportValue = hasHandles ? JSON.stringify(result) : JSON.stringify(result.encoded);
             manifestEntries[def.$$id] = stageBuildAssetModule(
               state.projectRoot,
@@ -4614,22 +5792,18 @@ async function renderStaticHandlers(state, rscEnv, registry) {
             break;
           }
         } catch (err) {
-          if (err.name === "Skip") {
-            const elapsed2 = (performance.now() - startHandler).toFixed(0);
-            console.log(
-              `[rango]   SKIP ${name.padEnd(40)} (${elapsed2}ms) - ${err.message}`
-            );
-            staticSkip++;
-            notifyOnError(registry, err, "static", void 0, void 0, true);
-            handled = true;
-            break;
-          }
           const elapsed = (performance.now() - startHandler).toFixed(0);
-          console.error(
-            `[rango]   FAIL ${name.padEnd(40)} (${elapsed}ms) - ${err.message}`
+          resolvePrerenderError(
+            registry,
+            err,
+            prerenderOnError,
+            name.padEnd(40),
+            elapsed,
+            "static"
           );
-          notifyOnError(registry, err, "static");
-          throw err;
+          staticSkip++;
+          handled = true;
+          break;
         }
       }
       if (!handled) {
@@ -4728,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);
@@ -4803,8 +5999,8 @@ async function discoverRouters(state, rscEnv) {
     computeProductionHash(state.projectRoot, refKey)
   ) : void 0;
   const collectFromBoundaryNode = (node) => {
-    if (collectClientFallbackRef && buildMod.collectFallbackClientRefs) {
-      buildMod.collectFallbackClientRefs(node, collectClientFallbackRef);
+    if (collectClientFallbackRef) {
+      collectFallbackClientRefs(node, collectClientFallbackRef);
     }
   };
   const manifestGenStart = debug10 ? performance.now() : 0;
@@ -4812,7 +6008,7 @@ async function discoverRouters(state, rscEnv) {
     if (!router.urlpatterns || !generateManifestFull) {
       continue;
     }
-    const manifest = generateManifestFull(
+    const manifest = await generateManifestFull(
       router.urlpatterns,
       routerMountIndex,
       {
@@ -4863,18 +6059,14 @@ async function discoverRouters(state, rscEnv) {
     if (manifest.routeTrailingSlash) {
       Object.assign(mergedRouteTrailingSlash, manifest.routeTrailingSlash);
     }
-    flattenLeafEntries(
-      manifest.prefixTree,
-      manifest.routeManifest,
-      newMergedPrecomputedEntries
-    );
-    newPerRouterManifestDataMap.set(id, manifest.routeManifest);
     const routerPrecomputed = [];
     flattenLeafEntries(
       manifest.prefixTree,
       manifest.routeManifest,
       routerPrecomputed
     );
+    newMergedPrecomputedEntries.push(...routerPrecomputed);
+    newPerRouterManifestDataMap.set(id, manifest.routeManifest);
     newPerRouterPrecomputedMap.set(id, routerPrecomputed);
     console.log(
       `[rango] Router "${id}" -> ${routeCount} routes (${staticRoutes} static, ${dynamicRoutes} dynamic)`
@@ -4898,8 +6090,7 @@ async function discoverRouters(state, rscEnv) {
   let newMergedRouteTrie = null;
   const trieStart = debug10 ? performance.now() : 0;
   if (Object.keys(newMergedRouteManifest).length > 0) {
-    const buildRouteTrie = buildMod.buildRouteTrie;
-    if (buildRouteTrie && mergedRouteAncestry) {
+    if (mergedRouteAncestry) {
       const routeToStaticPrefix = {};
       for (const { manifest } of allManifests) {
         for (const name of Object.keys(manifest.routeManifest)) {
@@ -4937,25 +6128,10 @@ async function discoverRouters(state, rscEnv) {
         mergedResponseTypeRoutes
       );
       for (const { id, manifest } of allManifests) {
-        if (!manifest._routeAncestry || Object.keys(manifest._routeAncestry).length === 0)
-          continue;
-        const perRouterStaticPrefix = {};
-        for (const name of Object.keys(manifest.routeManifest)) {
-          perRouterStaticPrefix[name] = "";
+        const perRouterTrie = buildPerRouterTrie(manifest);
+        if (perRouterTrie) {
+          newPerRouterTrieMap.set(id, perRouterTrie);
         }
-        buildRouteToStaticPrefix(manifest.prefixTree, perRouterStaticPrefix);
-        const perRouterPrerenderNames = manifest.prerenderRoutes ? new Set(manifest.prerenderRoutes) : void 0;
-        const perRouterPassthroughNames = manifest.passthroughRoutes ? new Set(manifest.passthroughRoutes) : void 0;
-        const perRouterTrie = buildRouteTrie(
-          manifest.routeManifest,
-          manifest._routeAncestry,
-          perRouterStaticPrefix,
-          manifest.routeTrailingSlash,
-          perRouterPrerenderNames,
-          perRouterPassthroughNames,
-          manifest.responseTypeRoutes
-        );
-        newPerRouterTrieMap.set(id, perRouterTrie);
       }
     }
   }
@@ -4975,9 +6151,46 @@ 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 join2, resolve as resolve6 } from "node:path";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, unlinkSync as unlinkSync2 } from "node:fs";
+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 = {};
   for (const [name, pattern] of Object.entries(manifest)) {
@@ -4988,7 +6201,7 @@ function filterUserNamedRoutes(manifest) {
   return filtered;
 }
 function writeGenFileIfChanged(state, outPath, source, opts) {
-  const existing = existsSync5(outPath) ? readFileSync4(outPath, "utf-8") : null;
+  const existing = existsSync6(outPath) ? readFileSync4(outPath, "utf-8") : null;
   if (existing === source) return;
   markSelfGenWrite(state, outPath, source);
   writeFileSync3(outPath, source);
@@ -5006,10 +6219,10 @@ function writeRouteTypesFiles(state) {
   if (state.perRouterManifests.length === 0) return;
   try {
     const entryDir = dirname3(
-      resolve6(state.projectRoot, state.resolvedEntryPath)
+      resolve8(state.projectRoot, state.resolvedEntryPath)
     );
-    const oldCombinedPath = join2(entryDir, "named-routes.gen.ts");
-    if (existsSync5(oldCombinedPath)) {
+    const oldCombinedPath = join4(entryDir, "named-routes.gen.ts");
+    if (existsSync6(oldCombinedPath)) {
       unlinkSync2(oldCombinedPath);
       console.log(
         `[rango] Removed stale combined route types: ${oldCombinedPath}`
@@ -5090,7 +6303,7 @@ function supplementGenFilesWithRuntimeRoutes(state) {
 }
 
 // src/vite/discovery/virtual-module-codegen.ts
-import { dirname as dirname4, basename, join as join3 } from "node:path";
+import { dirname as dirname4, basename, join as join5 } from "node:path";
 function generateRoutesManifestModule(state) {
   const hasManifest = state.mergedRouteManifest && Object.keys(state.mergedRouteManifest).length > 0;
   if (hasManifest) {
@@ -5105,7 +6318,7 @@ function generateRoutesManifestModule(state) {
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join3(
+        const genPath = join5(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
         ).replaceAll("\\", "/");
@@ -5190,7 +6403,7 @@ function generatePerRouterModule(state, routerId) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const genPath = join3(
+    const genPath = join5(
       routerDir,
       `${routerBasename}.named-routes.gen.js`
     ).replaceAll("\\", "/");
@@ -5213,17 +6426,17 @@ function generatePerRouterModule(state, routerId) {
       `export const precomputedEntries = ${jsonParseExpression(entries)};`
     );
   }
-  return lines.join("\n") || "// empty router manifest";
+  return lines.join("\n") || "";
 }
 
 // src/vite/discovery/bundle-postprocess.ts
-import { resolve as resolve7 } from "node:path";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "node:fs";
+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 = resolve7(
+  const rscEntryPath = resolve9(
     state.projectRoot,
     "dist/rsc",
     state.rscEntryFileName ?? "index.js"
@@ -5244,7 +6457,7 @@ function postprocessBundle(state) {
   ];
   for (const target of evictionTargets) {
     for (const info of target.infos) {
-      const chunkPath = resolve7(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(
@@ -5269,7 +6482,7 @@ function postprocessBundle(state) {
   }
   state.handlerChunkInfoMap.clear();
   state.staticHandlerChunkInfoMap.clear();
-  if (hasPrerenderData && existsSync6(rscEntryPath)) {
+  if (hasPrerenderData && existsSync7(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__prerender-manifest.js")) {
       try {
@@ -5284,12 +6497,12 @@ function postprocessBundle(state) {
           manifestMap[key] = `./assets/${assetFileName}`;
         }
         const manifestCode = [
-          `const m=JSON.parse('${JSON.stringify(manifestMap).replace(/'/g, "\\'")}');`,
+          `const m=${jsonParseExpression(manifestMap)};`,
           `export function loadPrerenderAsset(s){return import(s)}`,
           `export default m;`,
           ""
         ].join("\n");
-        const manifestPath = resolve7(
+        const manifestPath = resolve9(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js"
         );
@@ -5309,7 +6522,7 @@ function postprocessBundle(state) {
       }
     }
   }
-  if (hasStaticData && existsSync6(rscEntryPath)) {
+  if (hasStaticData && existsSync7(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__static-manifest.js")) {
       try {
@@ -5327,7 +6540,7 @@ function postprocessBundle(state) {
         }
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;
 `;
-        const manifestPath = resolve7(
+        const manifestPath = resolve9(
           state.projectRoot,
           "dist/rsc/__static-manifest.js"
         );
@@ -5359,8 +6572,8 @@ function createDiscoveryGate(s, debug11) {
   let pendingEvents = false;
   const beginGate = () => {
     if (gatePending) return;
-    s.discoveryDone = new Promise((resolve10) => {
-      gateResolver = resolve10;
+    s.discoveryDone = new Promise((resolve12) => {
+      gateResolver = resolve12;
     });
     gatePending = true;
   };
@@ -5452,15 +6665,15 @@ function selectForwardableResolvePlugins(plugins) {
 }
 function pickForwardedRunnerConfig(config) {
   const r = config.resolve ?? {};
-  const resolve10 = {};
-  if (r.alias !== void 0) resolve10.alias = r.alias;
-  if (r.dedupe !== void 0) resolve10.dedupe = r.dedupe;
-  if (r.conditions !== void 0) resolve10.conditions = r.conditions;
-  if (r.mainFields !== void 0) resolve10.mainFields = r.mainFields;
-  if (r.extensions !== void 0) resolve10.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)
-    resolve10.preserveSymlinks = r.preserveSymlinks;
-  if (r.tsconfigPaths !== void 0) resolve10.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" ? {
@@ -5468,7 +6681,7 @@ function pickForwardedRunnerConfig(config) {
     jsx: { ...userJsx, runtime: "automatic", importSource: "react" }
   } : { jsx: { runtime: "automatic", importSource: "react" } };
   return {
-    resolve: resolve10,
+    resolve: resolve12,
     define: config.define,
     oxc
   };
@@ -5546,11 +6759,11 @@ async function resolveBuildEnv(option, factoryCtx) {
       );
     }
     try {
-      const userRequire = createRequire2(
-        resolve8(factoryCtx.root, "package.json")
+      const userRequire = createRequire3(
+        resolve10(factoryCtx.root, "package.json")
       );
       const wranglerPath = userRequire.resolve("wrangler");
-      const { getPlatformProxy } = await import(pathToFileURL(wranglerPath).href);
+      const { getPlatformProxy } = await import(pathToFileURL2(wranglerPath).href);
       const proxy = await getPlatformProxy();
       return {
         env: proxy.env,
@@ -5602,16 +6815,17 @@ 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;
+      s.scanFilter = opts?.discovery ? createScanFilter(s.projectRoot, opts.discovery) : void 0;
       s.isBuildMode = config.command === "build";
       viteCommand = config.command;
       viteMode = config.mode;
@@ -5645,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((resolve10) => {
-        resolveDiscovery = resolve10;
+      const discoveryPromise = new Promise((resolve12) => {
+        resolveDiscovery = resolve12;
       });
       const gate = createDiscoveryGate(s, debugDiscovery);
       const beginDiscoveryGate = gate.beginGate;
@@ -5754,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) {
@@ -5805,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;
@@ -5814,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)",
@@ -5838,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?.(
@@ -5850,6 +7082,7 @@ ${err.stack}`
           resolveDiscovery();
           return;
         }
+        const optimizerHashBefore = rscEnv.depsOptimizer?.metadata?.browserHash;
         try {
           debugDiscovery?.("dev: node path start");
           await timed(
@@ -5859,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,
@@ -5882,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?.(
@@ -5900,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;
@@ -5969,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;
         }
@@ -5983,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,
@@ -5998,26 +7260,24 @@ ${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],
-                handles: {
-                  ...result.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) {
-            console.warn(
-              `[rango] Dev prerender failed for ${pathname}: ${err.message}`
-            );
+            if (err?.name !== "Skip") {
+              console.warn(
+                `[rango] Dev prerender error for ${pathname} (serving live instead): ${err.message}`
+              );
+            }
           }
         }
         res.statusCode = 404;
@@ -6224,7 +7484,7 @@ ${err.stack}`
             if (hasCreateRouter) {
               const nestedRouterConflict = findNestedRouterConflict([
                 ...s.cachedRouterFiles ?? [],
-                resolve8(filePath)
+                resolve10(filePath)
               ]);
               if (nestedRouterConflict) {
                 server.config.logger.error(
@@ -6536,7 +7796,11 @@ async function rango(options) {
   ];
   const pkg = getPublishedPackageName();
   const nested = (spec) => `${pkg} > ${spec}`;
-  const routerRef = { path: void 0 };
+  const routerRef = {
+    path: void 0,
+    kind: "router"
+  };
+  const explicitHostRouter = preset !== "cloudflare" ? resolvedOptions.hostRouter : void 0;
   const prerenderEnabled = true;
   if (preset === "cloudflare") {
     const { default: rsc } = await import("@vitejs/plugin-rsc");
@@ -6549,8 +7813,6 @@ async function rango(options) {
       enforce: "pre",
       config() {
         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,
             rolldownOptions: sharedRolldownOptions
@@ -6573,21 +7835,12 @@ async function rango(options) {
             client: {
               build: {
                 rollupOptions: {
-                  // FILE_NAME_CONFLICT (and any other client-build warning) is
-                  // emitted by the CLIENT environment build, which consults THIS
-                  // env's onwarn -- Vite 8's environment builds do NOT propagate
-                  // the top-level build.rollupOptions.onwarn into the client env.
-                  // Wire it here so the suppression runs where the conflicts
-                  // originate (the top-level handler is invoked 0x for these; the
-                  // client-env handler is invoked for all of them).
                   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,
@@ -6595,12 +7848,9 @@ async function rango(options) {
               }
             },
             ssr: {
-              // Build SSR inside RSC directory so wrangler can deploy self-contained dist/rsc
               build: {
                 outDir: "./dist/rsc/ssr"
               },
-              // 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: [
@@ -6620,10 +7870,7 @@ async function rango(options) {
               }
             },
             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",
@@ -6661,17 +7908,49 @@ async function rango(options) {
       name: "@rangojs/router:auto-discover",
       config(userConfig) {
         if (routerRef.path) return;
-        const root = userConfig.root ? resolve9(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 = normalizeHostRouterEntry(
+            explicitHostRouter,
+            root,
+            existsSync8
+          );
+          routerRef.kind = "host";
+          return;
+        }
+        const hostCandidates = findHostRouterFiles(root);
+        if (hostCandidates.length === 1) {
+          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;
+        }
+        if (hostCandidates.length > 1) {
+          throw new Error(
+            `[rango] Multiple host routers found:
+${bulletList(hostCandidates)}
+
+Set the \`hostRouter\` option to the entry to serve, e.g. rango({ preset: "${preset}", hostRouter: "./src/worker.rsc.tsx" }).`
+          );
+        }
         const candidates = findRouterFiles(root);
         if (candidates.length === 1) {
-          const abs = candidates[0];
-          routerRef.path = (abs.startsWith(root) ? "./" + abs.slice(root.length + 1) : abs).replaceAll("\\", "/");
-        } else if (candidates.length > 1) {
-          const list = candidates.map(
-            (f) => "  - " + (f.startsWith(root) ? f.slice(root.length + 1) : f)
-          ).join("\n");
-          throw new Error(`[rango] Multiple routers found:
-${list}`);
+          routerRef.path = toRootRelative(candidates[0]);
+          routerRef.kind = "router";
+          return;
+        }
+        if (candidates.length > 1) {
+          throw new Error(
+            `[rango] Multiple routers found:
+${bulletList(candidates)}
+
+If this is a multi-app host router, export a createHostRouter() instance and set the \`hostRouter\` option (e.g. rango({ preset: "${preset}", hostRouter: "./src/worker.rsc.tsx" })), or use preset: "cloudflare" where you own the worker entry.`
+          );
         }
       }
     });
@@ -6685,8 +7964,11 @@ ${list}`);
     plugins.push({
       name: "@rangojs/router:rsc-integration",
       enforce: "pre",
-      config() {
+      config(_userConfig, configEnv) {
+        const vercelDefine = preset === "vercel" && configEnv.command === "build" ? { "process.env.NODE_ENV": JSON.stringify("production") } : void 0;
+        const vercelServerEnv = preset === "vercel" && configEnv.command === "build" ? { resolve: { noExternal: true } } : void 0;
         return {
+          ...vercelDefine ? { define: vercelDefine } : {},
           optimizeDeps: {
             exclude: excludeDeps,
             rolldownOptions: sharedRolldownOptions
@@ -6709,13 +7991,6 @@ ${list}`);
             client: {
               build: {
                 rollupOptions: {
-                  // FILE_NAME_CONFLICT (and any other client-build warning) is
-                  // emitted by the CLIENT environment build, which consults THIS
-                  // env's onwarn -- Vite 8's environment builds do NOT propagate
-                  // the top-level build.rollupOptions.onwarn into the client env.
-                  // Wire it here so the suppression runs where the conflicts
-                  // originate (the top-level handler is invoked 0x for these; the
-                  // client-env handler is invoked for all of them).
                   onwarn,
                   output: {
                     manualChunks: getManualChunks
@@ -6736,6 +8011,7 @@ ${list}`);
               }
             },
             ssr: {
+              ...vercelServerEnv ?? {},
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.ssr],
                 include: [
@@ -6754,6 +8030,7 @@ ${list}`);
               }
             },
             rsc: {
+              ...vercelServerEnv ?? {},
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.rsc],
                 include: [
@@ -6764,6 +8041,12 @@ ${list}`);
                     "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
                   )
                 ],
+                // 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
               }
             }
@@ -6773,7 +8056,11 @@ ${list}`);
       configResolved(config) {
         if (showBanner) {
           const mode = config.command === "serve" ? process.argv.includes("preview") ? "preview" : "dev" : "build";
-          printBanner(mode, "node", rangoVersion);
+          printBanner(
+            mode,
+            preset === "vercel" ? "vercel" : "node",
+            rangoVersion
+          );
         }
         const rscMinimalCount = config.plugins.filter(
           (p) => p.name === "rsc:minimal"
@@ -6806,8 +8093,7 @@ ${list}`);
         return;
       try {
         const source = readFileSync7(file, "utf-8");
-        const trimmed = source.trimStart();
-        if (trimmed.startsWith('"use client"') || trimmed.startsWith("'use client'")) {
+        if (hasUseClientDirective(source)) {
           return [];
         }
       } catch {
@@ -6831,9 +8117,16 @@ ${list}`);
       enableBuildPrerender: prerenderEnabled,
       buildEnv: options?.buildEnv,
       preset,
+      prerenderOnError: options?.prerender?.onError,
+      discovery: options?.discovery,
       clientChunkCtx
     })
   );
+  if (preset === "vercel") {
+    plugins.push(
+      createVercelOutputPlugin(resolvedOptions)
+    );
+  }
   debugConfig?.(
     "rango(%s) setup done: %d plugin(s) (%sms)",
     preset,
@@ -6846,7 +8139,7 @@ ${list}`);
 // src/vite/plugins/refresh-cmd.ts
 function poke() {
   return {
-    name: "vite-plugin-poke",
+    name: "@rangojs/router:poke",
     apply: "serve",
     configureServer(server) {
       const stdin = process.stdin;
@@ -6924,6 +8217,7 @@ function poke() {
   };
 }
 export {
+  directoryClientChunks,
   poke,
   rango
 };