@rangojs/router 0.0.0-experimental.18 → 0.0.0-experimental.1878aa49

package/dist/vite/index.js

@@ -1,6 +1,6 @@
 // src/vite/rango.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 
 // src/vite/plugins/expose-action-id.ts
 import MagicString from "magic-string";
@@ -292,7 +292,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;
@@ -1454,7 +1454,7 @@ function useCacheTransform() {
           transformWrapExport
         );
       }
-      return transformFunctionLevelUseCache(
+      const functionResult = transformFunctionLevelUseCache(
         code,
         ast,
         filePath,
@@ -1462,21 +1462,33 @@ function useCacheTransform() {
         isBuild,
         transformHoistInlineDirective
       );
+      warnOnNearMissDirectives(ast, id, this.warn.bind(this));
+      if (functionResult) return functionResult;
     }
   };
 }
 function transformFileLevelUseCache(code, ast, filePath, sourceId, isBuild, isLayoutOrTemplate, transformWrapExport) {
+  const nonFunctionExports = [];
   const { exportNames, output } = transformWrapExport(code, ast, {
     runtime: (value, name) => {
       const funcId = isBuild ? hashId(filePath, name) : `${filePath}#${name}`;
       return `__rango_registerCachedFunction(${value}, ${JSON.stringify(funcId)}, "default")`;
     },
     rejectNonAsyncFunction: false,
-    filter: (name) => {
+    filter: (name, meta) => {
       if (name === "default" && isLayoutOrTemplate) return false;
+      if (meta.isFunction === false) {
+        nonFunctionExports.push(name);
+        return false;
+      }
       return true;
     }
   });
+  if (nonFunctionExports.length > 0) {
+    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.`
+    );
+  }
   if (exportNames.length === 0) {
     const s = new MagicString5(code);
     const directive2 = findFileLevelDirective(ast);
@@ -1513,7 +1525,7 @@ function transformFileLevelUseCache(code, ast, filePath, sourceId, isBuild, isLa
 function transformFunctionLevelUseCache(code, ast, filePath, sourceId, isBuild, transformHoistInlineDirective) {
   try {
     const { output, names } = transformHoistInlineDirective(code, ast, {
-      directive: /^use cache(:\s*\w+)?$/,
+      directive: /^use cache(:\s*[\w-]+)?$/,
       runtime: (value, name, meta) => {
         const funcId = isBuild ? hashId(filePath, name) : `${filePath}#${name}`;
         const profileMatch = meta.directiveMatch[1];
@@ -1543,6 +1555,82 @@ function findFileLevelDirective(ast) {
   }
   return null;
 }
+var VALID_DIRECTIVE_RE = /^use cache(:\s*[\w-]+)?$/;
+var NEAR_MISS_RE = /^use cache:\s*.+$/;
+function warnOnNearMissDirectives(ast, fileId, warn) {
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "ExpressionStatement" && node.expression?.type === "Literal" && typeof node.expression.value === "string") {
+      const value = node.expression.value;
+      if (value.startsWith("use cache") && NEAR_MISS_RE.test(value) && !VALID_DIRECTIVE_RE.test(value)) {
+        const profilePart = value.slice("use cache:".length).trim();
+        warn(
+          `[rango:use-cache] "${value}" in ${fileId} has an invalid profile name "${profilePart}". Profile names must match [a-zA-Z0-9_-]+. This directive will be ignored.`
+        );
+      }
+    }
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          visit(item);
+        }
+      } else if (child && typeof child === "object" && child.type) {
+        visit(child);
+      }
+    }
+  };
+  for (const node of ast.body ?? []) {
+    visit(node);
+  }
+}
+
+// src/vite/plugins/client-ref-dedup.ts
+var CLIENT_IN_SERVER_PROXY_PREFIX = "virtual:vite-rsc/client-in-server-package-proxy/";
+function extractPackageName(absolutePath) {
+  const marker = "/node_modules/";
+  const idx = absolutePath.lastIndexOf(marker);
+  if (idx === -1) return null;
+  const afterModules = absolutePath.slice(idx + marker.length);
+  if (afterModules.startsWith("@")) {
+    const parts = afterModules.split("/");
+    if (parts.length < 2 || !parts[1]) return null;
+    return `${parts[0]}/${parts[1]}`;
+  }
+  const name = afterModules.split("/")[0];
+  return name || null;
+}
+function clientRefDedup() {
+  let clientExclude = [];
+  return {
+    name: "@rangojs/router:client-ref-dedup",
+    enforce: "pre",
+    apply: "serve",
+    configResolved(config) {
+      const clientEnv = config.environments?.["client"];
+      clientExclude = clientEnv?.optimizeDeps?.exclude ?? config.optimizeDeps?.exclude ?? [];
+    },
+    resolveId(source, importer, options) {
+      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;
+      return `\0rango:dedup/${packageName}`;
+    },
+    load(id) {
+      if (!id.startsWith("\0rango:dedup/")) return;
+      const packageName = id.slice("\0rango:dedup/".length);
+      return [
+        `export * from ${JSON.stringify(packageName)};`,
+        `import * as __all__ from ${JSON.stringify(packageName)};`,
+        `export default __all__.default;`
+      ].join("\n");
+    }
+  };
+}
 
 // src/vite/plugins/virtual-entries.ts
 var VIRTUAL_ENTRY_BROWSER = `
@@ -1657,7 +1745,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.18",
+  version: "0.0.0-experimental.1878aa49",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -1688,7 +1776,7 @@ var package_default = {
     "!src/**/*.test.tsx",
     "dist",
     "skills",
-    "CLAUDE.md",
+    "AGENTS.md",
     "README.md"
   ],
   type: "module",
@@ -1799,7 +1887,7 @@ var package_default = {
     "test:unit:watch": "vitest"
   },
   dependencies: {
-    "@vitejs/plugin-rsc": "^0.5.14",
+    "@vitejs/plugin-rsc": "^0.5.19",
     "magic-string": "^0.30.17",
     picomatch: "^4.0.3",
     "rsc-html-stream": "^0.0.7"
@@ -1970,15 +2058,27 @@ function extractRouteFromCallExpression(node) {
   };
 }
 
+// src/route-name.ts
+var AUTO_GENERATED_ROUTE_PREFIX = "$path_";
+var INTERNAL_INCLUDE_SCOPE_PREFIX = "$prefix_";
+function isAutoGeneratedRouteName(name) {
+  return name.split(".").some((segment) => {
+    return segment.startsWith(AUTO_GENERATED_ROUTE_PREFIX) || segment.startsWith(INTERNAL_INCLUDE_SCOPE_PREFIX);
+  });
+}
+
 // src/build/route-types/codegen.ts
 function generateRouteTypesSource(routeManifest, searchSchemas) {
-  const entries = Object.entries(routeManifest).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
+  const entries = Object.entries(routeManifest).filter(([name]) => !isAutoGeneratedRouteName(name)).sort(([a], [b]) => a.localeCompare(b));
+  const filteredSearchSchemas = searchSchemas ? Object.fromEntries(
+    Object.entries(searchSchemas).filter(
+      ([name]) => !isAutoGeneratedRouteName(name)
+    )
+  ) : void 0;
   const objectBody = entries.map(([name, pattern]) => {
     const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
     const params = extractParamsFromPattern(pattern);
-    const search = searchSchemas?.[name];
+    const search = filteredSearchSchemas?.[name];
     return formatRouteEntry(key, pattern, params, search);
   }).join("\n");
   return `// Auto-generated by @rangojs/router - do not edit
