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

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 { resolve as resolve10 } 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)
   );
 }
 
@@ -2096,6 +2257,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 +2278,63 @@ export default function handler(request, env) {
 }
 `.trim();
 }
+function getVirtualEntryRSCHost(hostEntryPath) {
+  return `
+import * as __hostEntry from "${hostEntryPath}";
+import { NoRouteMatchError } 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 here.
+// We require BOTH .match() and .host(): a regular createRouter() also exposes
+// .match(), so matching on .match() alone would accept an ordinary router and then
+// return its MatchResult (not a Response) at runtime. .host() is unique to a
+// HostRouter, so it disambiguates a mistaken \`hostRouter\` path at build time.
+// 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;
+};
+const hostRouter = __resolveHostRouter(__hostEntry);
+
+if (!hostRouter) {
+  throw new Error(
+    "[rango] The host entry (${hostEntryPath}) must export a HostRouter instance (createHostRouter()) for the node/vercel preset: a default export, or a named 'hostRouter'/'router' export. An ordinary createRouter() is not a host router (it has no .host()), and a Cloudflare-style 'export default { fetch }' object is not supported on this preset."
+  );
+}
+
+// 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) {
+  try {
+    return await hostRouter.match(request, input);
+  } catch (err) {
+    if (err instanceof NoRouteMatchError) {
+      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 +2353,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.e16b7c00",
+  version: "0.0.0-experimental.e9c0b2f2",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -2240,6 +2463,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"
@@ -2256,6 +2489,31 @@ var package_default = {
     "./host/testing": {
       types: "./src/host/testing.ts",
       default: "./src/host/testing.ts"
+    },
+    "./testing": {
+      types: "./src/testing/index.ts",
+      default: "./src/testing/index.ts"
+    },
+    "./testing/vitest": {
+      types: "./src/testing/vitest.ts",
+      default: "./dist/testing/vitest.js"
+    },
+    "./testing/dom": {
+      types: "./src/testing/dom.entry.ts",
+      default: "./src/testing/dom.entry.ts"
+    },
+    "./testing/e2e": {
+      types: "./src/testing/e2e/index.ts",
+      default: "./src/testing/e2e/index.ts"
+    },
+    "./testing/flight": {
+      types: "./src/testing/flight.entry.ts",
+      "react-server": "./src/testing/flight.entry.ts",
+      default: "./src/testing/flight.entry.ts"
+    },
+    "./testing/flight-matchers": {
+      types: "./src/testing/flight-matchers.ts",
+      default: "./src/testing/flight-matchers.ts"
     }
   },
   publishConfig: {
@@ -2263,51 +2521,80 @@ 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/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",
     "test:ui": "playwright test --ui",
     "test:hmr-local": "playwright test --project=dev-warmup --project=hmr-routes --project=hmr-basename --project=hmr-prerender --no-deps --workers=1",
     "test:unit": "vitest run",
-    "test:unit:watch": "vitest"
+    "test:unit:watch": "vitest",
+    "test:unit:rsc": "vitest run --config vitest.rsc.config.ts"
   },
   dependencies: {
     "@types/debug": "^4.1.12",
     "@vitejs/plugin-rsc": "^0.5.26",
     debug: "^4.4.1",
     "magic-string": "^0.30.17",
-    picomatch: "^4.0.3",
-    "rsc-html-stream": "^0.0.7"
+    picomatch: "^4.0.4",
+    "rsc-html-stream": "^0.0.7",
+    srvx: "^0.11.15",
+    tinyexec: "^0.3.2"
   },
   devDependencies: {
+    "@opentelemetry/api": "^1.9.0",
     "@playwright/test": "^1.49.1",
     "@shared/e2e": "workspace:*",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
     "@types/node": "^24.10.1",
     "@types/react": "catalog:",
     "@types/react-dom": "catalog:",
     esbuild: "^0.27.0",
+    "happy-dom": "^20.10.1",
     jiti: "^2.6.1",
     react: "catalog:",
     "react-dom": "catalog:",
-    tinyexec: "^0.3.2",
     typescript: "^5.3.0",
     vitest: "^4.0.0"
   },
   peerDependencies: {
     "@cloudflare/vite-plugin": "^1.38.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@playwright/test": "^1.49.1",
+    "@testing-library/react": ">=16",
+    "@vercel/functions": "^3.0.0",
     "@vitejs/plugin-rsc": "^0.5.26",
     react: ">=19.2.6 <20",
     "react-dom": ">=19.2.6 <20",
-    vite: "^8.0.0"
+    vite: "^8.0.0",
+    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"
   }
 };
 
@@ -2381,10 +2668,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
@@ -2410,8 +2697,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,
@@ -2491,16 +2778,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";
@@ -2509,6 +2824,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];
@@ -2524,8 +2866,8 @@ function extractNamePrefixFromInclude(node) {
   }
   return null;
 }
