@rangojs/router 0.0.0-experimental.f2337aef → 0.0.0-experimental.f2d1a2f1

package/dist/vite/index.js

@@ -18,6 +18,9 @@ function hashId(filePath, exportName) {
   const hash = crypto.createHash("sha256").update(input).digest("hex");
   return `${hash.slice(0, 8)}#${exportName}`;
 }
+function makeStubId(filePath, exportName, isBuild) {
+  return isBuild ? hashId(filePath, exportName) : `${filePath}#${exportName}`;
+}
 function hashInlineId(filePath, lineNumber, index) {
   const input = index !== void 0 && index > 0 ? `${filePath}:${lineNumber}:${index}` : `${filePath}:${lineNumber}`;
   return crypto.createHash("sha256").update(input).digest("hex").slice(0, 8);
@@ -292,7 +295,7 @@ function exposeActionId() {
       }
       if (!rscPluginApi) {
         throw new Error(
-          "[rsc-router] Could not find @vitejs/plugin-rsc. @rangojs/router requires the Vite RSC plugin.\nThe RSC plugin should be included automatically. If you disabled it with\nrango({ rsc: false }), add rsc() before rango() in your config."
+          "[rsc-router] Could not find @vitejs/plugin-rsc. @rangojs/router requires the Vite RSC plugin, which is included automatically by rango()."
         );
       }
       if (!isBuild) return;
@@ -910,9 +913,7 @@ function generateWholeFileStubs(cfg, bindings, code, filePath, isBuild) {
   });
   return { code: stubs.join("\n") + "\n", map: null };
 }
-function generateExprStubs(cfg, bindings, code, filePath, sourceId, isBuild) {
-  if (bindings.length === 0) return null;
-  const s = new MagicString2(code);
+function stubHandlerExprs(cfg, bindings, s, filePath, isBuild) {
   let hasChanges = false;
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
@@ -924,15 +925,7 @@ function generateExprStubs(cfg, bindings, code, filePath, sourceId, isBuild) {
     );
     hasChanges = true;
   }
-  if (!hasChanges) return null;
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      source: sourceId,
-      includeContent: true,
-      hires: "boundary"
-    })
-  };
+  return hasChanges;
 }
 function transformHandlerIds(cfg, bindings, s, filePath, isBuild) {
   let hasChanges = false;
@@ -1269,15 +1262,6 @@ ${lazyImports.join(",\n")}
           isBuild
         );
         if (wholeFile) return wholeFile;
-        const exprStubs = generateExprStubs(
-          PRERENDER_CONFIG,
-          bindings,
-          code,
-          filePath,
-          id,
-          isBuild
-        );
-        if (exprStubs) return exprStubs;
       }
       if (hasPrerenderHandlerCode && isRscEnv && isBuild) {
         const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
@@ -1329,15 +1313,134 @@ ${lazyImports.join(",\n")}
           isBuild
         );
         if (wholeFile) return wholeFile;
-        const exprStubs = generateExprStubs(
-          STATIC_CONFIG,
-          bindings,
-          code,
-          filePath,
-          id,
-          isBuild
-        );
-        if (exprStubs) return exprStubs;
+      }
+      if (!isRscEnv && (hasPrerenderHandlerCode || hasStaticHandlerCode)) {
+        const prerenderFnNames = hasPrerenderHandlerCode ? getFnNames(PRERENDER_CONFIG.fnName) : [];
+        const staticFnNames = hasStaticHandlerCode ? getFnNames(STATIC_CONFIG.fnName) : [];
+        const loaderFnNames = hasLoaderCode ? getFnNames("createLoader") : [];
+        const handleFnNames = hasHandleCode ? getFnNames("createHandle") : [];
+        const lsFnNames = hasLocationStateCode ? getFnNames("createLocationState") : [];
+        const allBindings = [];
+        for (const fnNames of [
+          prerenderFnNames,
+          staticFnNames,
+          loaderFnNames,
+          handleFnNames,
+          lsFnNames
+        ]) {
+          if (fnNames.length > 0) {
+            allBindings.push(...getBindings(code, fnNames));
+          }
+        }
+        let canStubWholeFile = allBindings.length > 0 && isExportOnlyFile(code, allBindings);
+        if (canStubWholeFile && (handleFnNames.length > 0 || lsFnNames.length > 0)) {
+          const exportedLocals = new Set(allBindings.map((b) => b.localName));
+          const strippedBindings = [];
+          const localDeclPattern = /(?:^|;|\n)\s*(?:const|let|var|function)\s+(\w+)/g;
+          let declMatch;
+          while ((declMatch = localDeclPattern.exec(code)) !== null) {
+            const name = declMatch[1];
+            if (!exportedLocals.has(name) && !/^_c\d*$/.test(name)) {
+              strippedBindings.push(name);
+            }
+          }
+          const importPattern = /import\s*\{([^}]*)\}\s*from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+          let importMatch;
+          while ((importMatch = importPattern.exec(code)) !== null) {
+            for (const spec of importMatch[1].split(",")) {
+              const m = spec.trim().match(/^[A-Za-z_$][\w$]*(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+              if (m) strippedBindings.push(m[1] || m[0].trim().split(/\s/)[0]);
+            }
+          }
+          const defaultImportPattern = /import\s+([A-Za-z_$][\w$]*)\s+from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+          while ((importMatch = defaultImportPattern.exec(code)) !== null) {
+            strippedBindings.push(importMatch[1]);
+          }
+          const nsImportPattern = /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+          while ((importMatch = nsImportPattern.exec(code)) !== null) {
+            strippedBindings.push(importMatch[1]);
+          }
+          if (strippedBindings.length > 0) {
+            const preservedBindings = allBindings.filter((b) => {
+              const fc = code.slice(b.callExprStart, b.callOpenParenPos + 1);
+              return handleFnNames.some((n) => fc.includes(n)) || lsFnNames.some((n) => fc.includes(n));
+            });
+            const strippedRe = new RegExp(
+              `\\b(?:${strippedBindings.join("|")})\\b`
+            );
+            canStubWholeFile = !preservedBindings.some((b) => {
+              const expr = code.slice(b.callExprStart, b.callCloseParenPos + 1);
+              return strippedRe.test(expr);
+            });
+          }
+        }
+        if (canStubWholeFile) {
+          const lines = [];
+          const neededImports = [];
+          if (handleFnNames.length > 0) neededImports.push("createHandle");
+          if (lsFnNames.length > 0) neededImports.push("createLocationState");
+          if (neededImports.length > 0) {
+            lines.push(
+              `import { ${neededImports.join(", ")} } from "@rangojs/router";`
+            );
+          }
+          for (const binding of allBindings) {
+            const fnCall = code.slice(
+              binding.callExprStart,
+              binding.callOpenParenPos + 1
+            );
+            const isHandle = handleFnNames.some((n) => fnCall.includes(n));
+            const isLocationState = lsFnNames.some((n) => fnCall.includes(n));
+            const primaryName = binding.exportNames[0];
+            const stubId = makeStubId(filePath, primaryName, isBuild);
+            if (isHandle || isLocationState) {
+              const rawArgs = code.slice(binding.callOpenParenPos + 1, binding.callCloseParenPos).replace(/\b_c\d*\s*=\s*/g, "");
+              const canonicalName = isHandle ? "createHandle" : "createLocationState";
+              const activeFnNames = isHandle ? handleFnNames : lsFnNames;
+              let rawCallee = code.slice(
+                binding.callExprStart,
+                binding.callOpenParenPos
+              );
+              for (const alias of activeFnNames) {
+                if (alias !== canonicalName && rawCallee.startsWith(alias)) {
+                  rawCallee = canonicalName + rawCallee.slice(alias.length);
+                  break;
+                }
+              }
+              if (isHandle) {
+                const idParam = binding.argCount === 0 ? `undefined, "${stubId}"` : `, "${stubId}"`;
+                lines.push(
+                  `export const ${primaryName} = ${rawCallee}(${rawArgs}${idParam});`
+                );
+                lines.push(`${primaryName}.$$id = "${stubId}";`);
+              } else {
+                lines.push(
+                  `export const ${primaryName} = ${rawCallee}(${rawArgs});`
+                );
+                lines.push(
+                  `${primaryName}.__rsc_ls_key = "__rsc_ls_${stubId}";`
+                );
+              }
+              for (const name of binding.exportNames.slice(1)) {
+                lines.push(`export const ${name} = ${primaryName};`);
+              }
+            } else {
+              let brand = "loader";
+              if (prerenderFnNames.some((n) => fnCall.includes(n))) {
+                brand = PRERENDER_CONFIG.brand;
+              } else if (staticFnNames.some((n) => fnCall.includes(n))) {
+                brand = STATIC_CONFIG.brand;
+              }
+              lines.push(
+                `export const ${primaryName} = { __brand: "${brand}", $$id: "${stubId}" };`
+              );
+              for (const name of binding.exportNames.slice(1)) {
+                lines.push(`export const ${name} = ${primaryName};`);
+              }
+            }
+          }
+          return { code: lines.join("\n") + "\n", map: null };
+        }
       }
       if (hasStaticHandlerCode && isRscEnv && isBuild) {
         const fnNames = getFnNames(STATIC_CONFIG.fnName);
@@ -1372,25 +1475,41 @@ ${lazyImports.join(",\n")}
           isBuild
         ) || changed;
       }