@@ -1995,55 +2095,7 @@ declare global {
 }
 
 // src/build/route-types/scan-filter.ts
-import { join, relative } from "node:path";
-import { readdirSync } from "node:fs";
 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;
-  };
-}
-function findTsFiles(dir, filter) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch (err) {
-    console.warn(
-      `[rsc-router] Failed to scan directory ${dir}: ${err.message}`
-    );
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-      results.push(...findTsFiles(fullPath, filter));
-    } else if ((entry.name.endsWith(".ts") || entry.name.endsWith(".tsx") || entry.name.endsWith(".js") || entry.name.endsWith(".jsx")) && !entry.name.includes(".gen.")) {
-      if (filter && !filter(fullPath)) continue;
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
 
 // src/build/route-types/per-module-writer.ts
 import ts4 from "typescript";
@@ -2244,6 +2296,9 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
         diagnosticsOut
       );
     }
+    if (namePrefix === null) {
+      continue;
+    }
     for (const [name, pattern] of Object.entries(childResult.routes)) {
       const prefixedName = namePrefix ? `${namePrefix}.${name}` : name;
       let prefixedPattern;
@@ -2262,7 +2317,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;
@@ -2278,7 +2333,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;
@@ -2294,14 +2351,110 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
     searchSchemas,
     diagnosticsOut
   );
+  visited.delete(key);
   return { routes, searchSchemas };
 }
 
 // src/build/route-types/router-processing.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3, unlinkSync } from "node:fs";
-import { join as join2, dirname as dirname2, resolve as resolve3, basename as pathBasename } from "node:path";
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  existsSync as existsSync3,
+  unlinkSync,
+  readdirSync
+} from "node:fs";
+import {
+  join,
+  dirname as dirname2,
+  resolve as resolve3,
+  sep,
+  basename as pathBasename
+} from "node:path";
 import ts5 from "typescript";