-function extractIncludesWithDiagnostics(code) {
-  const sourceFile = ts3.createSourceFile(
+function extractIncludesWithDiagnostics(code, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
     code,
     ts3.ScriptTarget.Latest,
@@ -2579,7 +2921,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];
@@ -2616,8 +2958,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,
@@ -2639,16 +2981,20 @@ 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 });
@@ -2675,12 +3021,15 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
         targetFile,
         imported.exportedName,
         visited,
-        diagnosticsOut
+        diagnosticsOut,
+        void 0,
+        memo
       );
     } else {
       const sameFileBlock = extractUrlsBlockForVariable(
         fullSource,
-        variableName
+        variableName,
+        parseBlock(memo, fullSource)
       );
       if (!sameFileBlock) {
         if (diagnosticsOut) {
@@ -2698,7 +3047,9 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
         filePath,
         variableName,
         visited,
-        diagnosticsOut
+        diagnosticsOut,
+        void 0,
+        memo
       );
     }
     if (namePrefix === null) {
@@ -2722,8 +3073,9 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
-function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut, inlineBlock) {
+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)) {
@@ -2733,7 +3085,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: {} };
   }
@@ -2741,7 +3093,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 {
@@ -2754,7 +3110,8 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
     realPath,
     visited,
     searchSchemas,
-    diagnosticsOut
+    diagnosticsOut,
+    memo
   );
   visited.delete(key);
   return { routes, searchSchemas };
@@ -2769,7 +3126,7 @@ import {
   readdirSync
 } from "node:fs";
 import {
-  join,
+  join as join2,
   dirname as dirname2,
   resolve as resolve3,
   sep,
@@ -2792,7 +3149,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 });
@@ -2803,32 +3163,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) {
@@ -2965,7 +3329,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) {
@@ -3026,12 +3390,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(
@@ -3092,7 +3477,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);
 }
@@ -3100,23 +3506,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;
@@ -3241,7 +3637,6 @@ function createVersionPlugin() {
       }
       return null;
     },
