@rangojs/router 0.0.0-experimental.f3c21dba → 0.0.0-experimental.f4a8e8de

package/dist/bin/rango.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -22,10 +27,10 @@ function extractParamsFromPattern(pattern) {
 function formatRouteEntry(key, pattern, _params, search) {
   const hasSearch = search && Object.keys(search).length > 0;
   if (!hasSearch) {
-    return `  ${key}: "${pattern}",`;
+    return `  ${key}: ${JSON.stringify(pattern)},`;
   }
-  const searchBody = Object.entries(search).map(([k, v]) => `${k}: "${v}"`).join(", ");
-  return `  ${key}: { path: "${pattern}", search: { ${searchBody} } },`;
+  const searchBody = Object.entries(search).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
+  return `  ${key}: { path: ${JSON.stringify(pattern)}, search: { ${searchBody} } },`;
 }
 var init_param_extraction = __esm({
   "src/build/route-types/param-extraction.ts"() {
@@ -59,8 +64,8 @@ var init_ast_helpers = __esm({
 
 // src/build/route-types/ast-route-extraction.ts
 import ts2 from "typescript";
-function extractRoutesFromSource(code) {
-  const sourceFile = ts2.createSourceFile(
+function extractRoutesFromSource(code, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts2.createSourceFile(
     "input.tsx",
     code,
     ts2.ScriptTarget.Latest,
@@ -139,7 +144,7 @@ function generatePerModuleTypesSource(routes) {
   const valid = routes.filter(({ name }) => {
     if (!name || /["'\\`\n\r]/.test(name)) {
       console.warn(
-        `[rsc-router] Skipping route with invalid name: ${JSON.stringify(name)}`
+        `[rango] Skipping route with invalid name: ${JSON.stringify(name)}`
       );
       return false;
     }
@@ -149,7 +154,7 @@ function generatePerModuleTypesSource(routes) {
   for (const { name, pattern, params, search } of valid) {
     if (deduped.has(name)) {
       console.warn(
-        `[rsc-router] Duplicate route name "${name}" \u2014 keeping first definition`
+        `[rango] Duplicate route name "${name}" \u2014 keeping first definition`
       );
       continue;
     }
@@ -185,9 +190,13 @@ export const NamedRoutes = {
 ${objectBody}
 } as const;
 
+// Aliased so the augmentation below does not pay a homomorphic mapped-type
+// instantiation per route; \`as const\` already makes the members readonly.
+type NamedRoutesShape = typeof NamedRoutes;
+
 declare global {
-  namespace RSCRouter {
-    interface GeneratedRouteMap extends Readonly<typeof NamedRoutes> {}
+  namespace Rango {
+    interface GeneratedRouteMap extends NamedRoutesShape {}
   }
 }
 `;
@@ -211,14 +220,15 @@ function findTsFiles(dir, filter) {
     entries = readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     console.warn(
-      `[rsc-router] Failed to scan directory ${dir}: ${err.message}`
+      `[rango] 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;
+      if (entry.name === "node_modules" || entry.name.startsWith(".") || entry.name === "dist" || entry.name === "build" || entry.name === "coverage")
+        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;
@@ -237,6 +247,37 @@ var init_scan_filter = __esm({
 import { readFileSync, existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import ts3 from "typescript";
+function createScanMemo() {
+  return { files: /* @__PURE__ */ new Map(), blockSourceFiles: /* @__PURE__ */ new Map() };
+}
+function parseBlock(memo, block) {
+  if (memo) {
+    const cached = memo.blockSourceFiles.get(block);
+    if (cached) return cached;
+  }
+  const sf = ts3.createSourceFile(
+    "input.tsx",
+    block,
+    ts3.ScriptTarget.Latest,
+    true,
+    ts3.ScriptKind.TSX
+  );
+  if (memo) memo.blockSourceFiles.set(block, sf);
+  return sf;
+}
+function readSourceMemoized(memo, realPath) {
+  if (memo) {
+    const cached = memo.files.get(realPath);
+    if (cached !== void 0) return cached;
+  }
+  const source = readFileSync(realPath, "utf-8");
+  if (memo) memo.files.set(realPath, source);
+  return source;
+}
+function isUrlsDefinitionCall(node) {
+  const callee = node.expression;
+  return ts3.isIdentifier(callee) && (callee.text === "urls" || callee.text === "clientUrls");
+}
 function extractNamePrefixFromInclude(node) {
   if (node.arguments.length >= 3) {
     const thirdArg = node.arguments[2];
@@ -252,8 +293,95 @@ function extractNamePrefixFromInclude(node) {
   }
   return null;
 }
-function extractIncludesWithDiagnostics(code) {
-  const sourceFile = ts3.createSourceFile(
+function thenSelectsNonDefaultMember(expr) {
+  const findThenCall = (e) => {
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression) && e.expression.name.text === "then") {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findThenCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findThenCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findThenCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findThenCall(e.expression);
+    return null;
+  };
+  const thenCall = findThenCall(expr);
+  if (!thenCall || thenCall.arguments.length === 0) return false;
+  const cb = thenCall.arguments[0];
+  if (!ts3.isArrowFunction(cb) && !ts3.isFunctionExpression(cb)) return false;
+  let ret;
+  if (ts3.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        ret = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    ret = cb.body;
+  }
+  if (!ret) return false;
+  if (ts3.isPropertyAccessExpression(ret)) {
+    return ret.name.text !== "default";
+  }
+  return false;
+}
+function extractDynamicImportSpecifier(node) {
+  let body;
+  if (ts3.isArrowFunction(node) || ts3.isFunctionExpression(node)) {
+    body = node.body;
+  }
+  if (!body) return null;
+  let expr;
+  if (ts3.isBlock(body)) {
+    for (const stmt of body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        expr = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    expr = body;
+  }
+  if (!expr) return null;
+  const findImportCall = (e) => {
+    if (ts3.isCallExpression(e) && e.expression.kind === ts3.SyntaxKind.ImportKeyword) {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findImportCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findImportCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findImportCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findImportCall(e.expression);
+    return null;
+  };
+  const importCall = findImportCall(expr);
+  if (!importCall || importCall.arguments.length === 0) return null;
+  if (thenSelectsNonDefaultMember(expr)) return null;
+  return getStringValue(importCall.arguments[0]);
+}
+function resolveDefaultExportTarget(code, sourceFile) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts3.isExportAssignment(node) && !node.isExportEquals) {
+      const expr = node.expression;
+      if (ts3.isIdentifier(expr)) {
+        result = { variableName: expr.text };
+      } else if (ts3.isCallExpression(expr) && isUrlsDefinitionCall(expr)) {
+        result = { inlineBlock: expr.getText(sourceFile) };
+      }
+      return;
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function extractIncludesWithDiagnostics(code, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
     code,
     ts3.ScriptTarget.Latest,
@@ -277,12 +405,19 @@ function extractIncludesWithDiagnostics(code) {
         }
         const secondArg = node.arguments[1];
         const namePrefix = extractNamePrefixFromInclude(node);
+        const dynamicImportSpec = extractDynamicImportSpecifier(secondArg);
         if (ts3.isIdentifier(secondArg)) {
           resolved.push({
             pathPrefix,
             variableName: secondArg.text,
             namePrefix
           });
+        } else if (dynamicImportSpec !== null) {
+          resolved.push({
+            pathPrefix,
+            moduleSpecifier: dynamicImportSpec,
+            namePrefix
+          });
         } else if (ts3.isCallExpression(secondArg)) {
           const callText = secondArg.expression.getText(sourceFile);
           unresolvable.push({
@@ -307,7 +442,14 @@ function extractIncludesWithDiagnostics(code) {
   return { resolved, unresolvable };
 }
 function resolveImportedVariable(code, localName) {
-  const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
+  const defaultImportRegex = /import\s+([\w$]+)\s*(?:,\s*\{[^}]*\})?\s+from\s*["']([^"']+)["']/g;
+  let defaultMatch;
+  while ((defaultMatch = defaultImportRegex.exec(code)) !== null) {
+    if (defaultMatch[1] === localName) {
+      return { specifier: defaultMatch[2], exportedName: "default" };
+    }
+  }
+  const importRegex = /import\s*(?:[\w$]+\s*,\s*)?\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
   let match;
   while ((match = importRegex.exec(code)) !== null) {
     const imports = match[1];
@@ -344,8 +486,8 @@ function resolveImportPath(importSpec, fromFile) {
   }
   return null;
 }
-function extractUrlsBlockForVariable(code, varName) {
-  const sourceFile = ts3.createSourceFile(
+function extractUrlsBlockForVariable(code, varName, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
     code,
     ts3.ScriptTarget.Latest,
@@ -356,8 +498,7 @@ function extractUrlsBlockForVariable(code, varName) {
   function visit(node) {
     if (result) return;
     if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.name.text === varName && node.initializer && ts3.isCallExpression(node.initializer)) {
-      const callee = node.initializer.expression;
-      if (ts3.isIdentifier(callee) && callee.text === "urls") {
+      if (isUrlsDefinitionCall(node.initializer)) {
         result = node.initializer.getText(sourceFile);
         return;
       }
@@ -367,67 +508,113 @@ function extractUrlsBlockForVariable(code, varName) {
   visit(sourceFile);
   return result;
 }
-function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut, diagnosticsOut) {
+function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut, diagnosticsOut, memo) {
   const routeMap = {};
-  const localRoutes = extractRoutesFromSource(block);
+  const blockSourceFile = parseBlock(memo, block);
+  const localRoutes = extractRoutesFromSource(block, blockSourceFile);
   for (const { name, pattern, search } of localRoutes) {
     routeMap[name] = pattern;
     if (search && searchSchemasOut) {
       searchSchemasOut[name] = search;
     }
   }
-  const { resolved: includes, unresolvable } = extractIncludesWithDiagnostics(block);
+  const { resolved: includes, unresolvable } = extractIncludesWithDiagnostics(
+    block,
+    blockSourceFile
+  );
   if (diagnosticsOut) {
     for (const entry of unresolvable) {
       diagnosticsOut.push({ ...entry, sourceFile: filePath });
     }
   }
-  for (const { pathPrefix, variableName, namePrefix } of includes) {
+  for (const inc of includes) {
+    const { pathPrefix, namePrefix } = inc;
     let childResult;
-    const imported = resolveImportedVariable(fullSource, variableName);
-    if (imported) {
-      const targetFile = resolveImportPath(imported.specifier, filePath);
+    if (inc.moduleSpecifier) {
+      const targetFile = resolveImportPath(inc.moduleSpecifier, filePath);
       if (!targetFile) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "file-not-found",
-            sourceFile: filePath,
-            detail: `import "${imported.specifier}" resolved to no file`
-          });
-        }
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to no file`
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        targetFile,
-        imported.exportedName,
-        visited,
-        diagnosticsOut
-      );
-    } else {
-      const sameFileBlock = extractUrlsBlockForVariable(
-        fullSource,
-        variableName
+      let targetSource;
+      try {
+        targetSource = readSourceMemoized(memo, resolve(targetFile));
+      } catch (err) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to "${targetFile}" but reading it failed: ${err?.message ?? String(err)}`
+        });
+        continue;
+      }
+      const def = resolveDefaultExportTarget(
+        targetSource,
+        parseBlock(memo, targetSource)
       );
-      if (!sameFileBlock) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "unresolvable-import",
-            sourceFile: filePath,
-            detail: `variable "${variableName}" not found in imports or same-file scope`
-          });
-        }
+      if (!def) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "unresolvable-import",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") has no resolvable \`export default urls(...)\``
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        filePath,
+      if (def.inlineBlock) {
+        childResult = buildCombinedRouteMapWithSearch(
+          targetFile,
+          void 0,
+          visited,
+          diagnosticsOut,
+          def.inlineBlock,
+          memo
+        );
+      } else {
+        const variableName = def.variableName;
+        const resolved = resolveIncludedVariable({
+          variableName,
+          resolutionFile: targetFile,
+          resolutionSource: targetSource,
+          reportFile: filePath,
+          memo,
+          visited,
+          diagnosticsOut,
+          pathPrefix,
+          namePrefix,
+          fileNotFoundDetail: (specifier) => `import("${inc.moduleSpecifier}") default re-exports "${variableName}" from "${specifier}", which resolved to no file`,
+          notFoundDetail: () => `import("${inc.moduleSpecifier}") default "${variableName}" not found in its imports or same-file scope`
+        });
+        if (!resolved) continue;
+        childResult = resolved;
+      }
+    } else if (inc.variableName) {
+      const variableName = inc.variableName;
+      const resolved = resolveIncludedVariable({
         variableName,
+        resolutionFile: filePath,
+        resolutionSource: fullSource,
+        reportFile: filePath,
+        memo,
         visited,
-        diagnosticsOut
-      );
+        diagnosticsOut,
+        pathPrefix,
+        namePrefix,
+        fileNotFoundDetail: (specifier) => `import "${specifier}" resolved to no file`,
+        notFoundDetail: () => `variable "${variableName}" not found in imports or same-file scope`
+      });
+      if (!resolved) continue;
+      childResult = resolved;
+    } else {
+      continue;
     }
     if (namePrefix === null) {
       continue;
@@ -450,24 +637,131 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
-function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut) {
+function resolveIncludedVariable(opts) {
+  const {
+    variableName,
+    resolutionFile,
+    resolutionSource,
+    reportFile,
+    memo,
+    visited,
+    diagnosticsOut,
+    pathPrefix,
+    namePrefix
+  } = opts;
+  const imported = resolveImportedVariable(resolutionSource, variableName);
+  if (imported) {
+    const targetFile = resolveImportPath(imported.specifier, resolutionFile);
+    if (!targetFile) {
+      diagnosticsOut?.push({
+        pathPrefix,
+        namePrefix,
+        reason: "file-not-found",
+        sourceFile: reportFile,
+        detail: opts.fileNotFoundDetail(imported.specifier)
+      });
+      return null;
+    }
+    return buildCombinedRouteMapWithSearch(
+      targetFile,
+      imported.exportedName,
+      visited,
+      diagnosticsOut,
+      void 0,
+      memo
+    );
+  }
+  const sameFileBlock = extractUrlsBlockForVariable(
+    resolutionSource,
+    variableName,
+    parseBlock(memo, resolutionSource)
+  );
+  if (!sameFileBlock) {
+    diagnosticsOut?.push({
+      pathPrefix,
+      namePrefix,
+      reason: "unresolvable-import",
+      sourceFile: reportFile,
+      detail: opts.notFoundDetail()
+    });
+    return null;
+  }
+  return buildCombinedRouteMapWithSearch(
+    resolutionFile,
+    variableName,
+    visited,
+    diagnosticsOut,
+    void 0,
+    memo
+  );
+}
+function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut, inlineBlock, memo) {
   visited = visited ?? /* @__PURE__ */ new Set();
+  memo = memo ?? createScanMemo();
   const realPath = resolve(filePath);
   const key = variableName ? `${realPath}:${variableName}` : realPath;
   if (visited.has(key)) {
-    console.warn(`[rsc-router] Circular include detected, skipping: ${key}`);
+    console.warn(`[rango] Circular include detected, skipping: ${key}`);
     return { routes: {}, searchSchemas: {} };
   }
   visited.add(key);
   let source;
   try {
-    source = readFileSync(realPath, "utf-8");
+    source = readSourceMemoized(memo, realPath);
   } catch {
     return { routes: {}, searchSchemas: {} };
   }
   let block;
-  if (variableName) {
-    const extracted = extractUrlsBlockForVariable(source, variableName);
+  if (inlineBlock) {
+    block = inlineBlock;
+  } else if (variableName === "default") {
+    const defaultTarget = resolveDefaultExportTarget(
+      source,
+      parseBlock(memo, source)
+    );
+    if (!defaultTarget) {
+      visited.delete(key);
+      return { routes: {}, searchSchemas: {} };
+    }
+    if (defaultTarget.inlineBlock) {
+      block = defaultTarget.inlineBlock;
+    } else {
+      const targetName = defaultTarget.variableName;
+      const imported = resolveImportedVariable(source, targetName);
+      if (imported) {
+        const targetFile = resolveImportPath(imported.specifier, realPath);
+        if (!targetFile) {
+          visited.delete(key);
+          return { routes: {}, searchSchemas: {} };
+        }
+        const result = buildCombinedRouteMapWithSearch(
+          targetFile,
+          imported.exportedName,
+          visited,
+          diagnosticsOut,
+          void 0,
+          memo
+        );
+        visited.delete(key);
+        return result;
+      }
+      const extracted = extractUrlsBlockForVariable(
+        source,
+        targetName,
+        parseBlock(memo, source)
+      );
+      if (!extracted) {
+        visited.delete(key);
+        return { routes: {}, searchSchemas: {} };
+      }
+      block = extracted;
+    }
+  } else if (variableName) {
+    const extracted = extractUrlsBlockForVariable(
+      source,
+      variableName,
+      parseBlock(memo, source)
+    );
     if (!extracted) return { routes: {}, searchSchemas: {} };
     block = extracted;
   } else {
@@ -480,7 +774,8 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
     realPath,
     visited,
     searchSchemas,
-    diagnosticsOut
+    diagnosticsOut,
+    memo
   );
   visited.delete(key);
   return { routes, searchSchemas };
@@ -508,7 +803,7 @@ function findUrlsVariableNames(code) {
   function visit(node) {
     if (ts4.isVariableDeclaration(node) && ts4.isIdentifier(node.name) && node.initializer && ts4.isCallExpression(node.initializer)) {
       const callee = node.initializer.expression;
-      if (ts4.isIdentifier(callee) && callee.text === "urls") {
+      if (ts4.isIdentifier(callee) && (callee.text === "urls" || callee.text === "clientUrls")) {
         names.push(node.name.text);
       }
     }
@@ -520,13 +815,21 @@ function findUrlsVariableNames(code) {
 function writePerModuleRouteTypesForFile(filePath) {
   try {
     const source = readFileSync2(filePath, "utf-8");
-    if (!source.includes("urls(")) return;
+    if (!source.includes("urls(") && !source.includes("clientUrls(")) return;
     const varNames = findUrlsVariableNames(source);
     let routes;
     if (varNames.length > 0) {
       routes = [];
+      const memo = createScanMemo();
       for (const varName of varNames) {
-        const { routes: routeMap, searchSchemas } = buildCombinedRouteMapWithSearch(filePath, varName);
+        const { routes: routeMap, searchSchemas } = buildCombinedRouteMapWithSearch(
+          filePath,
+          varName,
+          void 0,
+          void 0,
+          void 0,
+          memo
+        );
         for (const [name, pattern] of Object.entries(routeMap)) {
           const params = extractParamsFromPattern(pattern);
           routes.push({
@@ -540,12 +843,12 @@ function writePerModuleRouteTypesForFile(filePath) {
     } else {
       routes = extractRoutesFromSource(source);
     }
-    const genPath = filePath.replace(/\.(tsx?)$/, ".gen.ts");
+    const genPath = filePath.replace(/\.(tsx?|jsx?)$/, ".gen.ts");
     if (routes.length === 0) {
       if (varNames.length > 0 && !existsSync2(genPath)) {
         writeFileSync(genPath, generatePerModuleTypesSource([]));
         console.log(
-          `[rsc-router] Generated route types (placeholder) -> ${genPath}`
+          `[rango] Generated route types (placeholder) -> ${genPath}`
         );
       }
       return;
@@ -554,11 +857,11 @@ function writePerModuleRouteTypesForFile(filePath) {
     const existing = existsSync2(genPath) ? readFileSync2(genPath, "utf-8") : null;
     if (existing !== genSource) {
       writeFileSync(genPath, genSource);
-      console.log(`[rsc-router] Generated route types -> ${genPath}`);
+      console.log(`[rango] Generated route types -> ${genPath}`);
     }
   } catch (err) {
     console.warn(
-      `[rsc-router] Failed to generate route types for ${filePath}: ${err.message}`
+      `[rango] Failed to generate route types for ${filePath}: ${err.message}`
     );
   }
 }
@@ -573,6 +876,131 @@ var init_per_module_writer = __esm({
   }
 });
 
+// src/build/route-types/source-scan.ts
+function isLineTerminator(ch) {
+  const c = ch.charCodeAt(0);
+  return c === 10 || c === 13 || c === 8232 || c === 8233;
+}
+function isRegexPositionAt(code, slashPos, prevChar) {
+  if (prevChar === void 0) return true;
+  if (prevChar === ")" || prevChar === "]" || prevChar === "}") return false;
+  if (!/[\w$]/.test(prevChar)) return true;
+  let k = slashPos - 1;
+  while (k >= 0 && /\s/.test(code[k])) k--;
+  const wordEnd = k + 1;
+  while (k >= 0 && /[\w$]/.test(code[k])) k--;
+  return REGEX_PRECEDING_KEYWORDS.has(code.slice(k + 1, wordEnd));
+}
+function makeCodeClassifier(code) {
+  const n = code.length;
+  let i = 0;
+  let skipStart = -1;
+  let skipEnd = -1;
+  let lastSig;
+  return (q) => {
+    if (q >= skipStart && q < skipEnd) return false;
+    while (i < n && i <= q) {
+      const c = code[i];
+      const d = i + 1 < n ? code[i + 1] : "";
+      let end = -1;
+      let transparent = false;
+      if (c === "/" && d === "/") {
+        let j = i + 2;
+        while (j < n && !isLineTerminator(code[j])) j++;
+        end = j;
+        transparent = true;
+      } else if (c === "/" && d === "*") {
+        let j = i + 2;
+        while (j < n && !(code[j] === "*" && code[j + 1] === "/")) j++;
+        end = Math.min(n, j + 2);
+        transparent = true;
+      } else if (c === '"' || c === "'" || c === "`") {
+        let j = i + 1;
+        while (j < n) {
+          if (code[j] === "\\") {
+            j += 2;
+            continue;
+          }
+          if (code[j] === c) {
+            j++;
+            break;
+          }
+          j++;
+        }
+        end = j;
+      } else if (c === "/" && d !== "/" && d !== "*" && isRegexPositionAt(code, i, lastSig)) {
+        let j = i + 1;
+        let inClass = false;
+        let closed = false;
+        while (j < n && !isLineTerminator(code[j])) {
+          const r = code[j];
+          if (r === "\\") {
+            j += 2;
+            continue;
+          }
+          if (r === "[") inClass = true;
+          else if (r === "]") inClass = false;
+          else if (r === "/" && !inClass) {
+            j++;
+            closed = true;
+            break;
+          }
+          j++;
+        }
+        if (closed) {
+          while (j < n && /[a-z]/.test(code[j])) j++;
+          end = j;
+        }
+      }
+      if (end >= 0) {
+        if (q < end) {
+          skipStart = i;
+          skipEnd = end;
+          return false;
+        }
+        i = end;
+        if (!transparent) lastSig = "x";
+      } else {
+        if (!/\s/.test(c)) lastSig = c;
+        i++;
+      }
+    }
+    return true;
+  };
+}
+function firstCodeMatchIndex(code, pattern) {
+  const inCode = makeCodeClassifier(code);
+  pattern.lastIndex = 0;
+  let m;
+  while ((m = pattern.exec(code)) !== null) {
+    if (inCode(m.index)) return m.index;
+    if (pattern.lastIndex <= m.index) pattern.lastIndex = m.index + 1;
+  }
+  return -1;
+}
+var REGEX_PRECEDING_KEYWORDS;
+var init_source_scan = __esm({
+  "src/build/route-types/source-scan.ts"() {
+    "use strict";
+    REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+      "return",
+      "typeof",
+      "instanceof",
+      "in",
+      "of",
+      "new",
+      "delete",
+      "void",
+      "do",
+      "else",
+      "yield",
+      "await",
+      "case",
+      "throw"
+    ]);
+  }
+});
+
 // src/build/route-types/router-processing.ts
 import {
   readFileSync as readFileSync3,
@@ -603,43 +1031,50 @@ function countPublicRouteEntries(source) {
 function isRoutableSourceFile(name) {
   return (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".jsx")) && !name.includes(".gen.") && !name.includes(".test.") && !name.includes(".spec.");
 }
-function findRouterFilesRecursive(dir, filter, results) {
+function isExcludedScanDir(name) {
+  return name === "node_modules" || name === "dist" || name === "coverage" || name === "__tests__" || name === "__mocks__" || name.startsWith(".");
+}
+function findCallSiteFilesRecursive(dir, pattern, patternG, stopAtMatchDir, filter, results) {
   let entries;
   try {
     entries = readdirSync2(dir, { withFileTypes: true });
   } catch (err) {
     console.warn(
-      `[rsc-router] Failed to scan directory ${dir}: ${err.message}`
+      `[rango] Failed to scan directory ${dir}: ${err.message}`
     );
     return;
   }
   const childDirs = [];
-  const routerFilesInDir = [];
+  const matchesInDir = [];
   for (const entry of entries) {
     const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage" || entry.name === "__tests__" || entry.name === "__mocks__" || entry.name.startsWith("."))
-        continue;
-      childDirs.push(fullPath);
+      if (!isExcludedScanDir(entry.name)) childDirs.push(fullPath);
       continue;
     }
     if (!isRoutableSourceFile(entry.name)) continue;
     if (filter && !filter(fullPath)) continue;
     try {
       const source = readFileSync3(fullPath, "utf-8");
-      if (ROUTER_CALL_PATTERN.test(source)) {
-        routerFilesInDir.push(fullPath);
+      if (pattern.test(source) && firstCodeMatchIndex(source, patternG) >= 0) {
+        matchesInDir.push(fullPath);
       }
     } catch {
       continue;
     }
   }
-  if (routerFilesInDir.length > 0) {
-    results.push(...routerFilesInDir);
-    return;
-  }
-  for (const childDir of childDirs) {
-    findRouterFilesRecursive(childDir, filter, results);
+  results.push(...matchesInDir);
+  if (!stopAtMatchDir || matchesInDir.length === 0) {
+    for (const childDir of childDirs) {
+      findCallSiteFilesRecursive(
+        childDir,
+        pattern,
+        patternG,
+        stopAtMatchDir,
+        filter,
+        results
+      );
+    }
   }
 }
 function findNestedRouterConflict(routerFiles) {
@@ -665,13 +1100,39 @@ function findNestedRouterConflict(routerFiles) {
   }
   return null;
 }
-function formatNestedRouterConflictError(conflict, prefix = "[rsc-router]") {
+function formatNestedRouterConflictError(conflict, prefix = "[rango]") {
   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 extractUrlsVariableFromRouter(code) {
+function isCreateRouterCall(node) {
+  if (!ts5.isCallExpression(node)) return false;
+  const callee = node.expression;
+  return ts5.isIdentifier(callee) && callee.text === "createRouter";
+}
+function extractUrlsArgument(node, sourceFile) {
+  if (ts5.isIdentifier(node)) {
+    return { kind: "variable", name: node.text };
+  }
+  if (ts5.isArrowFunction(node) || ts5.isFunctionExpression(node)) {
+    return { kind: "inline", block: node.getText(sourceFile) };
+  }
+  return null;
+}
+function collectCreateRouterCallChain(endpoint) {
+  const calls = [];
+  let current = endpoint;
+  while (true) {
+    calls.push(current);
+    if (isCreateRouterCall(current)) return calls.reverse();
+    if (!ts5.isPropertyAccessExpression(current.expression)) return null;
+    const receiver = current.expression.expression;
+    if (!ts5.isCallExpression(receiver)) return null;
+    current = receiver;
+  }
+}
+function extractAllUrlsFromRouter(code) {
   const sourceFile = ts5.createSourceFile(
     "router.tsx",
     code,
@@ -680,29 +1141,62 @@ function extractUrlsVariableFromRouter(code) {
     ts5.ScriptKind.TSX
   );
   let result = null;
-  function isCreateRouterCall(node) {
-    if (!ts5.isCallExpression(node)) return false;
-    const callee = node.expression;
-    return ts5.isIdentifier(callee) && callee.text === "createRouter";
-  }
   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)) {
+      const chain = collectCreateRouterCallChain(node);
+      if (chain) {
+        const extracted = [];
+        const createRouterCall = chain[0];
+        for (const callArg of createRouterCall.arguments) {
+          if (!ts5.isObjectLiteralExpression(callArg)) continue;
+          for (const prop of callArg.properties) {
+            if (!ts5.isPropertyAssignment(prop) || !ts5.isIdentifier(prop.name) || prop.name.text !== "urls") {
+              continue;
+            }
+            const urls = extractUrlsArgument(prop.initializer, sourceFile);
+            if (urls) extracted.push(urls);
+            break;
+          }
+        }
+        for (const call of chain.slice(1)) {
+          if (!ts5.isPropertyAccessExpression(call.expression) || call.expression.name.text !== "routes" || call.arguments.length === 0) {
+            continue;
+          }
+          const urls = extractUrlsArgument(call.arguments[0], sourceFile);
+          if (urls) extracted.push(urls);
+        }
+        if (extracted.length > 0) {
+          result = extracted;
+          return;
+        }
       }
     }
-    if (isCreateRouterCall(node)) {
-      const callExpr = node;
-      for (const arg of callExpr.arguments) {
+    ts5.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result ?? [];
+}
+function extractUrlsFromRouter(code) {
+  const extractions = extractAllUrlsFromRouter(code);
+  return extractions[extractions.length - 1] ?? null;
+}
+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;
             }
@@ -715,6 +1209,91 @@ function extractUrlsVariableFromRouter(code) {
   visit(sourceFile);
   return result;
 }
+function applyBasenameToRoutes(result, basename) {
+  const prefixed = {};
+  for (const [name, pattern] of Object.entries(result.routes)) {
+    if (pattern === "/") {
+      prefixed[name] = basename;
+    } else if (basename.endsWith("/") && pattern.startsWith("/")) {
+      prefixed[name] = basename + pattern.slice(1);
+    } else {
+      prefixed[name] = basename + pattern;
+    }
+  }
+  return { routes: prefixed, searchSchemas: result.searchSchemas };
+}
+function resolveRouterUrlsExtraction(routerFilePath, routerSource, extraction, diagnosticsOut, memo) {
+  if (extraction.kind === "inline") {
+    return buildCombinedRouteMapWithSearch(
+      routerFilePath,
+      void 0,
+      /* @__PURE__ */ new Set(),
+      diagnosticsOut,
+      extraction.block,
+      memo
+    );
+  }
+  const imported = resolveImportedVariable(routerSource, extraction.name);
+  if (imported) {
+    const targetFile = resolveImportPath(imported.specifier, routerFilePath);
+    if (!targetFile) {
+      diagnosticsOut?.push({
+        pathPrefix: "/",
+        namePrefix: null,
+        reason: "file-not-found",
+        sourceFile: routerFilePath,
+        detail: `import "${imported.specifier}" resolved to no file`
+      });
+      return { routes: {}, searchSchemas: {} };
+    }
+    return buildCombinedRouteMapWithSearch(
+      targetFile,
+      imported.exportedName,
+      /* @__PURE__ */ new Set(),
+      diagnosticsOut,
+      void 0,
+      memo
+    );
+  }
+  return buildCombinedRouteMapWithSearch(
+    routerFilePath,
+    extraction.name,
+    /* @__PURE__ */ new Set(),
+    diagnosticsOut,
+    void 0,
+    memo
+  );
+}
+function mergeRouteMaps(target, source) {
+  for (const [name, pattern] of Object.entries(source.routes)) {
+    target.routes[name] = pattern;
+    const search = source.searchSchemas[name];
+    if (search) {
+      target.searchSchemas[name] = search;
+    } else {
+      delete target.searchSchemas[name];
+    }
+  }
+}
+function genFileTsPath(sourceFile) {
+  const base = pathBasename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
+  return join2(dirname2(sourceFile), `${base}.named-routes.gen.ts`);
+}
+function resolveSearchSchemas(publicRouteNames, runtimeSchemas, sourceFile) {
+  if (runtimeSchemas && Object.keys(runtimeSchemas).length > 0) {
+    return runtimeSchemas;
+  }
+  const staticParsed = buildCombinedRouteMapForRouterFile(sourceFile);
+  if (Object.keys(staticParsed.searchSchemas).length === 0) {
+    return runtimeSchemas;
+  }
+  const filtered = {};
+  for (const name of publicRouteNames) {
+    const schema = staticParsed.searchSchemas[name];
+    if (schema) filtered[name] = schema;
+  }
+  return Object.keys(filtered).length > 0 ? filtered : runtimeSchemas;
+}
 function buildCombinedRouteMapForRouterFile(routerFilePath) {
   let routerSource;
   try {
@@ -722,19 +1301,30 @@ function buildCombinedRouteMapForRouterFile(routerFilePath) {
   } catch {
     return { routes: {}, searchSchemas: {} };
   }
-  const urlsVarName = extractUrlsVariableFromRouter(routerSource);
-  if (!urlsVarName) {
+  const extractions = extractAllUrlsFromRouter(routerSource);
+  if (extractions.length === 0) {
     return { routes: {}, searchSchemas: {} };
   }
-  const imported = resolveImportedVariable(routerSource, urlsVarName);
-  if (imported) {
-    const targetFile = resolveImportPath(imported.specifier, routerFilePath);
-    if (!targetFile) {
-      return { routes: {}, searchSchemas: {} };
-    }
-    return buildCombinedRouteMapWithSearch(targetFile, imported.exportedName);
+  const rawBasename = extractBasenameFromRouter(routerSource);
+  const basename = rawBasename ? ("/" + rawBasename.replace(/^\/+|\/+$/g, "")).replace(/^\/$/, "") : void 0;
+  const result = { routes: {}, searchSchemas: {} };
+  const memo = createScanMemo();
+  for (const extraction of extractions) {
+    mergeRouteMaps(
+      result,
+      resolveRouterUrlsExtraction(
+        routerFilePath,
+        routerSource,
+        extraction,
+        void 0,
+        memo
+      )
+    );
+  }
+  if (basename) {
+    return applyBasenameToRoutes(result, basename);
   }
-  return buildCombinedRouteMapWithSearch(routerFilePath, urlsVarName);
+  return result;
 }
 function detectUnresolvableIncludes(routerFilePath) {
   const realPath = resolve2(routerFilePath);
@@ -744,37 +1334,19 @@ function detectUnresolvableIncludes(routerFilePath) {
   } catch {
     return [];
   }
-  const urlsVarName = extractUrlsVariableFromRouter(source);
-  if (!urlsVarName) return [];
-  const imported = resolveImportedVariable(source, urlsVarName);
-  let targetFile;
-  let exportedName;
-  if (imported) {
-    const resolved = resolveImportPath(imported.specifier, realPath);
-    if (!resolved) {
-      return [
-        {
-          pathPrefix: "/",
-          namePrefix: null,
-          reason: "file-not-found",
-          sourceFile: realPath,
-          detail: `import "${imported.specifier}" resolved to no file`
-        }
-      ];
-    }
-    targetFile = resolved;
-    exportedName = imported.exportedName;
-  } else {
-    targetFile = realPath;
-    exportedName = urlsVarName;
-  }
+  const extractions = extractAllUrlsFromRouter(source);
+  if (extractions.length === 0) return [];
   const diagnostics = [];
-  buildCombinedRouteMapWithSearch(
-    targetFile,
-    exportedName,
-    /* @__PURE__ */ new Set(),
-    diagnostics
-  );
+  const memo = createScanMemo();
+  for (const extraction of extractions) {
+    resolveRouterUrlsExtraction(
+      realPath,
+      source,
+      extraction,
+      diagnostics,
+      memo
+    );
+  }
   return diagnostics;
 }
 function detectUnresolvableIncludesForUrlsFile(filePath) {
@@ -795,7 +1367,14 @@ function detectUnresolvableIncludesForUrlsFile(filePath) {
 }
 function findRouterFiles(root, filter) {
   const result = [];
-  findRouterFilesRecursive(root, filter, result);
+  findCallSiteFilesRecursive(
+    root,
+    ROUTER_CALL_PATTERN,
+    ROUTER_CALL_PATTERN_G,
+    true,
+    filter,
+    result
+  );
   return result;
 }
 function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
@@ -804,7 +1383,7 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
     if (existsSync3(oldCombinedPath)) {
       unlinkSync(oldCombinedPath);
       console.log(
-        `[rsc-router] Removed stale combined route types: ${oldCombinedPath}`
+        `[rango] Removed stale combined route types: ${oldCombinedPath}`
       );
     }
   } catch {
@@ -816,38 +1395,22 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
     throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
   }
   for (const routerFilePath of routerFilePaths) {
-    let routerSource;
-    try {
-      routerSource = readFileSync3(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 = readFileSync3(routerFilePath, "utf-8");
+      } catch {
+        continue;
+      }
+      if (!extractUrlsFromRouter(routerSource)) continue;
     }
-    const routerBasename = pathBasename(routerFilePath).replace(
-      /\.(tsx?|jsx?)$/,
-      ""
-    );
-    const outPath = join2(
-      dirname2(routerFilePath),
-      `${routerBasename}.named-routes.gen.ts`
-    );
+    const outPath = genFileTsPath(routerFilePath);
     const existing = existsSync3(outPath) ? readFileSync3(outPath, "utf-8") : null;
     if (Object.keys(result.routes).length === 0) {
       if (!existing) {
         const emptySource = generateRouteTypesSource({});
+        opts?.onWrite?.(outPath, emptySource);
         writeFileSync2(outPath, emptySource);
       }
       continue;
@@ -867,22 +1430,25 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
           continue;
         }
       }
+      opts?.onWrite?.(outPath, source);
       writeFileSync2(outPath, source);
       console.log(
-        `[rsc-router] Generated route types (${Object.keys(result.routes).length} routes) -> ${outPath}`
+        `[rango] Generated route types (${Object.keys(result.routes).length} routes) -> ${outPath}`
       );
     }
   }
 }
-var ROUTER_CALL_PATTERN;
+var ROUTER_CALL_PATTERN, ROUTER_CALL_PATTERN_G;
 var init_router_processing = __esm({
   "src/build/route-types/router-processing.ts"() {
     "use strict";
     init_codegen();
+    init_source_scan();
     init_include_resolution();
     init_per_module_writer();
     init_route_name();
     ROUTER_CALL_PATTERN = /\bcreateRouter\s*[<(]/;
+    ROUTER_CALL_PATTERN_G = /\bcreateRouter\s*[<(]/g;
   }
 });
 
@@ -901,11 +1467,143 @@ var init_generate_route_types = __esm({
   }
 });
 
+// src/build/merge-full-manifests.ts
+function clonePrefixNode(node) {
+  return {
+    staticPrefix: node.staticPrefix,
+    fullPrefix: node.fullPrefix,
+    ...node.namePrefix === void 0 ? {} : { namePrefix: node.namePrefix },
+    children: clonePrefixTree(node.children),
+    routes: [...node.routes]
+  };
+}
+function clonePrefixTree(tree) {
+  return Object.fromEntries(
+    Object.entries(tree).map(([prefix, node]) => [
+      prefix,
+      clonePrefixNode(node)
+    ])
+  );
+}
+function removeRoutesFromPrefixTree(tree, routeNames) {
+  return Object.fromEntries(
+    Object.entries(tree).map(([prefix, node]) => [
+      prefix,
+      {
+        staticPrefix: node.staticPrefix,
+        fullPrefix: node.fullPrefix,
+        ...node.namePrefix === void 0 ? {} : { namePrefix: node.namePrefix },
+        children: removeRoutesFromPrefixTree(node.children, routeNames),
+        routes: node.routes.filter((name) => !routeNames.has(name))
+      }
+    ])
+  );
+}
+function mergePrefixTrees(earlier, later) {
+  const merged = clonePrefixTree(earlier);
+  for (const [prefix, laterNode] of Object.entries(later)) {
+    const earlierNode = merged[prefix];
+    if (!earlierNode) {
+      merged[prefix] = clonePrefixNode(laterNode);
+      continue;
+    }
+    merged[prefix] = {
+      staticPrefix: laterNode.staticPrefix,
+      fullPrefix: laterNode.fullPrefix,
+      ...laterNode.namePrefix === void 0 ? {} : { namePrefix: laterNode.namePrefix },
+      children: mergePrefixTrees(earlierNode.children, laterNode.children),
+      routes: [.../* @__PURE__ */ new Set([...earlierNode.routes, ...laterNode.routes])]
+    };
+  }
+  return merged;
+}
+function mergeRouteRecord(earlier, later, overwrittenRoutes, cloneValue) {
+  const merged = {};
+  for (const [name, value] of Object.entries(earlier ?? {})) {
+    if (!overwrittenRoutes.has(name)) merged[name] = cloneValue(value);
+  }
+  for (const [name, value] of Object.entries(later ?? {})) {
+    merged[name] = cloneValue(value);
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeRouteList(earlier, later, overwrittenRoutes) {
+  const merged = [
+    ...(earlier ?? []).filter((name) => !overwrittenRoutes.has(name)),
+    ...later ?? []
+  ];
+  const unique = [...new Set(merged)];
+  return unique.length > 0 ? unique : void 0;
+}
+function mergeFullManifests(manifests) {
+  let merged = {
+    prefixTree: {},
+    routeManifest: {}
+  };
+  for (const manifest of manifests) {
+    const overwrittenRoutes = new Set(Object.keys(manifest.routeManifest));
+    const prefixTreeWithoutOverwrites = removeRoutesFromPrefixTree(
+      merged.prefixTree,
+      overwrittenRoutes
+    );
+    merged = {
+      prefixTree: mergePrefixTrees(
+        prefixTreeWithoutOverwrites,
+        manifest.prefixTree
+      ),
+      routeManifest: {
+        ...merged.routeManifest,
+        ...manifest.routeManifest
+      },
+      routeTrailingSlash: mergeRouteRecord(
+        merged.routeTrailingSlash,
+        manifest.routeTrailingSlash,
+        overwrittenRoutes,
+        (value) => value
+      ),
+      prerenderRoutes: mergeRouteList(
+        merged.prerenderRoutes,
+        manifest.prerenderRoutes,
+        overwrittenRoutes
+      ),
+      passthroughRoutes: mergeRouteList(
+        merged.passthroughRoutes,
+        manifest.passthroughRoutes,
+        overwrittenRoutes
+      ),
+      responseTypeRoutes: mergeRouteRecord(
+        merged.responseTypeRoutes,
+        manifest.responseTypeRoutes,
+        overwrittenRoutes,
+        (value) => value
+      ),
+      routeSearchSchemas: mergeRouteRecord(
+        merged.routeSearchSchemas,
+        manifest.routeSearchSchemas,
+        overwrittenRoutes,
+        (value) => ({ ...value })
+      ),
+      _prerenderDefs: mergeRouteRecord(
+        merged._prerenderDefs,
+        manifest._prerenderDefs,
+        overwrittenRoutes,
+        (value) => value
+      )
+    };
+  }
+  return merged;
+}
+var init_merge_full_manifests = __esm({
+  "src/build/merge-full-manifests.ts"() {
+    "use strict";
+  }
+});
+
 // src/vite/plugins/virtual-entries.ts
 function getVirtualVersionContent(version) {
   return `export const VERSION = ${JSON.stringify(version)};`;
 }
-var VIRTUAL_ENTRY_BROWSER, VIRTUAL_ENTRY_SSR, VIRTUAL_IDS;
+var VIRTUAL_ENTRY_BROWSER, VIRTUAL_IDS;
 var init_virtual_entries = __esm({
   "src/vite/plugins/virtual-entries.ts"() {
     "use strict";
@@ -920,7 +1618,7 @@ import {
 import { createElement, StrictMode } from "react";
 import { hydrateRoot } from "react-dom/client";
 import { rscStream } from "@rangojs/router/internal/deps/html-stream-client";
-import { initBrowserApp, RSCRouter } from "@rangojs/router/browser";
+import { initBrowserApp, Rango } from "@rangojs/router/browser";
 
 async function initializeApp() {
   const deps = {
@@ -931,29 +1629,30 @@ async function initializeApp() {
     createTemporaryReferenceSet,
   };
 
-  await initBrowserApp({ rscStream, deps });
+  // initBrowserApp resolves the initial payload and returns the browser app
+  // context, including strictMode (default true) from createRouter. StrictMode
+  // is the default; createRouter({ strictMode: false }) ships the opt-out in the
+  // payload metadata. StrictMode emits no DOM, so toggling never changes markup.
+  const { strictMode, initialPayload } = await initBrowserApp({ rscStream, deps });
+
+  if (import.meta.hot) {
+    const { startDevDiscoveryHandshake } = await import(
+      "@rangojs/router/internal/browser/dev-discovery"
+    );
+    startDevDiscoveryHandshake(
+      initialPayload.metadata?.devDiscoveryEpoch,
+      import.meta.hot
+    );
+  }
 
+  const app = createElement(Rango);
   hydrateRoot(
     document,
-    createElement(StrictMode, null, createElement(RSCRouter))
+    strictMode === false ? app : createElement(StrictMode, null, app)
   );
 }
 
 initializeApp().catch(console.error);
-`.trim();
-    VIRTUAL_ENTRY_SSR = `
-import { createFromReadableStream } from "@rangojs/router/internal/deps/ssr";
-import { renderToReadableStream } from "react-dom/server.edge";
-import { injectRSCPayload } from "@rangojs/router/internal/deps/html-stream-server";
-import { createSSRHandler } from "@rangojs/router/ssr";
-
-export const renderHTML = createSSRHandler({
-  createFromReadableStream,
-  renderToReadableStream,
-  injectRSCPayload,
-  loadBootstrapScriptContent: () =>
-    import.meta.viteRsc.loadBootstrapScriptContent("index"),
-});
 `.trim();
     VIRTUAL_IDS = {
       browser: "virtual:rsc-router/entry.browser.js",
@@ -964,12 +1663,37 @@ export const renderHTML = createSSRHandler({
   }
 });
 
+// src/vite/utils/directive-prologue.ts
+import { parseAst } from "vite";
+function hasUseClientDirective(source) {
+  let program;
+  try {
+    program = parseAst(source, { lang: "tsx" });
+  } catch {
+    return false;
+  }
+  for (const node of program.body ?? []) {
+    if (node?.type === "ExpressionStatement" && node.expression?.type === "Literal" && typeof node.expression.value === "string") {
+      if (node.expression.value === "use client") return true;
+      continue;
+    }
+    break;
+  }
+  return false;
+}
+var init_directive_prologue = __esm({
+  "src/vite/utils/directive-prologue.ts"() {
+    "use strict";
+  }
+});
+
 // src/vite/plugins/version-plugin.ts
 var version_plugin_exports = {};
 __export(version_plugin_exports, {
-  createVersionPlugin: () => createVersionPlugin
+  createVersionPlugin: () => createVersionPlugin,
+  isViteDepCachePath: () => isViteDepCachePath
 });
-import { parseAst } from "vite";
+import { parseAst as parseAst2 } from "vite";
 function isCodeModule(id) {
   return /\.(tsx?|jsx?)($|\?)/.test(id);
 }
@@ -977,23 +1701,13 @@ function normalizeModuleId(id) {
   return id.split("?", 1)[0];
 }
 function getClientModuleSignature(source) {
+  if (!hasUseClientDirective(source)) return void 0;
   let program;
   try {
-    program = parseAst(source, { jsx: true });
+    program = parseAst2(source, { lang: "tsx" });
   } catch {
     return void 0;
   }
-  let isUseClient = false;
-  for (const node of program.body ?? []) {
-    if (node?.type === "ExpressionStatement" && node.expression?.type === "Literal" && typeof node.expression.value === "string") {
-      if (node.expression.value === "use client") {
-        isUseClient = true;
-      }
-      continue;
-    }
-    break;
-  }
-  if (!isUseClient) return void 0;
   const exports = /* @__PURE__ */ new Set();
   let hasDefault = false;
   let hasExportAll = false;
@@ -1062,11 +1776,12 @@ function createVersionPlugin() {
   let currentVersion = buildVersion;
   let isDev = false;
   let server = null;
+  let resolvedCacheDir;
   const clientModuleSignatures = /* @__PURE__ */ new Map();
   let versionCounter = 0;
   const bumpVersion = (reason) => {
     currentVersion = Date.now().toString(16) + String(++versionCounter);
-    console.log(`[rsc-router] ${reason}, version updated: ${currentVersion}`);
+    console.log(`[rango] ${reason}, version updated: ${currentVersion}`);
     const rscEnv = server?.environments?.rsc;
     const versionMod = rscEnv?.moduleGraph?.getModuleById(
       "\0" + VIRTUAL_IDS.version
@@ -1078,8 +1793,16 @@ function createVersionPlugin() {
   return {
     name: "@rangojs/router:version",
     enforce: "pre",
+    // The build-time shell capture phase (producer B, #699) stamps entries
+    // with THIS instance's version — the value folded into the shipped worker
+    // — never the discovery temp server's own version-plugin value (a
+    // different Date.now() stamp that would fail the serve-side gate).
+    api: {
+      getBuildVersion: () => currentVersion
+    },
     configResolved(config) {
       isDev = config.command === "serve";
+      resolvedCacheDir = config.cacheDir ? String(config.cacheDir).replace(/\\/g, "/") : void 0;
     },
     configureServer(devServer) {
       server = devServer;
@@ -1116,11 +1839,11 @@ function createVersionPlugin() {
       }
       return null;
     },
-    // Track RSC module changes and update version
     async hotUpdate(ctx) {
       if (!isDev) return;
       const isRscModule = this.environment?.name === "rsc";
       if (!isRscModule) return;
+      if (isViteDepCachePath(ctx.file, resolvedCacheDir)) return;
       if (ctx.modules.length === 1 && ctx.modules[0].id === "\0" + VIRTUAL_IDS.version) {
         return;
       }
@@ -1150,10 +1873,22 @@ function createVersionPlugin() {
     }
   };
 }
+function isViteDepCachePath(filePath, cacheDir) {
+  if (!filePath) return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  if (cacheDir) {
+    const normalizedCacheDir = cacheDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (normalized === normalizedCacheDir || normalized.startsWith(normalizedCacheDir + "/")) {
+      return true;
+    }
+  }
+  return /\/node_modules\/\.vite[^/]*\//.test(normalized) || normalized.includes("/.vite-isolated/");
+}
 var init_version_plugin = __esm({
   "src/vite/plugins/version-plugin.ts"() {
     "use strict";
     init_virtual_entries();
+    init_directive_prologue();
   }
 });
 
@@ -1195,7 +1930,7 @@ var runtime_discovery_exports = {};
 __export(runtime_discovery_exports, {
   discoverAndWriteRouteTypes: () => discoverAndWriteRouteTypes
 });
-import { dirname as dirname3, join as join3, basename, resolve as resolve3 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
 async function discoverAndWriteRouteTypes(opts) {
   let createViteServer;
@@ -1272,17 +2007,28 @@ async function discoverAndWriteRouteTypes(opts) {
       );
     }
     const buildMod = await rscEnv.runner.import("@rangojs/router/build");
-    const generateManifest = buildMod.generateManifest;
-    if (!generateManifest) {
-      throw new Error("generateManifest not found in @rangojs/router/build");
+    const generateManifestFull = buildMod.generateManifestFull;
+    if (!generateManifestFull) {
+      throw new Error(
+        "generateManifestFull not found in @rangojs/router/build"
+      );
     }
     const outputFiles = [];
     let totalRouteCount = 0;
-    let routerMountIndex = 0;
+    let globalMountIndex = 0;
+    let routerCount = 0;
     for (const [id, router] of registry) {
-      if (!router.urlpatterns) continue;
-      const manifest = generateManifest(router.urlpatterns, routerMountIndex);
-      routerMountIndex++;
+      const mounts = router.__urlpatternMounts ?? (router.urlpatterns ? [{ patterns: router.urlpatterns }] : []);
+      if (mounts.length === 0) continue;
+      const mountManifests = [];
+      for (const mount of mounts) {
+        mountManifests.push(
+          await generateManifestFull(mount.patterns, globalMountIndex)
+        );
+        globalMountIndex++;
+      }
+      const manifest = mergeFullManifests(mountManifests);
+      routerCount++;
       const rawManifest = manifest.routeManifest;
       const routeManifest = {};
       for (const [name, pattern] of Object.entries(rawManifest)) {
@@ -1305,22 +2051,12 @@ This means createRouter() stack trace parsing matched an internal frame.
 Set an explicit \`id\` on createRouter() or check the call site.`
         );
       }
-      if (!routeSearchSchemas || Object.keys(routeSearchSchemas).length === 0) {
-        const staticParsed = buildCombinedRouteMapForRouterFile(sourceFile);
-        if (Object.keys(staticParsed.searchSchemas).length > 0) {
-          const filtered = {};
-          for (const name of Object.keys(routeManifest)) {
-            const schema = staticParsed.searchSchemas[name];
-            if (schema) filtered[name] = schema;
-          }
-          if (Object.keys(filtered).length > 0) {
-            routeSearchSchemas = filtered;
-          }
-        }
-      }
-      const routerDir = dirname3(sourceFile);
-      const routerBasename = basename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
-      const outPath = join3(routerDir, `${routerBasename}.named-routes.gen.ts`);
+      routeSearchSchemas = resolveSearchSchemas(
+        Object.keys(routeManifest),
+        routeSearchSchemas,
+        sourceFile
+      );
+      const outPath = genFileTsPath(sourceFile);
       const source = generateRouteTypesSource(
         routeManifest,
         routeSearchSchemas && Object.keys(routeSearchSchemas).length > 0 ? routeSearchSchemas : void 0
@@ -1337,7 +2073,7 @@ Set an explicit \`id\` on createRouter() or check the call site.`
       );
     }
     return {
-      routerCount: routerMountIndex,
+      routerCount,
       routeCount: totalRouteCount,
       outputFiles
     };
@@ -1351,13 +2087,14 @@ var init_runtime_discovery = __esm({
   "src/build/runtime-discovery.ts"() {
     "use strict";
     init_generate_route_types();
+    init_merge_full_manifests();
     init_route_name();
   }
 });
 
 // src/bin/rango.ts
 init_generate_route_types();
-import { resolve as resolve4, dirname as dirname4 } from "node:path";
+import { resolve as resolve4, dirname as dirname3 } from "node:path";
 import { readFileSync as readFileSync5, statSync, existsSync as existsSync5 } from "node:fs";
 var [command, ...rawArgs] = process.argv.slice(2);
 if (command === "generate") {
@@ -1428,12 +2165,12 @@ Examples:
   );
 }
 function findProjectRoot(fromPath) {
-  let dir = dirname4(resolve4(fromPath));
-  while (dir !== dirname4(dir)) {
+  let dir = dirname3(resolve4(fromPath));
+  while (dir !== dirname3(dir)) {
     if (existsSync5(resolve4(dir, "package.json")) || existsSync5(resolve4(dir, "vite.config.ts")) || existsSync5(resolve4(dir, "vite.config.js"))) {
       return dir;
     }
-    dir = dirname4(dir);
+    dir = dirname3(dir);
   }
   return process.cwd();
 }