-      if (hasPrerenderHandlerCode && isRscEnv) {
+      if (hasPrerenderHandlerCode) {
         const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
-        changed = transformHandlerIds(
-          PRERENDER_CONFIG,
-          getBindings(code, fnNames),
-          s,
-          filePath,
-          isBuild
-        ) || changed;
+        const bindings = getBindings(code, fnNames);
+        if (isRscEnv) {
+          changed = transformHandlerIds(
+            PRERENDER_CONFIG,
+            bindings,
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        } else {
+          changed = stubHandlerExprs(
+            PRERENDER_CONFIG,
+            bindings,
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        }
       }
-      if (hasStaticHandlerCode && isRscEnv) {
+      if (hasStaticHandlerCode) {
         const fnNames = getFnNames(STATIC_CONFIG.fnName);
-        changed = transformHandlerIds(
-          STATIC_CONFIG,
-          getBindings(code, fnNames),
-          s,
-          filePath,
-          isBuild
-        ) || changed;
+        const bindings = getBindings(code, fnNames);
+        if (isRscEnv) {
+          changed = transformHandlerIds(
+            STATIC_CONFIG,
+            bindings,
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        } else {
+          changed = stubHandlerExprs(STATIC_CONFIG, bindings, s, filePath, isBuild) || changed;
+        }
       }
       if (!changed) return;
       return {
@@ -1740,12 +1859,13 @@ function getVirtualVersionContent(version) {
 
 // src/vite/utils/package-resolution.ts
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { resolve } from "node:path";
 
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.f2337aef",
+  version: "0.0.0-experimental.f2d1a2f1",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -1878,22 +1998,24 @@ 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 && 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 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",
     prepublishOnly: "pnpm build",
-    typecheck: "tsc --noEmit",
+    typecheck: "tsc --noEmit && tsc -p tsconfig.strict-check.json --noEmit",
     test: "playwright test",
     "test:ui": "playwright test --ui",
     "test:unit": "vitest run",
     "test:unit:watch": "vitest"
   },
   dependencies: {
-    "@vitejs/plugin-rsc": "^0.5.14",
+    "@vitejs/plugin-rsc": "^0.5.23",
+    debug: "^4.4.1",
     "magic-string": "^0.30.17",
     picomatch: "^4.0.3",
     "rsc-html-stream": "^0.0.7"
   },
   devDependencies: {
     "@playwright/test": "^1.49.1",
+    "@types/debug": "^4.1.12",
     "@types/node": "^24.10.1",
     "@types/react": "catalog:",
     "@types/react-dom": "catalog:",
@@ -1907,7 +2029,7 @@ var package_default = {
   },
   peerDependencies: {
     "@cloudflare/vite-plugin": "^1.25.0",
-    "@vitejs/plugin-rsc": "^0.5.14",
+    "@vitejs/plugin-rsc": "^0.5.23",
     react: "^18.0.0 || ^19.0.0",
     vite: "^7.3.0"
   },
@@ -1922,6 +2044,7 @@ var package_default = {
 };
 
 // src/vite/utils/package-resolution.ts
+var require2 = createRequire(import.meta.url);
 var VIRTUAL_PACKAGE_NAME = "@rangojs/router";
 function getPublishedPackageName() {
   return package_default.name;
@@ -1962,6 +2085,20 @@ function getPackageAliases() {
   }
   return aliases;
 }
+function getVendorAliases() {
+  const specs = [
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+  ];
+  const aliases = {};
+  for (const spec of specs) {
+    try {
+      aliases[spec] = require2.resolve(spec);
+    } catch {
+    }
+  }
+  return aliases;
+}
 
 // src/build/route-types/param-extraction.ts
 function extractParamsFromPattern(pattern) {
@@ -2095,31 +2232,7 @@ declare global {
 }
 
 // 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";
@@ -2341,7 +2454,7 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
-function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut) {
+function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut, inlineBlock) {
   visited = visited ?? /* @__PURE__ */ new Set();
   const realPath = resolve2(filePath);
   const key = variableName ? `${realPath}:${variableName}` : realPath;
@@ -2357,7 +2470,9 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
     return { routes: {}, searchSchemas: {} };
   }
   let block;
-  if (variableName) {
+  if (inlineBlock) {
+    block = inlineBlock;
+  } else if (variableName) {
     const extracted = extractUrlsBlockForVariable(source, variableName);
     if (!extracted) return { routes: {}, searchSchemas: {} };
     block = extracted;
@@ -2386,7 +2501,7 @@ import {
   readdirSync
 } from "node:fs";
 import {
-  join as join2,
+  join,
   dirname as dirname2,
   resolve as resolve3,
   sep,
@@ -2406,7 +2521,7 @@ function countPublicRouteEntries(source) {
 }
 var ROUTER_CALL_PATTERN = /\bcreateRouter\s*[<(]/;
 function isRoutableSourceFile(name) {
-  return (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".jsx")) && !name.includes(".gen.");
+  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) {
   let entries;
@@ -2421,9 +2536,10 @@ function findRouterFilesRecursive(dir, filter, results) {
   const childDirs = [];
   const routerFilesInDir = [];
   for (const entry of entries) {
-    const fullPath = join2(dir, entry.name);
+    const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage" || entry.name === "__tests__" || entry.name === "__mocks__" || entry.name.startsWith("."))
+        continue;
       childDirs.push(fullPath);
       continue;
     }
@@ -2475,7 +2591,7 @@ Router root: ${conflict.ancestor}
 Nested router: ${conflict.nested}
 Move the nested router into a sibling directory or configure it as a separate app root.`;
 }
-function extractUrlsVariableFromRouter(code) {
+function extractUrlsFromRouter(code) {
   const sourceFile = ts5.createSourceFile(
     "router.tsx",
     code,
@@ -2489,24 +2605,70 @@ function extractUrlsVariableFromRouter(code) {
     const callee = node.expression;
     return ts5.isIdentifier(callee) && callee.text === "createRouter";
   }
+  function isInlineBuilder(node) {
+    return ts5.isArrowFunction(node) || ts5.isFunctionExpression(node);
+  }
+  function isRoutesOnCreateRouter(node) {
+    if (!ts5.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "routes")
+      return false;
+    let inner = node.expression.expression;
+    while (ts5.isCallExpression(inner) && ts5.isPropertyAccessExpression(inner.expression)) {
+      inner = inner.expression.expression;
+    }
+    return isCreateRouterCall(inner);
+  }
   function visit(node) {
     if (result) return;
-    if (ts5.isCallExpression(node) && ts5.isPropertyAccessExpression(node.expression) && node.expression.name.text === "routes" && node.arguments.length >= 1 && ts5.isIdentifier(node.arguments[0])) {
-      let inner = node.expression.expression;
-      while (ts5.isCallExpression(inner) && ts5.isPropertyAccessExpression(inner.expression)) {
-        inner = inner.expression.expression;
-      }
-      if (isCreateRouterCall(inner)) {
-        result = node.arguments[0].text;
-        return;
+    if (ts5.isCallExpression(node) && node.arguments.length >= 1 && isRoutesOnCreateRouter(node)) {
+      const arg = node.arguments[0];
+      if (ts5.isIdentifier(arg)) {
+        result = { kind: "variable", name: arg.text };
+      } else if (isInlineBuilder(arg)) {
+        result = { kind: "inline", block: arg.getText(sourceFile) };
       }
+      return;
     }
     if (isCreateRouterCall(node)) {
       const callExpr = node;
-      for (const arg of callExpr.arguments) {
+      for (const callArg of callExpr.arguments) {
+        if (ts5.isObjectLiteralExpression(callArg)) {
+          for (const prop of callArg.properties) {
+            if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.name) && prop.name.text === "urls") {
+              if (ts5.isIdentifier(prop.initializer)) {
+                result = { kind: "variable", name: prop.initializer.text };
+              } else if (isInlineBuilder(prop.initializer)) {
+                result = {
+                  kind: "inline",
+                  block: prop.initializer.getText(sourceFile)
+                };
+              }
+              return;
+            }
+          }
+        }
+      }
+    }
+    ts5.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function extractBasenameFromRouter(code) {
+  const sourceFile = ts5.createSourceFile(
+    "router.tsx",
+    code,
+    ts5.ScriptTarget.Latest,
+    true,
+    ts5.ScriptKind.TSX
+  );
+  let result;
+  function visit(node) {
+    if (result !== void 0) return;
+    if (ts5.isCallExpression(node) && ts5.isIdentifier(node.expression) && node.expression.text === "createRouter") {
+      for (const arg of node.arguments) {
         if (ts5.isObjectLiteralExpression(arg)) {
           for (const prop of arg.properties) {
-            if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.name) && prop.name.text === "urls" && ts5.isIdentifier(prop.initializer)) {
+            if (ts5.isPropertyAssignment(prop) && ts5.isIdentifier(prop.name) && prop.name.text === "basename" && ts5.isStringLiteral(prop.initializer)) {
               result = prop.initializer.text;
               return;
             }
@@ -2519,6 +2681,19 @@ function extractUrlsVariableFromRouter(code) {
   visit(sourceFile);
   return result;
 }
+function applyBasenameToRoutes(result, basename3) {
+  const prefixed = {};
+  for (const [name, pattern] of Object.entries(result.routes)) {
+    if (pattern === "/") {
+      prefixed[name] = basename3;
+    } else if (basename3.endsWith("/") && pattern.startsWith("/")) {
+      prefixed[name] = basename3 + pattern.slice(1);
+    } else {
+      prefixed[name] = basename3 + pattern;
+    }
+  }
+  return { routes: prefixed, searchSchemas: result.searchSchemas };
+}
 function buildCombinedRouteMapForRouterFile(routerFilePath) {
   let routerSource;
   try {
@@ -2526,19 +2701,40 @@ function buildCombinedRouteMapForRouterFile(routerFilePath) {
   } catch {
     return { routes: {}, searchSchemas: {} };
   }
-  const urlsVarName = extractUrlsVariableFromRouter(routerSource);
-  if (!urlsVarName) {
+  const extraction = extractUrlsFromRouter(routerSource);
+  if (!extraction) {
     return { routes: {}, searchSchemas: {} };
   }
-  const imported = resolveImportedVariable(routerSource, urlsVarName);
-  if (imported) {
-    const targetFile = resolveImportPath(imported.specifier, routerFilePath);
-    if (!targetFile) {
-      return { routes: {}, searchSchemas: {} };
+  const rawBasename = extractBasenameFromRouter(routerSource);
+  const basename3 = rawBasename ? ("/" + rawBasename.replace(/^\/+|\/+$/g, "")).replace(/^\/$/, "") : void 0;
+  let result;
+  if (extraction.kind === "inline") {
+    result = buildCombinedRouteMapWithSearch(
+      routerFilePath,
+      void 0,
+      void 0,
+      void 0,
+      extraction.block
+    );
+  } else {
+    const imported = resolveImportedVariable(routerSource, extraction.name);
+    if (imported) {
+      const targetFile = resolveImportPath(imported.specifier, routerFilePath);
+      if (!targetFile) {
+        return { routes: {}, searchSchemas: {} };
+      }
+      result = buildCombinedRouteMapWithSearch(
+        targetFile,
+        imported.exportedName
+      );
+    } else {
+      result = buildCombinedRouteMapWithSearch(routerFilePath, extraction.name);
     }
-    return buildCombinedRouteMapWithSearch(targetFile, imported.exportedName);
   }
-  return buildCombinedRouteMapWithSearch(routerFilePath, urlsVarName);
+  if (basename3) {
+    result = applyBasenameToRoutes(result, basename3);
+  }
+  return result;
 }
 function findRouterFiles(root, filter) {
   const result = [];
@@ -2547,7 +2743,7 @@ function findRouterFiles(root, filter) {
 }
 function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
   try {
-    const oldCombinedPath = join2(root, "src", "named-routes.gen.ts");
+    const oldCombinedPath = join(root, "src", "named-routes.gen.ts");
     if (existsSync3(oldCombinedPath)) {
       unlinkSync(oldCombinedPath);
       console.log(
@@ -2563,31 +2759,21 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
     throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
   }
   for (const routerFilePath of routerFilePaths) {
-    let routerSource;
-    try {
-      routerSource = readFileSync2(routerFilePath, "utf-8");
-    } catch {
-      continue;
-    }
-    const urlsVarName = extractUrlsVariableFromRouter(routerSource);
-    if (!urlsVarName) continue;
-    let result;
-    const imported = resolveImportedVariable(routerSource, urlsVarName);
-    if (imported) {
-      const targetFile = resolveImportPath(imported.specifier, routerFilePath);
-      if (!targetFile) continue;
-      result = buildCombinedRouteMapWithSearch(
-        targetFile,
-        imported.exportedName
-      );
-    } else {
-      result = buildCombinedRouteMapWithSearch(routerFilePath, urlsVarName);
+    const result = buildCombinedRouteMapForRouterFile(routerFilePath);
+    if (Object.keys(result.routes).length === 0 && Object.keys(result.searchSchemas).length === 0) {
+      let routerSource;
+      try {
+        routerSource = readFileSync2(routerFilePath, "utf-8");
+      } catch {
+        continue;
+      }
+      if (!extractUrlsFromRouter(routerSource)) continue;
     }
     const routerBasename = pathBasename(routerFilePath).replace(
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const outPath = join2(
+    const outPath = join(
       dirname2(routerFilePath),
       `${routerBasename}.named-routes.gen.ts`
     );
@@ -2717,8 +2903,9 @@ function createVersionPlugin() {
   let isDev = false;
   let server = null;
   const clientModuleSignatures = /* @__PURE__ */ new Map();
+  let versionCounter = 0;
   const bumpVersion = (reason) => {
-    currentVersion = Date.now().toString(16);
+    currentVersion = Date.now().toString(16) + String(++versionCounter);
     console.log(`[rsc-router] ${reason}, version updated: ${currentVersion}`);
     const rscEnv = server?.environments?.rsc;
     const versionMod = rscEnv?.moduleGraph?.getModuleById(
@@ -2774,6 +2961,9 @@ function createVersionPlugin() {
       if (!isDev) return;
       const isRscModule = this.environment?.name === "rsc";
       if (!isRscModule) return;
+      if (ctx.modules.length === 1 && ctx.modules[0].id === "\0" + VIRTUAL_IDS.version) {
+        return;
+      }
       if (isCodeModule(ctx.file)) {
         const filePath = normalizeModuleId(ctx.file);
         const previousSignature = clientModuleSignatures.get(filePath);
@@ -2803,6 +2993,98 @@ function createVersionPlugin() {
 
 // src/vite/utils/shared-utils.ts
 import * as Vite from "vite";
+
+// src/vite/plugins/performance-tracks.ts
+import { readFile } from "node:fs/promises";
+
+// src/vite/debug.ts
+import debugFactory from "debug";
+if (process.env.INTERNAL_RANGO_DEBUG) {
+  const existing = debugFactory.disable();
+  debugFactory.enable(existing ? `${existing},rango:*` : "rango:*");
+}
+function createRangoDebugger(namespace) {
+  const primary = debugFactory(namespace);
+  const shadow = debugFactory(`vite:${namespace}`);
+  if (primary.enabled) return primary;
+  if (shadow.enabled) return shadow;
+  return void 0;
+}
+async function timed(debug2, label, fn) {
+  if (!debug2) return await fn();
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    debug2("%s (%sms)", label, (performance.now() - start).toFixed(1));
+  }
+}
+function timedSync(debug2, label, fn) {
+  if (!debug2) return fn();
+  const start = performance.now();
+  try {
+    return fn();
+  } finally {
+    debug2("%s (%sms)", label, (performance.now() - start).toFixed(1));
+  }
+}
+
+// src/vite/plugins/performance-tracks.ts
+var debug = createRangoDebugger("rango:transform");
+var RSDW_PATCH_RE = /((?:var|let|const)\s+\w+\s*=\s*root\._children\s*,\s*(\w+)\s*=\s*root\._debugInfo\s*[;,])/;
+function buildPatchReplacement(match, debugInfoVar) {
+  return `${match}
+if (${debugInfoVar} && 0 === ${debugInfoVar}.length && "fulfilled" === root.status) {
+  var _resolved = "function" === typeof resolveLazy ? resolveLazy(root.value) : root.value;
+  if ("object" === typeof _resolved && null !== _resolved && isArrayImpl(_resolved._debugInfo)) {
+    ${debugInfoVar} = _resolved._debugInfo;
+  }
+}`;
+}
+function patchRsdwClientDebugInfoRecovery(code) {
+  const match = code.match(RSDW_PATCH_RE);
+  if (!match) {
+    return { code, debugInfoVar: null };
+  }
+  return {
+    code: code.replace(match[1], buildPatchReplacement(match[1], match[2])),
+    debugInfoVar: match[2]
+  };
+}
+function performanceTracksOptimizeDepsPlugin() {
+  return {
+    name: "@rangojs/router:performance-tracks-optimize-deps",
+    setup(build) {
+      build.onLoad(
+        {
+          filter: /react-server-dom-webpack-client\.browser\.(development|production)\.js$/
+        },
+        async (args) => {
+          const code = await readFile(args.path, "utf8");
+          const patched = patchRsdwClientDebugInfoRecovery(code);
+          return {
+            contents: patched.code,
+            loader: "js"
+          };
+        }
+      );
+    }
+  };
+}
+function performanceTracksPlugin() {
+  return {
+    name: "@rangojs/router:performance-tracks",
+    transform(code, id) {
+      if (!id.includes("react-server-dom") || !id.includes("client")) return;
+      const patched = patchRsdwClientDebugInfoRecovery(code);
+      if (!patched.debugInfoVar) return;
+      debug?.("patched RSDW client (var: %s)", patched.debugInfoVar);
+      return patched.code;
+    }
+  };
+}
+
+// src/vite/utils/shared-utils.ts
 var versionEsbuildPlugin = {
   name: "@rangojs/router-version",
   setup(build) {
@@ -2820,7 +3102,7 @@ var versionEsbuildPlugin = {
   }
 };
 var sharedEsbuildOptions = {
-  plugins: [versionEsbuildPlugin]
+  plugins: [versionEsbuildPlugin, performanceTracksOptimizeDepsPlugin()]
 };
 function createVirtualEntriesPlugin(entries, routerPathRef) {
   const virtualModules = {};
@@ -2903,11 +3185,11 @@ ${dim} \u2571${reset}    ${bold}\u2554\u2550\u2557${reset}${dim}      *      \u2
 ${dim}      ${reset}${bold}\u2551 \u2551${reset} ${bold}\u2554\u2550\u2557${reset}${dim}                    *                \u2727.   \u2571${reset}
 ${dim}   ${reset}${bold}\u2554\u2557 \u2551 \u2551 \u2551 \u2551${reset}${dim}                          *               \u2571${reset}
 ${dim}   ${reset}${bold}\u2551\u2551 \u2551 \u2551 \u2551 \u2551  \u2566\u2550\u2557\u2554\u2550\u2557\u2554\u2557\u2554\u2554\u2550\u2557\u2554\u2550\u2557${reset}${dim}             \u2727              \u2726${reset}
-${dim}  ${reset}${bold}\u2550\u2563\u2551 \u2551 \u2560\u2550\u255D \u2551  \u2560\u2566\u255D\u2560\u2550\u2563\u2551\u2551\u2551\u2551 \u2566\u2551 \u2551${reset}${dim}        *           \u2727${reset}
+${dim}   ${reset}${bold}\u2551\u2551 \u2551 \u2560\u2550\u255D \u2551  \u2560\u2566\u255D\u2560\u2550\u2563\u2551\u2551\u2551\u2551 \u2566\u2551 \u2551${reset}${dim}        *           \u2727${reset}
 ${dim}   ${reset}${bold}\u2551\u255A\u2550\u255D \u2554\u2550\u2550\u2550\u255D  \u2569\u255A\u2550\u2569 \u2569\u255D\u255A\u255D\u255A\u2550\u255D\u255A\u2550\u255D${reset}${dim}            \u2726          .      *${reset}
 ${dim}   ${reset}${bold}\u255A\u2550\u2550\u2557 \u2551${reset}${dim} *      RSC Wrangler         \u2727                \u2726${reset}
-${dim}  *   ${reset}${bold}\u2551 \u2560\u2550${reset}${dim}                         *            \u2727.    \u2571${reset}
-${bold}\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2569\u2550\u2550\u2550${reset}${dim}                  \u2726            *${reset}
+${dim}  *   ${reset}${bold}\u2551 \u2551${reset}${dim}                          *            \u2727.    \u2571${reset}
+${dim}   ${reset}${bold}\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550${reset}${dim}                           \u2726            *${reset}
 
    v${version} \xB7 ${preset} \xB7 ${mode}
 `;
@@ -3026,6 +3308,8 @@ function createCjsToEsmPlugin() {
 import { createServer as createViteServer } from "vite";
 import { resolve as resolve8 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
+import { createRequire as createRequire2, register } from "node:module";
+import { pathToFileURL } from "node:url";
 
 // src/vite/plugins/virtual-stub-plugin.ts
 function createVirtualStubPlugin() {
@@ -3051,8 +3335,115 @@ function createVirtualStubPlugin() {
   };
 }
 
+// src/vite/plugins/cloudflare-protocol-stub.ts
+var VIRTUAL_PREFIX = "virtual:rango-cloudflare-stub-";
+var NULL_PREFIX = "\0" + VIRTUAL_PREFIX;
+var CF_PREFIX = "cloudflare:";
+var BUILD_ENV_GLOBAL_KEY = "__rango_build_env__";
+var SOURCE_EXT_RE = /\.[mc]?[jt]sx?$/;
+var IMPORT_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ImportDeclaration",
+  "ImportExpression",
+  "ExportNamedDeclaration",
+  "ExportAllDeclaration"
+]);
+var STUBS = {
+  "cloudflare:workers": `
+export class DurableObject { constructor(_ctx, _env) {} }
+export class WorkerEntrypoint { constructor(_ctx, _env) {} }
+export class WorkflowEntrypoint { constructor(_ctx, _env) {} }
+export class RpcTarget {}
+export const env = globalThis[${JSON.stringify(BUILD_ENV_GLOBAL_KEY)}] ?? {};
+export default {};
+`,
+  "cloudflare:email": `
+export class EmailMessage { constructor(_from, _to, _raw) {} }
+export default {};
+`,
+  "cloudflare:sockets": `
+export function connect() { return {}; }
+export default {};
+`,
+  "cloudflare:workflows": `
+export class NonRetryableError extends Error {
+  constructor(message, name) { super(message); this.name = name ?? "NonRetryableError"; }
+}
+export default {};
+`
+};
+var FALLBACK_STUB = `export default {};
+`;
+function createCloudflareProtocolStubPlugin() {
+  return {
+    name: "@rangojs/router:cloudflare-protocol-stub",
+    transform(code, id) {
+      const cleanId = id.split("?")[0] ?? id;
+      if (!SOURCE_EXT_RE.test(cleanId)) return null;
+      if (!code.includes(CF_PREFIX)) return null;
+      let ast;
+      try {
+        ast = this.parse(code);
+      } catch {
+        return null;
+      }
+      const hits = [];
+      walk(ast, (node) => {
+        if (!IMPORT_NODE_TYPES.has(node.type)) return;
+        const source = node.source;
+        if (!source || source.type !== "Literal") return;
+        if (typeof source.value !== "string") return;
+        if (!source.value.startsWith(CF_PREFIX)) return;
+        if (typeof source.start !== "number" || typeof source.end !== "number")
+          return;
+        hits.push({
+          start: source.start,
+          end: source.end,
+          value: source.value
+        });
+      });
+      if (hits.length === 0) return null;
+      hits.sort((a, b) => b.start - a.start);
+      let out = code;
+      for (const hit of hits) {
+        const submodule = hit.value.slice(CF_PREFIX.length);
+        const quote = code[hit.start] === "'" ? "'" : '"';
+        out = out.slice(0, hit.start) + quote + VIRTUAL_PREFIX + submodule + quote + out.slice(hit.end);
+      }
+      return { code: out, map: null };
+    },
+    resolveId(id) {
+      if (id.startsWith(VIRTUAL_PREFIX)) {
+        return "\0" + id;
+      }
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(NULL_PREFIX)) return null;
+      const submodule = id.slice(NULL_PREFIX.length);
+      const specifier = CF_PREFIX + submodule;
+      return STUBS[specifier] ?? FALLBACK_STUB;
+    }
+  };
+}
+function walk(node, visit) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit);
+    return;
+  }
+  const n = node;
+  if (typeof n.type !== "string") return;
+  visit(n);
+  for (const key in n) {
+    if (key === "loc" || key === "start" || key === "end" || key === "range") {
+      continue;
+    }
+    walk(n[key], visit);
+  }
+}
+
 // src/vite/plugins/client-ref-hashing.ts
-import { relative as relative2 } from "node:path";
+import { relative } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 var CLIENT_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-package-proxy/";
 var CLIENT_IN_SERVER_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-in-server-package-proxy/";
@@ -3065,10 +3456,10 @@ function computeProductionHash(projectRoot, refKey) {
     const absPath = decodeURIComponent(
       refKey.slice(CLIENT_IN_SERVER_PKG_PROXY_PREFIX.length)
     );
-    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith(FS_PREFIX)) {
     const absPath = refKey.slice(FS_PREFIX.length - 1);
-    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith("/")) {
     toHash = refKey.slice(1);
   } else {
@@ -3209,8 +3600,8 @@ function createDiscoveryState(entryPath, opts) {
     perRouterManifestDataMap: /* @__PURE__ */ new Map(),
     prerenderManifestEntries: null,
     staticManifestEntries: null,
-    handlerChunkInfo: null,
-    staticHandlerChunkInfo: null,
+    handlerChunkInfoMap: /* @__PURE__ */ new Map(),
+    staticHandlerChunkInfoMap: /* @__PURE__ */ new Map(),
     rscEntryFileName: null,
     resolvedPrerenderModules: void 0,
     resolvedStaticModules: void 0,
@@ -3293,8 +3684,17 @@ function jsonParseExpression(value) {
 }
 
 // src/context-var.ts
+var NON_CACHEABLE_KEYS = /* @__PURE__ */ Symbol.for(
+  "rango:non-cacheable-keys"
+);
+function getNonCacheableKeys(variables) {
+  if (!variables[NON_CACHEABLE_KEYS]) {
+    variables[NON_CACHEABLE_KEYS] = /* @__PURE__ */ new Set();
+  }
+  return variables[NON_CACHEABLE_KEYS];
+}
 var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function contextSet(variables, keyOrVar, value) {
+function contextSet(variables, keyOrVar, value, options) {
   if (typeof keyOrVar === "string") {
     if (FORBIDDEN_KEYS.has(keyOrVar)) {
       throw new Error(
@@ -3302,8 +3702,14 @@ function contextSet(variables, keyOrVar, value) {
       );
     }
     variables[keyOrVar] = value;
+    if (options?.cache === false) {
+      getNonCacheableKeys(variables).add(keyOrVar);
+    }
   } else {
     variables[keyOrVar.key] = value;
+    if (options?.cache === false) {
+      getNonCacheableKeys(variables).add(keyOrVar.key);
+    }
   }
 }
 
@@ -3326,13 +3732,31 @@ function encodePathParam(value) {
 }
 function substituteRouteParams(pattern, params, encode = encodeURIComponent) {
   let result = pattern;
+  let hadOmittedOptional = false;
   for (const [key, value] of Object.entries(params)) {
     const escaped = escapeRegExp2(key);
-    result = result.replace(
-      new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
-      encode(value)
-    );
-    result = result.replace(`*${key}`, encode(value));
+    if (value === "") {
+      result = result.replace(
+        new RegExp(`:${escaped}(\\([^)]*\\))?(?!\\?)`),
+        ""
+      );
+      result = result.replace(`*${key}`, "");
+    } else {
+      result = result.replace(
+        new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
+        encode(value)
+      );
+      result = result.replace(`*${key}`, encode(value));
+    }
+  }
+  result = result.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\([^)]*\))?\?/g, () => {
+    hadOmittedOptional = true;
+    return "";
+  });
+  if (hadOmittedOptional) {
+    const hadTrailingSlash = pattern.length > 1 && pattern.endsWith("/");
+    result = result.replace(/\/\/+/g, "/").replace(/\/+$/, "") || "/";
+    if (hadTrailingSlash && !result.endsWith("/")) result += "/";
   }
   return result;
 }
@@ -3442,84 +3866,126 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
     if (!params) return pattern;
     return substituteRouteParams(pattern, params);
   };
+  let resolvedRoutes = 0;
+  let totalDynamic = 0;
   for (const { manifest } of allManifests) {
     if (!manifest.prerenderRoutes) continue;
-    const defs = manifest._prerenderDefs || {};
     for (const routeName of manifest.prerenderRoutes) {
       const pattern = manifest.routeManifest[routeName];
-      if (!pattern) continue;
-      const def = defs[routeName];
-      const isPassthroughRoute = !!def?.options?.passthrough;
-      const hasDynamic = pattern.includes(":") || pattern.includes("*");
-      if (!hasDynamic) {
-        entries.push({
-          urlPath: pattern.replace(/\/$/, "") || "/",
-          routeName,
-          concurrency: 1,
-          isPassthroughRoute
-        });
-      } else {
-        if (def?.getParams) {
-          try {
-            const buildVars = {};
-            const getParamsCtx = {
-              build: true,
-              set: ((keyOrVar, value) => {
-                contextSet(buildVars, keyOrVar, value);
-              }),
-              reverse: getParamsReverse
-            };
-            const paramsList = await def.getParams(getParamsCtx);
-            const concurrency = def.options?.concurrency ?? 1;
-            const hasBuildVars = Object.keys(buildVars).length > 0 || Object.getOwnPropertySymbols(buildVars).length > 0;
-            for (const params of paramsList) {
-              let url = substituteRouteParams(
-                pattern,
-                params,
-                encodePathParam
-              );
-              if (url.includes("*")) {
-                const wildcardValue = params["*"] ?? params.splat;
-                if (wildcardValue !== void 0) {
-                  url = url.replace(/\*[^/]*$/, encodePathParam(wildcardValue));
+      if (pattern && (pattern.includes(":") || pattern.includes("*"))) {
+        totalDynamic++;
+      }
+    }
+  }
+  const paramsStart = performance.now();
+  const progressInterval = totalDynamic > 0 ? setInterval(() => {
+    const elapsed = ((performance.now() - paramsStart) / 1e3).toFixed(1);
+    console.log(
+      `[rsc-router] Resolving prerender params... ${resolvedRoutes}/${totalDynamic} routes (${elapsed}s)`
+    );
+  }, 5e3) : void 0;
+  try {
+    for (const { manifest } of allManifests) {
+      if (!manifest.prerenderRoutes) continue;
+      const defs = manifest._prerenderDefs || {};
+      const passthroughSet = new Set(manifest.passthroughRoutes || []);
+      for (const routeName of manifest.prerenderRoutes) {
+        const pattern = manifest.routeManifest[routeName];
+        if (!pattern) continue;
+        const def = defs[routeName];
+        const isPassthroughRoute = passthroughSet.has(routeName);
+        const hasDynamic = pattern.includes(":") || pattern.includes("*");
+        if (!hasDynamic) {
+          entries.push({
+            urlPath: pattern.replace(/\/$/, "") || "/",
+            routeName,
+            concurrency: 1,
+            isPassthroughRoute
+          });
+        } else {
+          if (def?.getParams) {
+            try {
+              const buildVars = {};
+              const buildEnv = state.resolvedBuildEnv;
+              const getParamsCtx = {
+                build: true,
+                dev: !state.isBuildMode,
+                set: ((keyOrVar, value) => {
+                  contextSet(buildVars, keyOrVar, value);
+                }),
+                reverse: getParamsReverse,
+                get env() {
+                  if (buildEnv !== void 0) return buildEnv;
+                  throw new Error(
+                    "[rsc-router] ctx.env is not available during build-time getParams(). Configure buildEnv in your rango() plugin options to enable build-time env access."
+                  );
                 }
+              };
+              const paramsList = await def.getParams(getParamsCtx);
+              const concurrency = def.options?.concurrency ?? 1;
+              const hasBuildVars = Object.keys(buildVars).length > 0 || Object.getOwnPropertySymbols(buildVars).length > 0;
+              for (const params of paramsList) {
+                let url = substituteRouteParams(
+                  pattern,
+                  params,
+                  encodePathParam
+                );
+                if (url.includes("*")) {
+                  const wildcardValue = params["*"] ?? params.splat;
+                  if (wildcardValue !== void 0) {
+                    url = url.replace(
+                      /\*[^/]*$/,
+                      encodePathParam(wildcardValue)
+                    );
+                  }
+                }
+                entries.push({
+                  urlPath: url.replace(/\/$/, "") || "/",
+                  routeName,
+                  concurrency,
+                  ...hasBuildVars ? { buildVars } : {},
+                  isPassthroughRoute
+                });
               }
-              entries.push({
-                urlPath: url.replace(/\/$/, "") || "/",
-                routeName,
-                concurrency,
-                ...hasBuildVars ? { buildVars } : {},
-                isPassthroughRoute
-              });
-            }
-          } catch (err) {
-            if (err.name === "Skip") {
-              console.log(
-                `[rsc-router]   SKIP route "${routeName}" - ${err.message}`
-              );
-              notifyOnError(
-                registry,
-                err,
-                "prerender",
-                routeName,
-                void 0,
-                true
+              resolvedRoutes++;
+            } catch (err) {
+              resolvedRoutes++;
+              if (err.name === "Skip") {
+                console.log(
+                  `[rsc-router]   SKIP route "${routeName}" - ${err.message}`
+                );
+                notifyOnError(
+                  registry,
+                  err,
+                  "prerender",
+                  routeName,
+                  void 0,
+                  true
+                );
+                continue;
+              }
+              console.error(
+                `[rsc-router] Failed to get params for prerender route "${routeName}": ${err.message}`
               );
-              continue;
+              notifyOnError(registry, err, "prerender", routeName);
+              throw err;
             }
-            console.error(
-              `[rsc-router] Failed to get params for prerender route "${routeName}": ${err.message}`
+          } else {
+            console.warn(
+              `[rsc-router] Dynamic prerender route "${routeName}" has no getParams(), skipping`
             );
-            notifyOnError(registry, err, "prerender", routeName);
-            throw err;
           }
-        } else {
-          console.warn(
-            `[rsc-router] Dynamic prerender route "${routeName}" has no getParams(), skipping`
-          );
         }
       }
     }
+  } finally {
+    if (progressInterval) {
+      clearInterval(progressInterval);
+      const elapsed = ((performance.now() - paramsStart) / 1e3).toFixed(1);
+      console.log(
+        `[rsc-router] Resolved prerender params: ${resolvedRoutes}/${totalDynamic} routes (${elapsed}s)`
+      );
+    }
   }
   if (entries.length === 0) return;
   const maxConcurrency = Math.max(...entries.map((e) => e.concurrency));
@@ -3546,7 +4012,8 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
               entry.urlPath,
               {},
               entry.buildVars,
-              entry.isPassthroughRoute
+              entry.isPassthroughRoute,
+              state.resolvedBuildEnv
             );
             if (!result) continue;
             if (result.passthrough) {
@@ -3670,7 +4137,9 @@ async function renderStaticHandlers(state, rscEnv, registry) {
           const result = await routerInstance.renderStaticSegment(
             def.handler,
             def.$$id,
-            def.$$routePrefix
+            def.$$routePrefix,
+            state.resolvedBuildEnv,
+            !state.isBuildMode
           );
           if (result) {
             const hasHandles = Object.keys(result.handles).length > 0;
@@ -3795,7 +4264,11 @@ async function discoverRouters(state, rscEnv) {
     if (!router.urlpatterns || !generateManifestFull) {
       continue;
     }
-    const manifest = generateManifestFull(router.urlpatterns, routerMountIndex);
+    const manifest = generateManifestFull(
+      router.urlpatterns,
+      routerMountIndex,
+      router.__basename ? { urlPrefix: router.__basename } : void 0
+    );
     routerMountIndex++;
     allManifests.push({ id, manifest });
     const routeCount = Object.keys(manifest.routeManifest).length;
@@ -3937,7 +4410,7 @@ async function discoverRouters(state, rscEnv) {
 }
 
 // src/vite/discovery/route-types-writer.ts
-import { dirname as dirname3, basename, join as join3, resolve as resolve6 } from "node:path";
+import { dirname as dirname3, basename, 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";
 function filterUserNamedRoutes(manifest) {
   const filtered = {};
@@ -3958,7 +4431,7 @@ function writeCombinedRouteTypesWithTracking(state, opts) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const outPath = join3(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    const outPath = join2(routerDir, `${routerBasename}.named-routes.gen.ts`);
     try {
       preContent.set(outPath, readFileSync4(outPath, "utf-8"));
     } catch {
@@ -3971,7 +4444,7 @@ function writeCombinedRouteTypesWithTracking(state, opts) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const outPath = join3(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    const outPath = join2(routerDir, `${routerBasename}.named-routes.gen.ts`);
     if (!existsSync5(outPath)) continue;
     try {
       const content = readFileSync4(outPath, "utf-8");
@@ -3988,7 +4461,7 @@ function writeRouteTypesFiles(state) {
     const entryDir = dirname3(
       resolve6(state.projectRoot, state.resolvedEntryPath)
     );
-    const oldCombinedPath = join3(entryDir, "named-routes.gen.ts");
+    const oldCombinedPath = join2(entryDir, "named-routes.gen.ts");
     if (existsSync5(oldCombinedPath)) {
       unlinkSync2(oldCombinedPath);
       console.log(
@@ -4013,7 +4486,7 @@ Set an explicit \`id\` on createRouter() or check the call site.`
     }
     const routerDir = dirname3(sourceFile);
     const routerBasename = basename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
-    const outPath = join3(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    const outPath = join2(routerDir, `${routerBasename}.named-routes.gen.ts`);
     const userRoutes = filterUserNamedRoutes(routeManifest);
     let effectiveSearchSchemas = routeSearchSchemas;
     if ((!effectiveSearchSchemas || Object.keys(effectiveSearchSchemas).length === 0) && sourceFile) {
@@ -4078,7 +4551,7 @@ function supplementGenFilesWithRuntimeRoutes(state) {
     }
     const routerDir = dirname3(sourceFile);
     const routerBasename = basename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
-    const outPath = join3(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    const outPath = join2(routerDir, `${routerBasename}.named-routes.gen.ts`);
     const source = generateRouteTypesSource(
       mergedRoutes,
       Object.keys(mergedSearchSchemas).length > 0 ? mergedSearchSchemas : void 0
@@ -4092,7 +4565,7 @@ function supplementGenFilesWithRuntimeRoutes(state) {
 }
 
 // src/vite/discovery/virtual-module-codegen.ts
-import { dirname as dirname4, basename as basename2, join as join4 } from "node:path";
+import { dirname as dirname4, basename as basename2, join as join3 } from "node:path";
 function generateRoutesManifestModule(state) {
   const hasManifest = state.mergedRouteManifest && Object.keys(state.mergedRouteManifest).length > 0;
   if (hasManifest) {
@@ -4107,7 +4580,7 @@ function generateRoutesManifestModule(state) {
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join4(
+        const genPath = join3(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
         ).replaceAll("\\", "/");
@@ -4204,7 +4677,7 @@ function generatePerRouterModule(state, routerId) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const genPath = join4(
+    const genPath = join3(
       routerDir,
       `${routerBasename}.named-routes.gen.js`
     ).replaceAll("\\", "/");
@@ -4244,48 +4717,45 @@ function postprocessBundle(state) {
   );
   const evictionTargets = [
     {
-      info: state.handlerChunkInfo,
+      infos: state.handlerChunkInfoMap.values(),
       fnName: "Prerender",
       brand: "prerenderHandler",
       label: "handler code from RSC bundle"
     },
     {
-      info: state.staticHandlerChunkInfo,
+      infos: state.staticHandlerChunkInfoMap.values(),
       fnName: "Static",
       brand: "staticHandler",
       label: "static handler code"
     }
   ];
   for (const target of evictionTargets) {
-    if (!target.info) continue;
-    const chunkPath = resolve7(
-      state.projectRoot,
-      "dist/rsc",
-      target.info.fileName
-    );
-    try {
-      const code = readFileSync5(chunkPath, "utf-8");
-      const result = evictHandlerCode(
-        code,
-        target.info.exports,
-        target.fnName,
-        target.brand
-      );
-      if (result) {
-        writeFileSync4(chunkPath, result.code);
-        const savedKB = (result.savedBytes / 1024).toFixed(1);
-        console.log(
-          `[rsc-router] Evicted ${target.label} (${savedKB} KB saved): ${target.info.fileName}`
+    for (const info of target.infos) {
+      const chunkPath = resolve7(state.projectRoot, "dist/rsc", info.fileName);
+      try {
+        const code = readFileSync5(chunkPath, "utf-8");
+        const result = evictHandlerCode(
+          code,
+          info.exports,
+          target.fnName,
+          target.brand
+        );
+        if (result) {
+          writeFileSync4(chunkPath, result.code);
+          const savedKB = (result.savedBytes / 1024).toFixed(1);
+          console.log(
+            `[rsc-router] Evicted ${target.label} (${savedKB} KB saved): ${info.fileName}`
+          );
+        }
+      } catch (replaceErr) {
+        console.warn(
+          `[rsc-router] Failed to evict ${target.label}: ${replaceErr.message}`
         );
       }
-    } catch (replaceErr) {
-      console.warn(
-        `[rsc-router] Failed to evict ${target.label}: ${replaceErr.message}`
-      );
     }
   }
-  state.handlerChunkInfo = null;
-  state.staticHandlerChunkInfo = null;
+  state.handlerChunkInfoMap.clear();
+  state.staticHandlerChunkInfoMap.clear();
   if (hasPrerenderData && existsSync6(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__prerender-manifest.js")) {
@@ -4328,7 +4798,7 @@ function postprocessBundle(state) {
   }
   if (hasStaticData && existsSync6(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
-    if (!rscCode.includes("__STATIC_MANIFEST")) {
+    if (!rscCode.includes("__static-manifest.js")) {
       try {
         const manifestEntries = [];
         let totalBytes = copyStagedBuildAssets(
@@ -4367,7 +4837,24 @@ function postprocessBundle(state) {
 }
 
 // src/vite/router-discovery.ts
+var debugDiscovery = createRangoDebugger("rango:discovery");
+var debugRoutes = createRangoDebugger("rango:routes");
+var loaderHookRegistered = false;
+function ensureCloudflareProtocolLoaderRegistered() {
+  if (loaderHookRegistered) return;
+  loaderHookRegistered = true;
+  try {
+    register(
+      new URL("./plugins/cloudflare-protocol-loader-hook.mjs", import.meta.url)
+    );
+  } catch (err) {
+    console.warn(
+      `[rsc-router] Could not register Node ESM loader hook for cloudflare:* imports (${err?.message ?? err}). Falling back to Vite transform only.`
+    );
+  }
+}
 async function createTempRscServer(state, options = {}) {
+  ensureCloudflareProtocolLoaderRegistered();
   const { default: rsc } = await import("@vitejs/plugin-rsc");
   return createViteServer({
     root: state.projectRoot,
@@ -4390,6 +4877,7 @@ async function createTempRscServer(state, options = {}) {
       ...options.forceBuild ? [hashClientRefs(state.projectRoot)] : [],
       createVersionPlugin(),
       createVirtualStubPlugin(),
+      createCloudflareProtocolStubPlugin(),
       // Dev prerender must use dev-mode IDs (path-based) to match the workerd
       // runtime. forceBuild produces hashed IDs for production bundle consistency.
       exposeInternalIds(options.forceBuild ? { forceBuild: true } : void 0),
@@ -4397,8 +4885,69 @@ async function createTempRscServer(state, options = {}) {
     ]
   });
 }
+async function resolveBuildEnv(option, factoryCtx) {
+  if (!option) return null;
+  if (option === "auto") {
+    if (factoryCtx.preset !== "cloudflare") {
+      throw new Error(
+        '[rsc-router] buildEnv: "auto" is only supported with preset: "cloudflare". Use a factory function or plain object for other presets.'
+      );
+    }
+    try {
+      const userRequire = createRequire2(
+        resolve8(factoryCtx.root, "package.json")
+      );
+      const wranglerPath = userRequire.resolve("wrangler");
+      const { getPlatformProxy } = await import(pathToFileURL(wranglerPath).href);
+      const proxy = await getPlatformProxy();
+      return {
+        env: proxy.env,
+        dispose: proxy.dispose
+      };
+    } catch (err) {
+      throw new Error(
+        `[rsc-router] buildEnv: "auto" requires wrangler to be installed.
+Install it with: pnpm add -D wrangler
+${err.message}`
+      );
+    }
+  }
+  if (typeof option === "function") {
+    return await option(factoryCtx);
+  }
+  return { env: option };
+}
+async function acquireBuildEnv(s, command, mode) {
+  const option = s.opts?.buildEnv;
+  if (!option) return false;
+  const result = await resolveBuildEnv(option, {
+    root: s.projectRoot,
+    mode,
+    command,
+    preset: s.opts?.preset ?? "node"
+  });
+  if (!result) return false;
+  s.resolvedBuildEnv = result.env;
+  s.buildEnvDispose = result.dispose ?? null;
+  globalThis[BUILD_ENV_GLOBAL_KEY] = result.env;
+  return true;
+}
+async function releaseBuildEnv(s) {
+  if (s.buildEnvDispose) {
+    try {
+      await s.buildEnvDispose();
+    } catch (err) {
+      console.warn(`[rsc-router] buildEnv dispose failed: ${err.message}`);
+    }
+    s.buildEnvDispose = null;
+  }
+  s.resolvedBuildEnv = void 0;
+  delete globalThis[BUILD_ENV_GLOBAL_KEY];
+}
 function createRouterDiscoveryPlugin(entryPath, opts) {
   const s = createDiscoveryState(entryPath, opts);
+  let viteCommand = "build";
+  let viteMode = "production";
   return {
     name: "@rangojs/router:discovery",
     config() {
@@ -4407,31 +4956,13 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
           __RANGO_DEBUG__: JSON.stringify(!!process.env.INTERNAL_RANGO_DEBUG)
         }
       };
-      if (opts?.enableBuildPrerender) {
-        config.environments = {
-          rsc: {
-            build: {
-              rollupOptions: {
-                output: {
-                  manualChunks(id) {
-                    if (s.resolvedPrerenderModules?.has(id)) {
-                      return "__prerender-handlers";
-                    }
-                    if (s.resolvedStaticModules?.has(id)) {
-                      return "__static-handlers";
-                    }
-                  }
-                }
-              }
-            }
-          }
-        };
-      }
       return config;
     },
     configResolved(config) {
       s.projectRoot = config.root;
       s.isBuildMode = config.command === "build";
+      viteCommand = config.command;
+      viteMode = config.mode;
       s.userResolveAlias = config.resolve.alias;
       if (!s.resolvedEntryPath && opts?.routerPathRef?.path) {
         s.resolvedEntryPath = opts.routerPathRef.path;
@@ -4445,12 +4976,6 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
           s.resolvedEntryPath = entries[0];
         }
       }
-      if (opts?.include || opts?.exclude) {
-        s.scanFilter = createScanFilter(s.projectRoot, {
-          include: opts.include,
-          exclude: opts.exclude
-        });
-      }
       if (opts?.staticRouteTypesGeneration !== false) {
         s.cachedRouterFiles = findRouterFiles(s.projectRoot, s.scanFilter);
         writeCombinedRouteTypesWithTracking(s, { preserveIfLarger: true });
@@ -4482,6 +5007,8 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
           });
           prerenderTempServer = null;
         }
+        releaseBuildEnv(s).catch(() => {
+        });
       });
       async function getOrCreateTempServer() {
         if (prerenderNodeRegistry) {
@@ -4508,14 +5035,33 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
         return null;
       }
       const discover = async () => {
+        const discoverStart = performance.now();
         const rscEnv = server.environments?.rsc;
         if (!rscEnv?.runner) {
+          debugDiscovery?.("dev: no rsc runner (cloudflare path)");
           s.devServerOrigin = getDevServerOrigin();
           try {
-            const tempRscEnv = await getOrCreateTempServer();
+            await timed(
+              debugDiscovery,
+              "acquireBuildEnv",
+              () => acquireBuildEnv(s, viteCommand, viteMode)
+            );
+            const tempRscEnv = await timed(
+              debugDiscovery,
+              "getOrCreateTempServer",
+              () => getOrCreateTempServer()
+            );
             if (tempRscEnv) {
-              await discoverRouters(s, tempRscEnv);
-              writeRouteTypesFiles(s);
+              await timed(
+                debugDiscovery,
+                "discoverRouters (cloudflare)",
+                () => discoverRouters(s, tempRscEnv)
+              );
+              timedSync(
+                debugDiscovery,
+                "writeRouteTypesFiles",
+                () => writeRouteTypesFiles(s)
+              );
             }
           } catch (err) {
             console.warn(
@@ -4523,26 +5069,54 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
 ${err.stack}`
             );
           }
+          debugDiscovery?.(
+            "dev discovery done (%sms)",
+            (performance.now() - discoverStart).toFixed(1)
+          );
           resolveDiscovery();
           return;
         }
         try {
-          const serverMod = await rscEnv.runner.import(
-            "@rangojs/router/server"
+          debugDiscovery?.("dev: node path start");
+          await timed(
+            debugDiscovery,
+            "acquireBuildEnv",
+            () => acquireBuildEnv(s, viteCommand, viteMode)
+          );
+          const serverMod = await timed(
+            debugDiscovery,
+            "import @rangojs/router/server",
+            () => rscEnv.runner.import("@rangojs/router/server")
           );
           if (serverMod?.setManifestReadyPromise) {
             serverMod.setManifestReadyPromise(discoveryPromise);
           }
-          await discoverRouters(s, rscEnv);
+          await timed(
+            debugDiscovery,
+            "discoverRouters",
+            () => discoverRouters(s, rscEnv)
+          );
           s.devServerOrigin = getDevServerOrigin();
-          writeRouteTypesFiles(s);
-          await propagateDiscoveryState(rscEnv);
+          timedSync(
+            debugDiscovery,
+            "writeRouteTypesFiles",
+            () => writeRouteTypesFiles(s)
+          );
+          await timed(
+            debugDiscovery,
+            "propagateDiscoveryState",
+            () => propagateDiscoveryState(rscEnv)
+          );
         } catch (err) {
           console.warn(
             `[rsc-router] Router discovery failed: ${err.message}
 ${err.stack}`
           );
         } finally {
+          debugDiscovery?.(
+            "dev discovery done (%sms)",
+            (performance.now() - discoverStart).toFixed(1)
+          );
           resolveDiscovery();
         }
       };
@@ -4591,7 +5165,26 @@ ${err.stack}`
           res.end("Missing pathname");
           return;
         }
-        let registry = mainRegistry;
+        const rscEnv = server.environments?.rsc;
+        let registry = null;
+        if (rscEnv?.runner && s.resolvedEntryPath) {
+          try {
+            await rscEnv.runner.import(s.resolvedEntryPath);
+            const serverMod = await rscEnv.runner.import(
+              "@rangojs/router/server"
+            );
+            registry = serverMod.RouterRegistry ?? null;
+          } catch (err) {
+            console.warn(
+              `[rsc-router] Dev prerender module refresh failed: ${err.message}`
+            );
+            res.statusCode = 500;
+            res.end(`Prerender handler error: ${err.message}`);
+            return;
+          }
+        } else {
+          registry = mainRegistry;
+        }
         if (!registry) {
           if (!prerenderNodeRegistry) {
             await getOrCreateTempServer();
@@ -4613,7 +5206,10 @@ ${err.stack}`
               pathname,
               {},
               void 0,
-              wantPassthrough
+              wantPassthrough,
+              s.resolvedBuildEnv,
+              true
+              // devMode: check getParams for passthrough routes
             );
             if (!result) continue;
             if (result.passthrough) continue;
@@ -4665,15 +5261,32 @@ ${err.stack}`
           const rscEnv = server.environments?.rsc;
           if (!rscEnv?.runner || runtimeRediscoveryInProgress) return;
           runtimeRediscoveryInProgress = true;
+          const hmrStart = performance.now();
           try {
-            await discoverRouters(s, rscEnv);
-            writeRouteTypesFiles(s);
-            await propagateDiscoveryState(rscEnv);
+            await timed(
+              debugDiscovery,
+              "hmr discoverRouters",
+              () => discoverRouters(s, rscEnv)
+            );
+            timedSync(
+              debugDiscovery,
+              "hmr writeRouteTypesFiles",
+              () => writeRouteTypesFiles(s)
+            );
+            await timed(
+              debugDiscovery,
+              "hmr propagateDiscoveryState",
+              () => propagateDiscoveryState(rscEnv)
+            );
           } catch (err) {
             console.warn(
               `[rsc-router] Runtime re-discovery failed: ${err.message}`
             );
           } finally {
+            debugDiscovery?.(
+              "hmr re-discovery done (%sms)",
+              (performance.now() - hmrStart).toFixed(1)
+            );
             runtimeRediscoveryInProgress = false;
           }
         };
@@ -4746,13 +5359,24 @@ ${err.stack}`
     async buildStart() {
       if (!s.isBuildMode) return;
       if (s.mergedRouteManifest !== null) return;
+      const buildStartTime = performance.now();
+      debugDiscovery?.("build: start");
       resetStagedBuildAssets(s.projectRoot);
       s.prerenderManifestEntries = null;
       s.staticManifestEntries = null;
+      await timed(
+        debugDiscovery,
+        "build acquireBuildEnv",
+        () => acquireBuildEnv(s, viteCommand, viteMode)
+      );
       let tempServer = null;
       globalThis.__rscRouterDiscoveryActive = true;
       try {
-        tempServer = await createTempRscServer(s, { forceBuild: true });
+        tempServer = await timed(
+          debugDiscovery,
+          "build createTempRscServer",
+          () => createTempRscServer(s, { forceBuild: true })
+        );
         const rscEnv = tempServer.environments?.rsc;
         if (!rscEnv?.runner) {
           console.warn(
@@ -4766,8 +5390,16 @@ ${err.stack}`
         if (tempIdsPlugin?.api?.staticHandlerModules) {
           s.resolvedStaticModules = tempIdsPlugin.api.staticHandlerModules;
         }
-        await discoverRouters(s, rscEnv);
-        writeRouteTypesFiles(s);
+        await timed(
+          debugDiscovery,
+          "build discoverRouters",
+          () => discoverRouters(s, rscEnv)
+        );
+        timedSync(
+          debugDiscovery,
+          "build writeRouteTypesFiles",
+          () => writeRouteTypesFiles(s)
+        );
       } catch (err) {
         const sourceFile = err.stack?.split("\n").find(
           (line) => line.includes(s.projectRoot) && !line.includes("node_modules")
@@ -4786,8 +5418,17 @@ ${details}`
       } finally {
         delete globalThis.__rscRouterDiscoveryActive;
         if (tempServer) {
-          await tempServer.close();
+          await timed(
+            debugDiscovery,
+            "build tempServer.close",
+            () => tempServer.close()
+          );
         }
+        await releaseBuildEnv(s);
+        debugDiscovery?.(
+          "build discovery done (%sms)",
+          (performance.now() - buildStartTime).toFixed(1)
+        );
       }
     },
     // Virtual module: provides the pre-generated route manifest as a JS module
@@ -4804,17 +5445,36 @@ ${details}`
     async load(id) {
       if (id === "\0" + VIRTUAL_ROUTES_MANIFEST_ID) {
         if (s.discoveryDone) {
-          await s.discoveryDone;
+          await timed(
+            debugRoutes,
+            "await discoveryDone (manifest)",
+            () => Promise.resolve(s.discoveryDone)
+          );
         }
-        return generateRoutesManifestModule(s);
+        const code = await timed(
+          debugRoutes,
+          "generateRoutesManifestModule",
+          () => generateRoutesManifestModule(s)
+        );
+        debugRoutes?.("manifest module emitted (%d bytes)", code?.length ?? 0);
+        return code;
       }
       const perRouterPrefix = "\0" + VIRTUAL_ROUTES_MANIFEST_ID + "/";
       if (id.startsWith(perRouterPrefix)) {
         if (s.discoveryDone) {
-          await s.discoveryDone;
+          await timed(
+            debugRoutes,
+            "await discoveryDone (per-router)",
+            () => Promise.resolve(s.discoveryDone)
+          );
         }
         const routerId = id.slice(perRouterPrefix.length);
-        return generatePerRouterModule(s, routerId);
+        const code = await timed(
+          debugRoutes,
+          `generatePerRouterModule ${routerId}`,
+          () => generatePerRouterModule(s, routerId)
+        );
+        return code;
       }
       return null;
     },
@@ -4830,20 +5490,30 @@ ${details}`
       }
       if (!s.resolvedPrerenderModules?.size && !s.resolvedStaticModules?.size)
         return;
+      s.handlerChunkInfoMap.clear();
+      s.staticHandlerChunkInfoMap.clear();
       for (const [fileName, chunk] of Object.entries(bundle)) {
         if (chunk.type !== "chunk") continue;
-        if (fileName.includes("__prerender-handlers") && s.resolvedPrerenderModules?.size) {
+        if (s.resolvedPrerenderModules?.size) {
           const handlers = extractHandlerExportsFromChunk(
             chunk.code,
             s.resolvedPrerenderModules,
             "Prerender",
-            true
+            false
           );
           if (handlers.length > 0) {
-            s.handlerChunkInfo = { fileName, exports: handlers };
+            const existing = s.handlerChunkInfoMap.get(fileName);
+            if (existing) {
+              existing.exports.push(...handlers);
+            } else {
+              s.handlerChunkInfoMap.set(fileName, {
+                fileName,
+                exports: handlers
+              });
+            }
           }
         }
-        if (fileName.includes("__static-handlers") && s.resolvedStaticModules?.size) {
+        if (s.resolvedStaticModules?.size) {
           const handlers = extractHandlerExportsFromChunk(
             chunk.code,
             s.resolvedStaticModules,
@@ -4851,7 +5521,15 @@ ${details}`
             false
           );
           if (handlers.length > 0) {
-            s.staticHandlerChunkInfo = { fileName, exports: handlers };
+            const existing = s.staticHandlerChunkInfoMap.get(fileName);
+            if (existing) {
+              existing.exports.push(...handlers);
+            } else {
+              s.staticHandlerChunkInfoMap.set(fileName, {
+                fileName,
+                exports: handlers
+              });
+            }
           }
         }
       }
@@ -4872,14 +5550,30 @@ ${details}`
 }
 
 // src/vite/rango.ts
+var debugConfig = createRangoDebugger("rango:config");
 async function rango(options) {
+  const rangoStart = performance.now();
   const resolvedOptions = options ?? { preset: "node" };
   const preset = resolvedOptions.preset ?? "node";
   const showBanner = resolvedOptions.banner ?? true;
+  debugConfig?.("rango(%s) setup start", preset);
   const plugins = [];
-  const rangoAliases = getPackageAliases();
-  const excludeDeps = getExcludeDeps();
-  let rscEntryPath = null;
+  const rangoAliases = { ...getPackageAliases(), ...getVendorAliases() };
+  const excludeDeps = [
+    ...getExcludeDeps(),
+    // plugin-rsc itself injects these into the client env's
+    // optimizeDeps.include, which overrides exclude for the dep's own
+    // pre-bundle entry. What exclude still controls is how *other*
+    // pre-bundled deps treat imports of these specs (external vs inlined)
+    // via esbuildCjsExternalPlugin. The cjs-to-esm transform in
+    // plugins/cjs-to-esm.ts is the fallback for strict-pnpm consumers,
+    // where client.browser's bare include fails to resolve and Vite ends up
+    // serving the raw CJS file at dev-serve time.
+    "@vitejs/plugin-rsc/browser",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser"
+  ];
+  const pkg = getPublishedPackageName();
+  const nested = (spec) => `${pkg} > ${spec}`;
   const routerRef = { path: void 0 };
   const prerenderEnabled = true;
   if (preset === "cloudflare") {
@@ -4917,7 +5611,7 @@ async function rango(options) {
               // Pre-bundle rsc-html-stream to prevent discovery during first request
               // Exclude rsc-router modules to ensure same Context instance
               optimizeDeps: {
-                include: ["rsc-html-stream/client"],
+                include: [nested("rsc-html-stream/client")],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions
               }
@@ -4942,8 +5636,10 @@ async function rango(options) {
                   "react-dom/static.edge",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  "rsc-html-stream/server",
-                  "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+                  nested("rsc-html-stream/server"),
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+                  )
                 ],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions
@@ -4958,7 +5654,9 @@ async function rango(options) {
                   "react",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+                  )
                 ],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions
@@ -4975,6 +5673,7 @@ async function rango(options) {
       }
     });
     plugins.push(createVirtualEntriesPlugin(finalEntries));
+    plugins.push(performanceTracksPlugin());
     plugins.push(
       rsc({
         entries: finalEntries,
@@ -4983,153 +5682,126 @@ async function rango(options) {
     );
     plugins.push(clientRefDedup());
   } else {
-    const nodeOptions = resolvedOptions;
-    routerRef.path = nodeOptions.router;
-    if (!routerRef.path) {
-      plugins.push({
-        name: "@rangojs/router:auto-discover",
-        config(userConfig) {
-          if (routerRef.path) return;
-          const root = userConfig.root ? resolve9(process.cwd(), userConfig.root) : process.cwd();
-          const filter = createScanFilter(root, {
-            include: resolvedOptions.include,
-            exclude: resolvedOptions.exclude
-          });
-          const candidates = findRouterFiles(root, filter);
-          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(
-              `[rsc-router] Multiple routers found. Specify \`router\` to choose one:
-${list}`
-            );
-          }
+    plugins.push({
+      name: "@rangojs/router:auto-discover",
+      config(userConfig) {
+        if (routerRef.path) return;
+        const root = userConfig.root ? resolve9(process.cwd(), userConfig.root) : process.cwd();
+        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(`[rsc-router] Multiple routers found:
+${list}`);
         }
-      });
-    }
-    const rscOption = nodeOptions.rsc ?? true;
-    if (rscOption !== false) {
-      const { default: rsc } = await import("@vitejs/plugin-rsc");
-      const userEntries = typeof rscOption === "boolean" ? {} : rscOption.entries || {};
-      const finalEntries = {
-        client: userEntries.client ?? VIRTUAL_IDS.browser,
-        ssr: userEntries.ssr ?? VIRTUAL_IDS.ssr,
-        rsc: userEntries.rsc ?? VIRTUAL_IDS.rsc
-      };
-      rscEntryPath = userEntries.rsc ?? null;
-      let hasWarnedDuplicate = false;
-      plugins.push({
-        name: "@rangojs/router:rsc-integration",
-        enforce: "pre",
-        config() {
-          const useVirtualClient = finalEntries.client === VIRTUAL_IDS.browser;
-          const useVirtualSSR = finalEntries.ssr === VIRTUAL_IDS.ssr;
-          const useVirtualRSC = finalEntries.rsc === VIRTUAL_IDS.rsc;
-          return {
-            // Exclude rsc-router modules from optimization to prevent module duplication
-            // This ensures the same Context instance is used by both browser entry and RSC proxy modules
-            optimizeDeps: {
-              exclude: excludeDeps,
-              esbuildOptions: sharedEsbuildOptions
-            },
-            build: {
-              rollupOptions: { onwarn }
-            },
-            resolve: {
-              alias: rangoAliases
-            },
-            environments: {
-              client: {
-                build: {
-                  rollupOptions: {
-                    output: {
-                      manualChunks: getManualChunks
-                    }
-                  }
-                },
-                // Always exclude rsc-router modules, conditionally add virtual entry
-                optimizeDeps: {
-                  // Pre-bundle React and rsc-html-stream to prevent late discovery
-                  // triggering ERR_OUTDATED_OPTIMIZED_DEP on cold starts
-                  include: [
-                    "react",
-                    "react-dom",
-                    "react/jsx-runtime",
-                    "react/jsx-dev-runtime",
-                    "rsc-html-stream/client"
-                  ],
-                  exclude: excludeDeps,
-                  esbuildOptions: sharedEsbuildOptions,
-                  ...useVirtualClient && {
-                    // Tell Vite to scan the virtual entry for dependencies
-                    entries: [VIRTUAL_IDS.browser]
-                  }
-                }
-              },
-              ...useVirtualSSR && {
-                ssr: {
-                  optimizeDeps: {
-                    entries: [VIRTUAL_IDS.ssr],
-                    // Pre-bundle all SSR deps to prevent late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
-                    include: [
-                      "react",
-                      "react-dom",
-                      "react-dom/server.edge",
-                      "react-dom/static.edge",
-                      "react/jsx-runtime",
-                      "react/jsx-dev-runtime",
-                      "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
-                    ],
-                    exclude: excludeDeps,
-                    esbuildOptions: sharedEsbuildOptions
+      }
+    });
+    const finalEntries = {
+      client: VIRTUAL_IDS.browser,
+      ssr: VIRTUAL_IDS.ssr,
+      rsc: VIRTUAL_IDS.rsc
+    };
+    const { default: rsc } = await import("@vitejs/plugin-rsc");
+    let hasWarnedDuplicate = false;
+    plugins.push({
+      name: "@rangojs/router:rsc-integration",
+      enforce: "pre",
+      config() {
+        return {
+          optimizeDeps: {
+            exclude: excludeDeps,
+            esbuildOptions: sharedEsbuildOptions
+          },
+          build: {
+            rollupOptions: { onwarn }
+          },
+          resolve: {
+            alias: rangoAliases
+          },
+          environments: {
+            client: {
+              build: {
+                rollupOptions: {
+                  output: {
+                    manualChunks: getManualChunks
                   }
                 }
               },
-              ...useVirtualRSC && {
-                rsc: {
-                  optimizeDeps: {
-                    entries: [VIRTUAL_IDS.rsc],
-                    // Pre-bundle all RSC deps to prevent late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
-                    include: [
-                      "react",
-                      "react/jsx-runtime",
-                      "react/jsx-dev-runtime",
-                      "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
-                    ],
-                    esbuildOptions: sharedEsbuildOptions
-                  }
-                }
+              optimizeDeps: {
+                include: [
+                  "react",
+                  "react-dom",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested("rsc-html-stream/client")
+                ],
+                exclude: excludeDeps,
+                esbuildOptions: sharedEsbuildOptions,
+                entries: [VIRTUAL_IDS.browser]
+              }
+            },
+            ssr: {
+              optimizeDeps: {
+                entries: [VIRTUAL_IDS.ssr],
+                include: [
+                  "react",
+                  "react-dom",
+                  "react-dom/server.edge",
+                  "react-dom/static.edge",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+                  )
+                ],
+                exclude: excludeDeps,
+                esbuildOptions: sharedEsbuildOptions
+              }
+            },
+            rsc: {
+              optimizeDeps: {
+                entries: [VIRTUAL_IDS.rsc],
+                include: [
+                  "react",
+                  "react/jsx-runtime",
+                  "react/jsx-dev-runtime",
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+                  )
+                ],
+                esbuildOptions: sharedEsbuildOptions
               }
             }
-          };
-        },
-        configResolved(config) {
-          if (showBanner) {
-            const mode = config.command === "serve" ? process.argv.includes("preview") ? "preview" : "dev" : "build";
-            printBanner(mode, "node", rangoVersion);
-          }
-          const rscMinimalCount = config.plugins.filter(
-            (p) => p.name === "rsc:minimal"
-          ).length;
-          if (rscMinimalCount > 1 && !hasWarnedDuplicate) {
-            hasWarnedDuplicate = true;
-            console.warn(
-              "[rsc-router] Duplicate @vitejs/plugin-rsc detected. Remove rsc() from your config or use rango({ rsc: false }) for manual configuration."
-            );
           }
+        };
+      },
+      configResolved(config) {
+        if (showBanner) {
+          const mode = config.command === "serve" ? process.argv.includes("preview") ? "preview" : "dev" : "build";
+          printBanner(mode, "node", rangoVersion);
         }
-      });
-      plugins.push(createVirtualEntriesPlugin(finalEntries, routerRef));
-      plugins.push(
-        rsc({
-          entries: finalEntries
-        })
-      );
-    }
+        const rscMinimalCount = config.plugins.filter(
+          (p) => p.name === "rsc:minimal"
+        ).length;
+        if (rscMinimalCount > 1 && !hasWarnedDuplicate) {
+          hasWarnedDuplicate = true;
+          console.warn(
+            "[rsc-router] Duplicate @vitejs/plugin-rsc detected. Remove rsc() from your vite config \u2014 rango() includes it automatically."
+          );
+        }
+      }
+    });
+    plugins.push(createVirtualEntriesPlugin(finalEntries, routerRef));
+    plugins.push(performanceTracksPlugin());
+    plugins.push(
+      rsc({
+        entries: finalEntries
+      })
+    );
     plugins.push(clientRefDedup());
   }
   plugins.push({
@@ -5157,20 +5829,24 @@ ${list}`
   plugins.push(createVersionPlugin());
   const discoveryEntryPath = preset !== "cloudflare" ? routerRef.path : void 0;
   const discoveryRouterRef = preset !== "cloudflare" ? routerRef : void 0;
-  const injectorEntryPath = rscEntryPath ?? (preset === "cloudflare" ? void 0 : null);
-  if (injectorEntryPath !== null) {
-    plugins.push(createVersionInjectorPlugin(injectorEntryPath));
+  if (preset === "cloudflare") {
+    plugins.push(createVersionInjectorPlugin(void 0));
   }
   plugins.push(createCjsToEsmPlugin());
   plugins.push(
     createRouterDiscoveryPlugin(discoveryEntryPath, {
       routerPathRef: discoveryRouterRef,
       enableBuildPrerender: prerenderEnabled,
-      staticRouteTypesGeneration: resolvedOptions.staticRouteTypesGeneration,
-      include: resolvedOptions.include,
-      exclude: resolvedOptions.exclude
+      buildEnv: options?.buildEnv,
+      preset
     })
   );
+  debugConfig?.(
+    "rango(%s) setup done: %d plugin(s) (%sms)",
+    preset,
+    plugins.length,
+    (performance.now() - rangoStart).toFixed(1)
+  );
   return plugins;
 }
 
@@ -5181,29 +5857,75 @@ function poke() {
     apply: "serve",
     configureServer(server) {
       const stdin = process.stdin;
-      const previousRawMode = stdin.isTTY ? stdin.isRaw : null;
+      const debug2 = process.env.RANGO_POKE_DEBUG === "1";
+      const triggerReload = (source) => {
+        server.hot.send({ type: "full-reload", path: "*" });
+        server.config.logger.info(`  browser reload (${source})`, {
+          timestamp: true
+        });
+      };
+      const toBuffer = (chunk) => {
+        return typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+      };
+      const formatChunk = (chunk) => {
+        const data = toBuffer(chunk);
+        const hex = Array.from(data).map((byte) => `0x${byte.toString(16).padStart(2, "0")}`).join(" ");
+        const ascii = Array.from(data).map((byte) => {
+          if (byte >= 32 && byte <= 126) return String.fromCharCode(byte);
+          if (byte === 10) return "\\n";
+          if (byte === 13) return "\\r";
+          if (byte === 9) return "\\t";
+          return ".";
+        }).join("");
+        return `len=${data.length} hex=[${hex}] ascii="${ascii}"`;
+      };
+      const readCtrlR = (chunk) => {
+        const data = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+        return data.length === 1 && data[0] === 18;
+      };
+      const readSubmittedCommands = (chunk) => {
+        const text = toBuffer(chunk).toString("utf8").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        if (!text.includes("\n")) return [];
+        const lines = text.split("\n");
+        lines.pop();
+        return lines;
+      };
+      if (debug2) {
+        server.config.logger.info(
+          `  poke debug enabled (isTTY=${stdin.isTTY ? "yes" : "no"}, isRaw=${stdin.isTTY ? stdin.isRaw ? "yes" : "no" : "n/a"})`,
+          { timestamp: true }
+        );
+      }
       if (stdin.isTTY) {
-        stdin.setRawMode(true);
+        server.config.logger.info(
+          "  poke ready: press e + enter to reload browser (ctrl+r also works when available)",
+          { timestamp: true }
+        );
       }
       const onData = (data) => {
-        if (data.length !== 1) return;
-        if (data[0] === 3) {
-          process.emit("SIGINT", "SIGINT");
-          return;
-        }
-        if (data[0] === 18) {
-          server.hot.send({ type: "full-reload", path: "*" });
-          server.config.logger.info("  browser reload (ctrl+r)", {
+        if (debug2) {
+          server.config.logger.info(`  poke stdin ${formatChunk(data)}`, {
             timestamp: true
           });
         }
+        if (readCtrlR(data)) {
+          triggerReload("ctrl+r");
+          return;
+        }
+        for (const command of readSubmittedCommands(data)) {
+          if (command === "e") {
+            triggerReload("e+enter");
+            return;
+          }
+          if (command === "\x1Br") {
+            triggerReload("option+r+enter");
+            return;
+          }
+        }
       };
       stdin.on("data", onData);
       server.httpServer?.on("close", () => {
         stdin.off("data", onData);
-        if (stdin.isTTY && previousRawMode !== null) {
-          stdin.setRawMode(previousRawMode);
-        }
       });
     }
   };