-function extractUrlsVariableFromRouter(code) {
+function countPublicRouteEntries(source) {
+  const matches = source.matchAll(/^\s+(?:"([^"]+)"|([a-zA-Z_$][^:]*)):\s*["{]/gm) ?? [];
+  let count = 0;
+  for (const match of matches) {
+    const routeName = match[1] || match[2];
+    if (routeName && !isAutoGeneratedRouteName(routeName.trim())) {
+      count++;
+    }
+  }
+  return count;
+}
+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.") && !name.includes(".test.") && !name.includes(".spec.");
+}
+function findRouterFilesRecursive(dir, filter, results) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    console.warn(
+      `[rsc-router] Failed to scan directory ${dir}: ${err.message}`
+    );
+    return;
+  }
+  const childDirs = [];
+  const routerFilesInDir = [];
+  for (const entry of entries) {
+    const fullPath = join(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);
+      continue;
+    }
+    if (!isRoutableSourceFile(entry.name)) continue;
+    if (filter && !filter(fullPath)) continue;
+    try {
+      const source = readFileSync2(fullPath, "utf-8");
+      if (ROUTER_CALL_PATTERN.test(source)) {
+        routerFilesInDir.push(fullPath);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (routerFilesInDir.length > 0) {
+    results.push(...routerFilesInDir);
+    return;
+  }
+  for (const childDir of childDirs) {
+    findRouterFilesRecursive(childDir, filter, results);
+  }
+}
+function findNestedRouterConflict(routerFiles) {
+  const routerDirs = [
+    ...new Set(routerFiles.map((filePath) => dirname2(resolve3(filePath))))
+  ].sort((a, b) => a.length - b.length);
+  for (let i = 0; i < routerDirs.length; i++) {
+    const ancestorDir = routerDirs[i];
+    const prefix = ancestorDir.endsWith(sep) ? ancestorDir : `${ancestorDir}${sep}`;
+    for (let j = i + 1; j < routerDirs.length; j++) {
+      const nestedDir = routerDirs[j];
+      if (!nestedDir.startsWith(prefix)) continue;
+      const ancestorFile = routerFiles.find(
+        (filePath) => dirname2(resolve3(filePath)) === ancestorDir
+      );
+      const nestedFile = routerFiles.find(
+        (filePath) => dirname2(resolve3(filePath)) === nestedDir
+      );
+      if (ancestorFile && nestedFile) {
+        return { ancestor: ancestorFile, nested: nestedFile };
+      }
+    }
+  }
+  return null;
+}
+function formatNestedRouterConflictError(conflict, prefix = "[rsc-router]") {
+  return `${prefix} Nested router roots are not supported.
+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 extractUrlsFromRouter(code) {
   const sourceFile = ts5.createSourceFile(
     "router.tsx",
     code,
@@ -2315,24 +2468,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;
             }
@@ -2345,6 +2544,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 {
@@ -2352,39 +2564,49 @@ 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 files = findTsFiles(root, filter);
   const result = [];
-  for (const filePath of files) {
-    if (filePath.includes(".gen.")) continue;
-    try {
-      const source = readFileSync2(filePath, "utf-8");
-      if (/\bcreateRouter\s*[<(]/.test(source)) {
-        result.push(filePath);
-      }
-    } catch {
-      continue;
-    }
-  }
+  findRouterFilesRecursive(root, filter, result);
   return result;
 }
 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(
@@ -2395,32 +2617,26 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
   }
   const routerFilePaths = knownRouterFiles ?? findRouterFiles(root);
   if (routerFilePaths.length === 0) return;
+  const nestedRouterConflict = findNestedRouterConflict(routerFilePaths);
+  if (nestedRouterConflict) {
+    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`
     );
@@ -2439,8 +2655,10 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
     );
     if (existing !== source) {
       if (opts?.preserveIfLarger && existing) {
-        const existingCount = (existing.match(/^\s+["a-zA-Z_$][^:]*:\s*["{]/gm) || []).length;
-        const newCount = Object.keys(result.routes).length;
+        const existingCount = countPublicRouteEntries(existing);
+        const newCount = Object.keys(result.routes).filter(
+          (name) => !isAutoGeneratedRouteName(name)
+        ).length;
         if (existingCount > newCount) {
           continue;
         }
@@ -2548,8 +2766,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(
@@ -2605,6 +2824,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);
@@ -2634,6 +2856,68 @@ 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";
+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;
+      if (process.env.INTERNAL_RANGO_DEBUG)
+        console.log(
+          "[perf-tracks] patched RSDW client (var:",
+          patched.debugInfoVar,
+          ")"
+        );
+      return patched.code;
+    }
+  };
+}
+
+// src/vite/utils/shared-utils.ts
 var versionEsbuildPlugin = {
   name: "@rangojs/router-version",
   setup(build) {
@@ -2651,7 +2935,7 @@ var versionEsbuildPlugin = {
   }
 };
 var sharedEsbuildOptions = {
-  plugins: [versionEsbuildPlugin]
+  plugins: [versionEsbuildPlugin, performanceTracksOptimizeDepsPlugin()]
 };
 function createVirtualEntriesPlugin(entries, routerPathRef) {
   const virtualModules = {};
@@ -2684,7 +2968,8 @@ function createVirtualEntriesPlugin(entries, routerPathRef) {
           return virtualModules[virtualId];
         }
         if (virtualId === VIRTUAL_IDS.rsc && routerPathRef?.path) {
-          const absoluteRouterPath = routerPathRef.path.startsWith(".") ? "/" + routerPathRef.path.slice(2) : routerPathRef.path;
+          const raw = routerPathRef.path.startsWith(".") ? "/" + routerPathRef.path.slice(2) : routerPathRef.path;
+          const absoluteRouterPath = raw.replaceAll("\\", "/");
           return getVirtualEntryRSC(absoluteRouterPath);
         }
       }
@@ -2733,11 +3018,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}
 `;
@@ -2854,6 +3139,7 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
+import { resolve as resolve8 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
 
 // src/vite/plugins/virtual-stub-plugin.ts
@@ -2881,7 +3167,7 @@ function createVirtualStubPlugin() {
 }
 
 // src/vite/plugins/client-ref-hashing.ts
-import { relative as relative2, posix } 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/";
@@ -2894,10 +3180,10 @@ function computeProductionHash(projectRoot, refKey) {
     const absPath = decodeURIComponent(
       refKey.slice(CLIENT_IN_SERVER_PKG_PROXY_PREFIX.length)
     );
-    toHash = posix.normalize(relative2(projectRoot, absPath));
+    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith(FS_PREFIX)) {
     const absPath = refKey.slice(FS_PREFIX.length - 1);
-    toHash = posix.normalize(relative2(projectRoot, absPath));
+    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith("/")) {
     toHash = refKey.slice(1);
   } else {
@@ -3036,8 +3322,8 @@ function createDiscoveryState(entryPath, opts) {
     perRouterTrieMap: /* @__PURE__ */ new Map(),
     perRouterPrecomputedMap: /* @__PURE__ */ new Map(),
     perRouterManifestDataMap: /* @__PURE__ */ new Map(),
-    prerenderCollectedData: null,
-    staticCollectedData: null,
+    prerenderManifestEntries: null,
+    staticManifestEntries: null,
     handlerChunkInfo: null,
     staticHandlerChunkInfo: null,
     rscEntryFileName: null,
@@ -3122,8 +3408,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(
@@ -3131,18 +3426,46 @@ 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);
+    }
   }
 }
 
 // src/vite/utils/prerender-utils.ts
+import { createHash as createHash4 } from "node:crypto";
+import {
+  copyFileSync,
+  existsSync as existsSync4,
+  mkdirSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { resolve as resolve5 } from "node:path";
 function escapeRegExp2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function encodePathParam(value) {
   return String(value).split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
+function substituteRouteParams(pattern, params, encode = encodeURIComponent) {
+  let result = pattern;
+  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));
+  }
+  return result;
+}
 async function runWithConcurrency(items, concurrency, fn) {
   const limit = Math.max(1, Math.min(concurrency, items.length));
   if (limit <= 1) {
@@ -3203,6 +3526,37 @@ function notifyOnError(registry, error, phase, routeKey, pathname, skipped) {
     break;
   }
 }
+function getStagedAssetDir(projectRoot) {
+  return resolve5(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
+}
+function resetStagedBuildAssets(projectRoot) {
+  rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
+}
+function stageBuildAssetModule(projectRoot, prefix, exportValue) {
+  const stagedDir = getStagedAssetDir(projectRoot);
+  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)) {
+    writeFileSync2(filePath, `export default ${exportValue};
+`);
+  }
+  return fileName;
+}
+function copyStagedBuildAssets(projectRoot, fileNames) {
+  const stagedDir = getStagedAssetDir(projectRoot);
+  const distAssetsDir = resolve5(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);
+    copyFileSync(stagedPath, distPath);
+    totalBytes += statSync(stagedPath).size;
+  }
+  return totalBytes;
+}
 
 // src/vite/discovery/prerender-collection.ts
 async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
@@ -3215,18 +3569,8 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   const getParamsReverse = (name, params) => {
     const pattern = allRoutes[name];
     if (!pattern) throw new Error(`Unknown route: "${name}"`);
-    let result = pattern;
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        const escaped = escapeRegExp2(key);
-        result = result.replace(
-          new RegExp(`:${escaped}(\\([^)]*\\))?`),
-          encodeURIComponent(value)
-        );
-        result = result.replace(`*${key}`, encodeURIComponent(value));
-      }
-    }
-    return result;
+    if (!params) return pattern;
+    return substituteRouteParams(pattern, params);
   };
   for (const { manifest } of allManifests) {
     if (!manifest.prerenderRoutes) continue;
@@ -3234,15 +3578,17 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
     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
+          concurrency: 1,
+          isPassthroughRoute
         });
       } else {
-        const def = defs[routeName];
         if (def?.getParams) {
           try {
             const buildVars = {};
@@ -3257,18 +3603,11 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
             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 = pattern;
-              for (const [key, value] of Object.entries(
-                params
-              )) {
-                const encoded = encodePathParam(value);
-                const escaped = escapeRegExp2(key);
-                url = url.replace(
-                  new RegExp(`:${escaped}(\\([^)]*\\))?`),
-                  encoded
-                );
-                url = url.replace(`*${key}`, encoded);
-              }
+              let url = substituteRouteParams(
+                pattern,
+                params,
+                encodePathParam
+              );
               if (url.includes("*")) {
                 const wildcardValue = params["*"] ?? params.splat;
                 if (wildcardValue !== void 0) {
@@ -3279,7 +3618,8 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
                 urlPath: url.replace(/\/$/, "") || "/",
                 routeName,
                 concurrency,
-                ...hasBuildVars ? { buildVars } : {}
+                ...hasBuildVars ? { buildVars } : {},
+                isPassthroughRoute
               });
             }
           } catch (err) {
@@ -3318,7 +3658,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
     `[rsc-router] Pre-rendering ${entries.length} URL(s)${concurrencyNote}...`
   );
   const { hashParams } = await rscEnv.runner.import("@rangojs/router/build");
-  const collectedData = {};
+  const manifestEntries = {};
   let doneCount = 0;
   let skipCount = 0;
   const startTotal = performance.now();
@@ -3335,22 +3675,43 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
             const result = await routerInstance.matchForPrerender(
               entry.urlPath,
               {},
-              entry.buildVars
+              entry.buildVars,
+              entry.isPassthroughRoute
             );
             if (!result) continue;
+            if (result.passthrough) {
+              const elapsed2 = (performance.now() - startUrl).toFixed(0);
+              console.log(
+                `[rsc-router]   PASS ${entry.urlPath.padEnd(40)} (${elapsed2}ms) - live fallback`
+              );
+              doneCount++;
+              break;
+            }
             const paramHash = hashParams(result.params || {});
-            collectedData[`${result.routeName}/${paramHash}`] = {
+            const mainKey = `${result.routeName}/${paramHash}`;
+            const mainValue = JSON.stringify({
               segments: result.segments,
               handles: result.handles
-            };
+            });
+            manifestEntries[mainKey] = stageBuildAssetModule(
+              state.projectRoot,
+              "__pr",
+              mainValue
+            );
             if (result.interceptSegments?.length) {
-              collectedData[`${result.routeName}/${paramHash}/i`] = {
+              const interceptKey = `${result.routeName}/${paramHash}/i`;
+              const interceptValue = JSON.stringify({
                 segments: [...result.segments, ...result.interceptSegments],
                 handles: {
                   ...result.handles,
                   ...result.interceptHandles || {}
                 }
-              };
+              });
+              manifestEntries[interceptKey] = stageBuildAssetModule(
+                state.projectRoot,
+                "__pr",
+                interceptValue
+              );
             }
             const elapsed = (performance.now() - startUrl).toFixed(0);
             console.log(
@@ -3394,7 +3755,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   }
   const totalElapsed = (performance.now() - startTotal).toFixed(0);
   if (doneCount > 0) {
-    state.prerenderCollectedData = collectedData;
+    state.prerenderManifestEntries = manifestEntries;
   }
   const parts = [`${doneCount} done`];
   if (skipCount > 0) parts.push(`${skipCount} skipped`);
@@ -3405,7 +3766,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
 async function renderStaticHandlers(state, rscEnv, registry) {
   if (!state.opts?.enableBuildPrerender || !state.isBuildMode || !state.resolvedStaticModules?.size)
     return;
-  const collected = {};
+  const manifestEntries = {};
   let staticDone = 0;
   let staticSkip = 0;
   let totalStaticCount = 0;
@@ -3442,7 +3803,13 @@ async function renderStaticHandlers(state, rscEnv, registry) {
             def.$$routePrefix
           );
           if (result) {
-            collected[def.$$id] = result;
+            const hasHandles = Object.keys(result.handles).length > 0;
+            const exportValue = hasHandles ? JSON.stringify(result) : JSON.stringify(result.encoded);
+            manifestEntries[def.$$id] = stageBuildAssetModule(
+              state.projectRoot,
+              "__st",
+              exportValue
+            );
             const elapsed = (performance.now() - startHandler).toFixed(0);
             console.log(
               `[rsc-router]   OK   ${name.padEnd(40)} (${elapsed}ms)`
@@ -3479,7 +3846,7 @@ async function renderStaticHandlers(state, rscEnv, registry) {
   }
   const totalStaticElapsed = (performance.now() - startStatic).toFixed(0);
   if (staticDone > 0) {
-    state.staticCollectedData = collected;
+    state.staticManifestEntries = manifestEntries;
   }
   const staticParts = [`${staticDone} done`];
   if (staticSkip > 0) staticParts.push(`${staticSkip} skipped`);
@@ -3496,8 +3863,7 @@ async function discoverRouters(state, rscEnv) {
   let registry = serverMod.RouterRegistry;
   if (!registry || registry.size === 0) {
     try {
-      const hostMod = await rscEnv.runner.import("@rangojs/router/host");
-      const hostRegistry = hostMod.HostRouterRegistry;
+      const hostRegistry = serverMod.HostRouterRegistry;
       if (hostRegistry && hostRegistry.size > 0) {
         console.log(
           `[rsc-router] Found ${hostRegistry.size} host router(s), resolving lazy handlers...`
@@ -3537,12 +3903,20 @@ async function discoverRouters(state, rscEnv) {
   }
   const buildMod = await rscEnv.runner.import("@rangojs/router/build");
   const generateManifestFull = buildMod.generateManifestFull;
-  state.mergedRouteManifest = {};
-  state.mergedPrecomputedEntries = [];
-  state.perRouterManifests = [];
-  state.perRouterManifestDataMap = /* @__PURE__ */ new Map();
-  state.perRouterPrecomputedMap = /* @__PURE__ */ new Map();
-  state.perRouterTrieMap = /* @__PURE__ */ new Map();
+  const nestedRouterConflict = findNestedRouterConflict(
+    [...registry.values()].map((router) => router.__sourceFile).filter(
+      (sourceFile) => typeof sourceFile === "string"
+    )
+  );
+  if (nestedRouterConflict) {
+    throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
+  }
+  const newMergedRouteManifest = {};
+  const newMergedPrecomputedEntries = [];
+  const newPerRouterManifests = [];
+  const newPerRouterManifestDataMap = /* @__PURE__ */ new Map();
+  const newPerRouterPrecomputedMap = /* @__PURE__ */ new Map();
+  const newPerRouterTrieMap = /* @__PURE__ */ new Map();
   let mergedRouteAncestry = {};
   let mergedRouteTrailingSlash = {};
   let routerMountIndex = 0;
@@ -3551,7 +3925,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;
@@ -3559,7 +3937,7 @@ async function discoverRouters(state, rscEnv) {
       (p) => !p.includes(":") && !p.includes("*")
     ).length;
     const dynamicRoutes = routeCount - staticRoutes;
-    Object.assign(state.mergedRouteManifest, manifest.routeManifest);
+    Object.assign(newMergedRouteManifest, manifest.routeManifest);
     let factoryOnlyPrefixes;
     if (router.__sourceFile) {
       const staticParsed = buildCombinedRouteMapForRouterFile(
@@ -3577,7 +3955,7 @@ async function discoverRouters(state, rscEnv) {
       }
       if (factoryOnlyPrefixes.size === 0) factoryOnlyPrefixes = void 0;
     }
-    state.perRouterManifests.push({
+    newPerRouterManifests.push({
       id,
       routeManifest: manifest.routeManifest,
       routeSearchSchemas: manifest.routeSearchSchemas,
@@ -3593,16 +3971,16 @@ async function discoverRouters(state, rscEnv) {
     flattenLeafEntries(
       manifest.prefixTree,
       manifest.routeManifest,
-      state.mergedPrecomputedEntries
+      newMergedPrecomputedEntries
     );
-    state.perRouterManifestDataMap.set(id, manifest.routeManifest);
+    newPerRouterManifestDataMap.set(id, manifest.routeManifest);
     const routerPrecomputed = [];
     flattenLeafEntries(
       manifest.prefixTree,
       manifest.routeManifest,
       routerPrecomputed
     );
-    state.perRouterPrecomputedMap.set(id, routerPrecomputed);
+    newPerRouterPrecomputedMap.set(id, routerPrecomputed);
     console.log(
       `[rsc-router] Router "${id}" -> ${routeCount} routes (${staticRoutes} static, ${dynamicRoutes} dynamic)`
     );
@@ -3617,7 +3995,8 @@ async function discoverRouters(state, rscEnv) {
       );
     }
   }
-  if (state.mergedRouteManifest && Object.keys(state.mergedRouteManifest).length > 0) {
+  let newMergedRouteTrie = null;
+  if (Object.keys(newMergedRouteManifest).length > 0) {
     const buildRouteTrie = buildMod.buildRouteTrie;
     if (buildRouteTrie && mergedRouteAncestry) {
       const routeToStaticPrefix = {};
@@ -3647,8 +4026,8 @@ async function discoverRouters(state, rscEnv) {
           Object.assign(mergedResponseTypeRoutes, manifest.responseTypeRoutes);
         }
       }
-      state.mergedRouteTrie = buildRouteTrie(
-        state.mergedRouteManifest,
+      newMergedRouteTrie = buildRouteTrie(
+        newMergedRouteManifest,
         mergedRouteAncestry,
         routeToStaticPrefix,
         Object.keys(mergedRouteTrailingSlash).length > 0 ? mergedRouteTrailingSlash : void 0,
@@ -3675,22 +4054,29 @@ async function discoverRouters(state, rscEnv) {
           perRouterPassthroughNames && perRouterPassthroughNames.size > 0 ? perRouterPassthroughNames : void 0,
           manifest.responseTypeRoutes && Object.keys(manifest.responseTypeRoutes).length > 0 ? manifest.responseTypeRoutes : void 0
         );
-        state.perRouterTrieMap.set(id, perRouterTrie);
+        newPerRouterTrieMap.set(id, perRouterTrie);
       }
     }
   }
+  state.mergedRouteManifest = newMergedRouteManifest;
+  state.mergedPrecomputedEntries = newMergedPrecomputedEntries;
+  state.perRouterManifests = newPerRouterManifests;
+  state.perRouterManifestDataMap = newPerRouterManifestDataMap;
+  state.perRouterPrecomputedMap = newPerRouterPrecomputedMap;
+  state.perRouterTrieMap = newPerRouterTrieMap;
+  state.mergedRouteTrie = newMergedRouteTrie;
   await expandPrerenderRoutes(state, rscEnv, registry, allManifests);
   await renderStaticHandlers(state, rscEnv, registry);
   return serverMod;
 }
 
 // src/vite/discovery/route-types-writer.ts
-import { dirname as dirname3, basename, join as join3, resolve as resolve5 } from "node:path";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, unlinkSync as unlinkSync2 } from "node:fs";
+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 = {};
   for (const [name, pattern] of Object.entries(manifest)) {
-    if (!name.startsWith("$")) {
+    if (!isAutoGeneratedRouteName(name)) {
       filtered[name] = pattern;
     }
   }
@@ -3706,7 +4092,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 {
@@ -3719,8 +4105,8 @@ function writeCombinedRouteTypesWithTracking(state, opts) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const outPath = join3(routerDir, `${routerBasename}.named-routes.gen.ts`);
-    if (!existsSync4(outPath)) continue;
+    const outPath = join2(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    if (!existsSync5(outPath)) continue;
     try {
       const content = readFileSync4(outPath, "utf-8");
       if (content !== preContent.get(outPath)) {
@@ -3734,10 +4120,10 @@ function writeRouteTypesFiles(state) {
   if (state.perRouterManifests.length === 0) return;
   try {
     const entryDir = dirname3(
-      resolve5(state.projectRoot, state.resolvedEntryPath)
+      resolve6(state.projectRoot, state.resolvedEntryPath)
     );
-    const oldCombinedPath = join3(entryDir, "named-routes.gen.ts");
-    if (existsSync4(oldCombinedPath)) {
+    const oldCombinedPath = join2(entryDir, "named-routes.gen.ts");
+    if (existsSync5(oldCombinedPath)) {
       unlinkSync2(oldCombinedPath);
       console.log(
         `[rsc-router] Removed stale combined route types: ${oldCombinedPath}`
@@ -3761,7 +4147,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) {
@@ -3781,10 +4167,10 @@ Set an explicit \`id\` on createRouter() or check the call site.`
       userRoutes,
       effectiveSearchSchemas && Object.keys(effectiveSearchSchemas).length > 0 ? effectiveSearchSchemas : void 0
     );