-    // Track RSC module changes and update version
     async hotUpdate(ctx) {
       if (!isDev) return;
       const isRscModule = this.environment?.name === "rsc";
@@ -3318,9 +3713,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;
@@ -3408,7 +3800,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;
@@ -3463,7 +3855,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/";
@@ -3480,10 +3872,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 {
@@ -3510,7 +3902,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";
@@ -3588,6 +3979,190 @@ function resolveClientChunks(option, 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 resolve4, 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.`
+    );
+  }
+}
+async function assemble(root, options) {
+  const vercel = options.vercel ?? {};
+  assertVercelNodeRuntime(vercel.runtime);
+  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";
+  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.');
+  }
+  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;
+  }
+  await writeFile(
+    join3(funcDir, "package.json"),
+    JSON.stringify({ type: "module" }, null, 2) + "\n"
+  );
+  const vcConfig = {
+    runtime: vercel.runtime ?? "nodejs22.x",
+    handler: "index.mjs",
+    launcherType: "Nodejs",
+    shouldAddHelpers: false,
+    supportsResponseStreaming: true,
+    maxDuration: vercel.maxDuration ?? 30
+  };
+  if (vercel.memory != null) vcConfig.memory = vercel.memory;
+  if (vercel.regions != null) vcConfig.regions = vercel.regions;
+  await writeFile(
+    join3(funcDir, ".vc-config.json"),
+    JSON.stringify(vcConfig, null, 2) + "\n"
+  );
+  await writeFile(
+    join3(out, "config.json"),
+    JSON.stringify(
+      {
+        version: 3,
+        routes: [
+          { handle: "filesystem" },
+          { src: "/(.*)", dest: `/${functionName}` }
+        ]
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  console.log(
+    `[rango] assembled .vercel/output (function: ${functionName}.func)`
+  );
+}
+function createVercelOutputPlugin(options) {
+  let root = process.cwd();
+  let isBuild = false;
+  return {
+    name: "@rangojs/router:vercel-output",
+    configResolved(config) {
+      root = resolve4(config.root);
+      isBuild = config.command === "build";
+    },
+    // 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);
+      }
+    }
+  };
+}
+
 // src/vite/utils/banner.ts
 var rangoVersion = package_default.version;
 var _bannerPrinted = false;
@@ -3615,7 +4190,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 resolve5 } from "node:path";
 import * as Vite2 from "vite";
 function createVersionInjectorPlugin(rscEntryPath) {
   let resolvedEntryPath = "";
@@ -3626,7 +4201,7 @@ function createVersionInjectorPlugin(rscEntryPath) {
       let entryPath = rscEntryPath;
       if (!entryPath) entryPath = resolveRscEntryFromConfig(config);
       if (entryPath) {
-        resolvedEntryPath = resolve4(config.root, entryPath);
+        resolvedEntryPath = resolve5(config.root, entryPath);
       }
     },
     transform(code, id) {
@@ -3674,13 +4249,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 {
@@ -3731,10 +4310,10 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } 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/plugins/virtual-stub-plugin.ts
 function createVirtualStubPlugin() {
@@ -4019,7 +4598,50 @@ 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 __RANGO_DEBUG__ !== "undefined" ? __RANGO_DEBUG__ : typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_DEBUG);
+
+// src/router/logging.ts
+var routerLogContext = new AsyncLocalStorage();
+
+// src/router/pattern-matching.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,
+      suffix,
+      wildcard,
+      staticText
+    ] = match;
+    if (wildcard) {
+      segments.push({ type: "wildcard", value: "*", optional: false });
+    } else if (paramName) {
+      segments.push({
+        type: "param",
+        value: paramName,
+        optional: optional === "?",
+        constraint: constraint ? constraint.split("|") : void 0,
+        suffix: suffix || void 0
+      });
+    } else if (staticText) {
+      segments.push({ type: "static", value: staticText, optional: false });
+    }
+  }
+  return segments;
+}
+
+// src/build/prefix-tree-utils.ts
 function flattenLeafEntries(prefixTree, routeManifest, result) {
   function visit(node, ancestorStaticPrefixes) {
     const children = node.children || {};
@@ -4060,6 +4682,219 @@ 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: "*"
+    };
+    const existing = node.w ? { ...node.w } : void 0;
+    const merged = mergeLeaves(existing, 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, "\\'");
@@ -4067,6 +4902,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"
 );
@@ -4100,16 +4938,13 @@ 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 resolve6 } from "node:path";
 function encodePathParam(value) {
   return String(value).split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
@@ -4117,7 +4952,7 @@ 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);
     if (value === "") {
       result = result.replace(
         new RegExp(`:${escaped}(\\([^)]*\\))?(?!\\?)`),
@@ -4150,13 +4985,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();
@@ -4203,8 +5049,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 resolve6(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
 }
 function resetStagedBuildAssets(projectRoot) {
   rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
@@ -4214,8 +5077,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 = resolve6(stagedDir, fileName);
+  if (!existsSync5(filePath)) {
     writeFileSync2(filePath, `export default ${exportValue};
 `);
   }
@@ -4223,12 +5086,12 @@ function stageBuildAssetModule(projectRoot, prefix, exportValue) {
 }
 function copyStagedBuildAssets(projectRoot, fileNames) {
   const stagedDir = getStagedAssetDir(projectRoot);
-  const distAssetsDir = resolve5(projectRoot, "dist/rsc/assets");
+  const distAssetsDir = resolve6(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 = resolve6(stagedDir, fileName);
+    const distPath = resolve6(distAssetsDir, fileName);
     copyFileSync(stagedPath, distPath);
     totalBytes += statSync(stagedPath).size;
   }
@@ -4319,7 +5182,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,
@@ -4404,6 +5267,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) {
@@ -4446,10 +5310,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,
@@ -4464,34 +5327,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;
           }
         }
       }
@@ -4526,6 +5374,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;
   }
@@ -4559,7 +5408,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,
@@ -4573,22 +5422,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) {
@@ -4762,8 +5607,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;
@@ -4822,18 +5667,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)`
@@ -4857,8 +5698,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)) {
@@ -4896,25 +5736,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);
       }
     }
   }