-    const existing = existsSync4(outPath) ? readFileSync4(outPath, "utf-8") : null;
+    const existing = existsSync5(outPath) ? readFileSync4(outPath, "utf-8") : null;
     if (existing !== source) {
       markSelfGenWrite(state, outPath, source);
-      writeFileSync2(outPath, source);
+      writeFileSync3(outPath, source);
       console.log(`[rsc-router] Generated route types -> ${outPath}`);
     }
   }
@@ -3813,7 +4199,7 @@ function supplementGenFilesWithRuntimeRoutes(state) {
       ...staticParsed.searchSchemas
     };
     for (const [name, pattern] of Object.entries(routeManifest)) {
-      if (name.startsWith("$")) continue;
+      if (isAutoGeneratedRouteName(name)) continue;
       const dotIdx = name.indexOf(".");
       if (dotIdx <= 0) continue;
       const prefix = name.substring(0, dotIdx + 1);
@@ -3826,21 +4212,21 @@ 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
     );
-    const existing = existsSync4(outPath) ? readFileSync4(outPath, "utf-8") : null;
+    const existing = existsSync5(outPath) ? readFileSync4(outPath, "utf-8") : null;
     if (existing !== source) {
       markSelfGenWrite(state, outPath, source);
-      writeFileSync2(outPath, source);
+      writeFileSync3(outPath, source);
     }
   }
 }
 
 // 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) {