@@ -4935,8 +5760,8 @@ async function discoverRouters(state, rscEnv) {
 }
 
 // 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 resolve7 } 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)) {
@@ -4947,7 +5772,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);
@@ -4965,10 +5790,10 @@ function writeRouteTypesFiles(state) {
   if (state.perRouterManifests.length === 0) return;
   try {
     const entryDir = dirname3(
-      resolve6(state.projectRoot, state.resolvedEntryPath)
+      resolve7(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}`
@@ -5049,7 +5874,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) {
@@ -5064,7 +5889,7 @@ function generateRoutesManifestModule(state) {
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join3(
+        const genPath = join5(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
         ).replaceAll("\\", "/");
@@ -5149,7 +5974,7 @@ function generatePerRouterModule(state, routerId) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const genPath = join3(
+    const genPath = join5(
       routerDir,
       `${routerBasename}.named-routes.gen.js`
     ).replaceAll("\\", "/");
@@ -5172,17 +5997,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 resolve8 } 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 = resolve8(
     state.projectRoot,
     "dist/rsc",
     state.rscEntryFileName ?? "index.js"
@@ -5203,7 +6028,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 = resolve8(state.projectRoot, "dist/rsc", info.fileName);
       try {
         const code = readFileSync5(chunkPath, "utf-8");
         const result = evictHandlerCode(
@@ -5228,7 +6053,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 {
@@ -5243,12 +6068,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 = resolve8(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js"
         );
@@ -5268,7 +6093,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 {
@@ -5286,7 +6111,7 @@ function postprocessBundle(state) {
         }
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;
 `;
-        const manifestPath = resolve7(
+        const manifestPath = resolve8(
           state.projectRoot,
           "dist/rsc/__static-manifest.js"
         );
@@ -5318,8 +6143,8 @@ function createDiscoveryGate(s, debug11) {
   let pendingEvents = false;
   const beginGate = () => {
     if (gatePending) return;
-    s.discoveryDone = new Promise((resolve10) => {
-      gateResolver = resolve10;
+    s.discoveryDone = new Promise((resolve11) => {
+      gateResolver = resolve11;
     });
     gatePending = true;
   };
@@ -5411,15 +6236,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 resolve11 = {};
+  if (r.alias !== void 0) resolve11.alias = r.alias;
+  if (r.dedupe !== void 0) resolve11.dedupe = r.dedupe;
+  if (r.conditions !== void 0) resolve11.conditions = r.conditions;
+  if (r.mainFields !== void 0) resolve11.mainFields = r.mainFields;
+  if (r.extensions !== void 0) resolve11.extensions = r.extensions;
   if (r.preserveSymlinks !== void 0)
-    resolve10.preserveSymlinks = r.preserveSymlinks;
-  if (r.tsconfigPaths !== void 0) resolve10.tsconfigPaths = r.tsconfigPaths;
+    resolve11.preserveSymlinks = r.preserveSymlinks;
+  if (r.tsconfigPaths !== void 0) resolve11.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" ? {
@@ -5427,7 +6252,7 @@ function pickForwardedRunnerConfig(config) {
     jsx: { ...userJsx, runtime: "automatic", importSource: "react" }
   } : { jsx: { runtime: "automatic", importSource: "react" } };
   return {
-    resolve: resolve10,
+    resolve: resolve11,
     define: config.define,
     oxc
   };
@@ -5505,11 +6330,11 @@ async function resolveBuildEnv(option, factoryCtx) {
       );
     }
     try {
-      const userRequire = createRequire2(
-        resolve8(factoryCtx.root, "package.json")
+      const userRequire = createRequire3(
+        resolve9(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,
@@ -5571,6 +6396,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
     },
     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;
@@ -5605,8 +6431,8 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       if (globalThis.__rscRouterDiscoveryActive) return;
       s.devServer = server;
       let resolveDiscovery;
-      const discoveryPromise = new Promise((resolve10) => {
-        resolveDiscovery = resolve10;
+      const discoveryPromise = new Promise((resolve11) => {
+        resolveDiscovery = resolve11;
       });
       const gate = createDiscoveryGate(s, debugDiscovery);
       const beginDiscoveryGate = gate.beginGate;
@@ -5962,10 +6788,9 @@ ${err.stack}`
             if (wantIntercept && result.interceptSegments?.length) {
               payload = {
                 segments: [...result.segments, ...result.interceptSegments],
-                handles: {
-                  ...result.handles,
-                  ...result.interceptHandles || {}
-                }
+                // Pre-encoded MERGED handle string from the producer (handles are
+                // Flight-encoded so Promise/ReactNode values survive the wire).
+                handles: result.interceptHandles ?? ""
               };
             } else {
               payload = { segments: result.segments, handles: result.handles };
@@ -5974,9 +6799,11 @@ ${err.stack}`
             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;
@@ -6183,7 +7010,7 @@ ${err.stack}`
             if (hasCreateRouter) {
               const nestedRouterConflict = findNestedRouterConflict([
                 ...s.cachedRouterFiles ?? [],
-                resolve8(filePath)
+                resolve9(filePath)
               ]);
               if (nestedRouterConflict) {
                 server.config.logger.error(
@@ -6495,7 +7322,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");
@@ -6508,8 +7339,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
@@ -6532,21 +7361,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,
@@ -6554,12 +7374,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: [
@@ -6579,10 +7396,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",
@@ -6620,17 +7434,41 @@ 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 ? resolve10(process.cwd(), userConfig.root) : process.cwd();
+        const toRootRelative = (abs) => (abs.startsWith(root) ? "./" + abs.slice(root.length + 1) : abs).replaceAll("\\", "/");
+        const bulletList = (files) => files.map((f) => "  - " + toRootRelative(f)).join("\n");
+        if (explicitHostRouter) {
+          routerRef.path = explicitHostRouter.replaceAll("\\", "/");
+          routerRef.kind = "host";
+          return;
+        }
+        const hostCandidates = findHostRouterFiles(root);
+        if (hostCandidates.length === 1) {
+          routerRef.path = toRootRelative(hostCandidates[0]);
+          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.`
+          );
         }
       }
     });
@@ -6644,8 +7482,12 @@ ${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" ? { resolve: { noExternal: true } } : void 0;
+        const vercelServerInclude = preset === "vercel" && configEnv.command === "serve" ? ["@vercel/functions"] : [];
         return {
+          ...vercelDefine ? { define: vercelDefine } : {},
           optimizeDeps: {
             exclude: excludeDeps,
             rolldownOptions: sharedRolldownOptions
@@ -6668,13 +7510,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
@@ -6695,6 +7530,7 @@ ${list}`);
               }
             },
             ssr: {
+              ...vercelServerEnv ?? {},
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.ssr],
                 include: [
@@ -6706,13 +7542,15 @@ ${list}`);
                   "react/jsx-dev-runtime",
                   nested(
                     "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
-                  )
+                  ),
+                  ...vercelServerInclude
                 ],
                 exclude: excludeDeps,
                 rolldownOptions: sharedRolldownOptions
               }
             },
             rsc: {
+              ...vercelServerEnv ?? {},
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.rsc],
                 include: [
@@ -6721,8 +7559,15 @@ ${list}`);
                   "react/jsx-dev-runtime",
                   nested(
                     "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
-                  )
+                  ),
+                  ...vercelServerInclude
                 ],
+                // Vite 8 does not propagate the top-level optimizeDeps.exclude
+                // (set in config()) to non-client envs, so the rsc env must set
+                // 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
               }
             }
@@ -6732,7 +7577,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"
@@ -6765,8 +7614,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 {
@@ -6790,9 +7638,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,
@@ -6805,7 +7660,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;