@@ -3855,10 +4241,10 @@ function generateRoutesManifestModule(state) {
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join4(
+        const genPath = join3(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
-        );
+        ).replaceAll("\\", "/");
         const varName = `_r${varIdx++}`;
         genFileImports.push(
           `import { NamedRoutes as ${varName} } from ${JSON.stringify(genPath)};`
@@ -3952,7 +4338,10 @@ function generatePerRouterModule(state, routerId) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const genPath = join4(routerDir, `${routerBasename}.named-routes.gen.js`);
+    const genPath = join3(
+      routerDir,
+      `${routerBasename}.named-routes.gen.js`
+    ).replaceAll("\\", "/");
     lines.push(`import { NamedRoutes as _r } from ${JSON.stringify(genPath)};`);
     lines.push(
       `function __flat(r) { const o = {}; for (const [k, v] of Object.entries(r)) o[k] = typeof v === "string" ? v : v.path; return o; }`
@@ -3976,14 +4365,13 @@ function generatePerRouterModule(state, routerId) {
 }
 
 // src/vite/discovery/bundle-postprocess.ts
-import { resolve as resolve6 } from "node:path";
-import { createHash as createHash4 } from "node:crypto";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync } from "node:fs";
+import { resolve as resolve7 } from "node:path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "node:fs";
 function postprocessBundle(state) {
-  const hasPrerenderData = state.prerenderCollectedData && Object.keys(state.prerenderCollectedData).length > 0;
-  const hasStaticData = state.staticCollectedData && Object.keys(state.staticCollectedData).length > 0;
+  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 = resolve6(
+  const rscEntryPath = resolve7(
     state.projectRoot,
     "dist/rsc",
     state.rscEntryFileName ?? "index.js"
@@ -4004,7 +4392,7 @@ function postprocessBundle(state) {
   ];
   for (const target of evictionTargets) {
     if (!target.info) continue;
-    const chunkPath = resolve6(
+    const chunkPath = resolve7(
       state.projectRoot,
       "dist/rsc",
       target.info.fileName
@@ -4018,7 +4406,7 @@ function postprocessBundle(state) {
         target.brand
       );
       if (result) {
-        writeFileSync3(chunkPath, result.code);
+        writeFileSync4(chunkPath, result.code);
         const savedKB = (result.savedBytes / 1024).toFixed(1);
         console.log(
           `[rsc-router] Evicted ${target.label} (${savedKB} KB saved): ${target.info.fileName}`
@@ -4032,44 +4420,38 @@ function postprocessBundle(state) {
   }
   state.handlerChunkInfo = null;
   state.staticHandlerChunkInfo = null;
-  if (hasPrerenderData && existsSync5(rscEntryPath)) {
+  if (hasPrerenderData && existsSync6(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
-    if (!rscCode.includes("__PRERENDER_MANIFEST")) {
+    if (!rscCode.includes("__prerender-manifest.js")) {
       try {
-        const assetsDir = resolve6(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
-        const manifestEntries = [];
-        let totalBytes = 0;
-        for (const [key, entry] of Object.entries(
-          state.prerenderCollectedData
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.prerenderManifestEntries)
+        );
+        const manifestMap = {};
+        for (const [key, assetFileName] of Object.entries(
+          state.prerenderManifestEntries
         )) {
-          const entryJson = JSON.stringify(entry);
-          const contentHash = createHash4("sha256").update(entryJson).digest("hex").slice(0, 8);
-          const assetFileName = `__pr-${contentHash}.js`;
-          const assetPath = resolve6(assetsDir, assetFileName);
-          const assetCode = `export default ${entryJson};
-`;
-          writeFileSync3(assetPath, assetCode);
-          totalBytes += Buffer.byteLength(assetCode);
-          manifestEntries.push(
-            `${JSON.stringify(key)}:()=>import("./assets/${assetFileName}")`
-          );
+          manifestMap[key] = `./assets/${assetFileName}`;
         }
-        const manifestCode = `const m={${manifestEntries.join(",")}};export default m;
-`;
-        const manifestPath = resolve6(
+        const manifestCode = [
+          `const m=JSON.parse('${JSON.stringify(manifestMap).replace(/'/g, "\\'")}');`,
+          `export function loadPrerenderAsset(s){return import(s)}`,
+          `export default m;`,
+          ""
+        ].join("\n");
+        const manifestPath = resolve7(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js"
         );
-        writeFileSync3(manifestPath, manifestCode);
+        writeFileSync4(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
-        const injection = `import __pm from "./__prerender-manifest.js";
-globalThis.__PRERENDER_MANIFEST = __pm;
+        const injection = `globalThis.__loadPrerenderManifestModule = () => import("./__prerender-manifest.js");
 `;
-        writeFileSync3(rscEntryPath, injection + rscCode);
+        writeFileSync4(rscEntryPath, injection + rscCode);
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
-          `[rsc-router] Wrote prerender assets (${totalKB} KB total, ${Object.keys(state.prerenderCollectedData).length} entries)`
+          `[rsc-router] Wrote prerender assets (${totalKB} KB total, ${Object.keys(state.prerenderManifestEntries).length} entries)`
         );
       } catch (err) {
         throw new Error(
@@ -4078,44 +4460,36 @@ globalThis.__PRERENDER_MANIFEST = __pm;
       }
     }
   }
-  if (hasStaticData && existsSync5(rscEntryPath)) {
+  if (hasStaticData && existsSync6(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__STATIC_MANIFEST")) {
       try {
-        const assetsDir = resolve6(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
         const manifestEntries = [];
-        let totalBytes = 0;
-        for (const [handlerId, { encoded, handles }] of Object.entries(
-          state.staticCollectedData
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.staticManifestEntries)
+        );
+        for (const [handlerId, assetFileName] of Object.entries(
+          state.staticManifestEntries
         )) {
-          const contentHash = createHash4("sha256").update(encoded).digest("hex").slice(0, 8);
-          const assetFileName = `__st-${contentHash}.js`;
-          const assetPath = resolve6(assetsDir, assetFileName);
-          const hasHandles = Object.keys(handles).length > 0;
-          const exportValue = hasHandles ? JSON.stringify({ encoded, handles }) : JSON.stringify(encoded);
-          const assetCode = `export default ${exportValue};
-`;
-          writeFileSync3(assetPath, assetCode);
-          totalBytes += Buffer.byteLength(assetCode);
           manifestEntries.push(
             `${JSON.stringify(handlerId)}:()=>import("./assets/${assetFileName}")`
           );
         }
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;
 `;
-        const manifestPath = resolve6(
+        const manifestPath = resolve7(
           state.projectRoot,
           "dist/rsc/__static-manifest.js"
         );
-        writeFileSync3(manifestPath, manifestCode);
+        writeFileSync4(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
         const injection = `import "./__static-manifest.js";
 `;
-        writeFileSync3(rscEntryPath, injection + rscCode);
+        writeFileSync4(rscEntryPath, injection + rscCode);
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
-          `[rsc-router] Wrote static assets (${totalKB} KB total, ${Object.keys(state.staticCollectedData).length} entries)`
+          `[rsc-router] Wrote static assets (${totalKB} KB total, ${Object.keys(state.staticManifestEntries).length} entries)`
         );
       } catch (err) {
         throw new Error(
@@ -4205,12 +4579,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 });
@@ -4230,8 +4598,8 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       if (globalThis.__rscRouterDiscoveryActive) return;
       s.devServer = server;
       let resolveDiscovery;
-      const discoveryPromise = new Promise((resolve8) => {
-        resolveDiscovery = resolve8;
+      const discoveryPromise = new Promise((resolve10) => {
+        resolveDiscovery = resolve10;
       });
       const getDevServerOrigin = () => server.resolvedUrls?.local?.[0]?.replace(/\/$/, "") || `http://localhost:${server.config.server.port || 5173}`;
       let prerenderTempServer = null;
@@ -4293,34 +4661,10 @@ ${err.stack}`
           if (serverMod?.setManifestReadyPromise) {
             serverMod.setManifestReadyPromise(discoveryPromise);
           }
-          const serverModAfterDiscovery = await discoverRouters(s, rscEnv);
-          mainRegistry = serverModAfterDiscovery?.RouterRegistry ?? null;
+          await discoverRouters(s, rscEnv);
           s.devServerOrigin = getDevServerOrigin();
           writeRouteTypesFiles(s);
-          if (s.mergedRouteManifest && serverMod?.setCachedManifest) {
-            serverMod.setCachedManifest(s.mergedRouteManifest);
-          }
-          if (s.mergedPrecomputedEntries && s.mergedPrecomputedEntries.length > 0 && serverMod?.setPrecomputedEntries) {
-            serverMod.setPrecomputedEntries(s.mergedPrecomputedEntries);
-          }
-          if (s.mergedRouteTrie && serverMod?.setRouteTrie) {
-            serverMod.setRouteTrie(s.mergedRouteTrie);
-          }
-          if (serverMod?.setRouterManifest) {
-            for (const [routerId, manifest] of s.perRouterManifestDataMap) {
-              serverMod.setRouterManifest(routerId, manifest);
-            }
-          }
-          if (serverMod?.setRouterTrie) {
-            for (const [routerId, trie] of s.perRouterTrieMap) {
-              serverMod.setRouterTrie(routerId, trie);
-            }
-          }
-          if (serverMod?.setRouterPrecomputedEntries) {
-            for (const [routerId, entries] of s.perRouterPrecomputedMap) {
-              serverMod.setRouterPrecomputedEntries(routerId, entries);
-            }
-          }
+          await propagateDiscoveryState(rscEnv);
         } catch (err) {
           console.warn(
             `[rsc-router] Router discovery failed: ${err.message}
@@ -4330,10 +4674,42 @@ ${err.stack}`
           resolveDiscovery();
         }
       };
-      s.discoveryDone = new Promise((resolve8) => {
-        setTimeout(() => discover().then(resolve8, resolve8), 0);
+      s.discoveryDone = new Promise((resolve10) => {
+        setTimeout(() => discover().then(resolve10, resolve10), 0);
       });
       let mainRegistry = null;
+      const propagateDiscoveryState = async (rscEnv) => {
+        const serverMod = await rscEnv.runner.import("@rangojs/router/server");
+        if (!serverMod) return;
+        if (serverMod.clearAllRouterData) {
+          serverMod.clearAllRouterData();
+        }
+        mainRegistry = serverMod.RouterRegistry ?? null;
+        if (s.mergedRouteManifest && serverMod.setCachedManifest) {
+          serverMod.setCachedManifest(s.mergedRouteManifest);
+        }
+        if (s.mergedPrecomputedEntries && s.mergedPrecomputedEntries.length > 0 && serverMod.setPrecomputedEntries) {
+          serverMod.setPrecomputedEntries(s.mergedPrecomputedEntries);
+        }
+        if (s.mergedRouteTrie && serverMod.setRouteTrie) {
+          serverMod.setRouteTrie(s.mergedRouteTrie);
+        }
+        if (serverMod.setRouterManifest) {
+          for (const [routerId, manifest] of s.perRouterManifestDataMap) {
+            serverMod.setRouterManifest(routerId, manifest);
+          }
+        }
+        if (serverMod.setRouterTrie) {
+          for (const [routerId, trie] of s.perRouterTrieMap) {
+            serverMod.setRouterTrie(routerId, trie);
+          }
+        }
+        if (serverMod.setRouterPrecomputedEntries) {
+          for (const [routerId, entries] of s.perRouterPrecomputedMap) {
+            serverMod.setRouterPrecomputedEntries(routerId, entries);
+          }
+        }
+      };
       server.middlewares.use("/__rsc_prerender", async (req, res) => {
         if (s.discoveryDone) await s.discoveryDone;
         const url = new URL(req.url || "/", "http://localhost");
@@ -4356,11 +4732,20 @@ ${err.stack}`
           return;
         }
         const wantIntercept = url.searchParams.get("intercept") === "1";
+        const wantRouteName = url.searchParams.get("routeName");
+        const wantPassthrough = url.searchParams.get("passthrough") === "1";
         for (const [, routerInstance] of registry) {
           if (!routerInstance.matchForPrerender) continue;
           try {
-            const result = await routerInstance.matchForPrerender(pathname, {});
+            const result = await routerInstance.matchForPrerender(
+              pathname,
+              {},
+              void 0,
+              wantPassthrough
+            );
             if (!result) continue;
+            if (result.passthrough) continue;
+            if (wantRouteName && result.routeName !== wantRouteName) continue;
             res.setHeader("content-type", "application/json");
             let payload;
             if (wantIntercept && result.interceptSegments?.length) {
@@ -4397,10 +4782,29 @@ ${err.stack}`
         const maybeHandleGeneratedRouteFileMutation = (filePath) => {
           if (!isGeneratedRouteFile(filePath)) return false;
           if (consumeSelfGenWrite(s, filePath)) return true;
+          const hasRunner = !!server.environments?.rsc?.runner;
+          if (!hasRunner) return true;
           regenerateGeneratedRouteFiles();
           return true;
         };
         let routeChangeTimer;
+        let runtimeRediscoveryInProgress = false;
+        const refreshRuntimeDiscovery = async () => {
+          const rscEnv = server.environments?.rsc;
+          if (!rscEnv?.runner || runtimeRediscoveryInProgress) return;
+          runtimeRediscoveryInProgress = true;
+          try {
+            await discoverRouters(s, rscEnv);
+            writeRouteTypesFiles(s);
+            await propagateDiscoveryState(rscEnv);
+          } catch (err) {
+            console.warn(
+              `[rsc-router] Runtime re-discovery failed: ${err.message}`
+            );
+          } finally {
+            runtimeRediscoveryInProgress = false;
+          }
+        };
         const scheduleRouteRegeneration = () => {
           clearTimeout(routeChangeTimer);
           routeChangeTimer = setTimeout(() => {
@@ -4415,6 +4819,13 @@ ${err.stack}`
                 `[rsc-router] Route regeneration error: ${err.message}`
               );
             }
+            if (s.perRouterManifests.length > 0) {
+              refreshRuntimeDiscovery().catch((err) => {
+                console.warn(
+                  `[rsc-router] Runtime re-discovery error: ${err.message}`
+                );
+              });
+            }
           }, 100);
         };
         const handleRouteFileChange = (filePath) => {
@@ -4431,6 +4842,16 @@ ${err.stack}`
             const hasCreateRouter = /\bcreateRouter\s*[<(]/.test(source);
             if (!hasUrls && !hasCreateRouter) return;
             if (hasCreateRouter) {
+              const nestedRouterConflict = findNestedRouterConflict([
+                ...s.cachedRouterFiles ?? [],
+                resolve8(filePath)
+              ]);
+              if (nestedRouterConflict) {
+                server.config.logger.error(
+                  formatNestedRouterConflictError(nestedRouterConflict)
+                );
+                return;
+              }
               s.cachedRouterFiles = void 0;
             }
             scheduleRouteRegeneration();
@@ -4441,6 +4862,8 @@ ${err.stack}`
         server.watcher.on("change", handleRouteFileChange);
         server.watcher.on("unlink", (filePath) => {
           if (!isGeneratedRouteFile(filePath)) return;
+          const hasRunner = !!server.environments?.rsc?.runner;
+          if (!hasRunner) return;
           regenerateGeneratedRouteFiles();
         });
       }
@@ -4451,6 +4874,9 @@ ${err.stack}`
     async buildStart() {
       if (!s.isBuildMode) return;
       if (s.mergedRouteManifest !== null) return;
+      resetStagedBuildAssets(s.projectRoot);
+      s.prerenderManifestEntries = null;
+      s.staticManifestEntries = null;
       let tempServer = null;
       globalThis.__rscRouterDiscoveryActive = true;
       try {
@@ -4580,8 +5006,16 @@ async function rango(options) {
   const showBanner = resolvedOptions.banner ?? true;
   const plugins = [];
   const rangoAliases = getPackageAliases();
-  const excludeDeps = getExcludeDeps();
-  let rscEntryPath = null;
+  const excludeDeps = [
+    ...getExcludeDeps(),
+    // The public browser entry re-exports the RSDW browser client.
+    // Excluding both keeps Vite from freezing the unpatched bundle into
+    // .vite/deps before our source transforms run.
+    "@vitejs/plugin-rsc/browser",
+    // Keep the browser RSDW client out of Vite's dep optimizer so our
+    // cjs-to-esm transform can patch the real file.
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser"
+  ];
   const routerRef = { path: void 0 };
   const prerenderEnabled = true;
   if (preset === "cloudflare") {
@@ -4677,160 +5111,132 @@ async function rango(options) {
       }
     });
     plugins.push(createVirtualEntriesPlugin(finalEntries));
+    plugins.push(performanceTracksPlugin());
     plugins.push(
       rsc({
         entries: finalEntries,
         serverHandler: false
       })
     );
+    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 ? resolve7(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;
-          } 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",
+                  "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",
+                  "@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",
+                  "@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({
     name: "@rangojs/router:client-component-hmr",
@@ -4857,22 +5263,55 @@ ${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
+      staticRouteTypesGeneration: resolvedOptions.staticRouteTypesGeneration
     })
   );
   return plugins;
 }
+
+// src/vite/plugins/refresh-cmd.ts
+function poke() {
+  return {
+    name: "vite-plugin-poke",
+    apply: "serve",
+    configureServer(server) {
+      const stdin = process.stdin;
+      const previousRawMode = stdin.isTTY ? stdin.isRaw : null;
+      if (stdin.isTTY) {
+        stdin.setRawMode(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)", {
+            timestamp: true
+          });
+        }
+      };
+      stdin.on("data", onData);
+      server.httpServer?.on("close", () => {
+        stdin.off("data", onData);
+        if (stdin.isTTY && previousRawMode !== null) {
+          stdin.setRawMode(previousRawMode);
+        }
+      });
+    }
+  };
+}
 export {
+  poke,
   rango
 };