@rangojs/router 0.0.0-experimental.9c9afef3 → 0.0.0-experimental.a014d2b7

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,33 @@ 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 extractNamePrefixFromInclude(node) {
   if (node.arguments.length >= 3) {
     const thirdArg = node.arguments[2];
@@ -252,8 +289,8 @@ function extractNamePrefixFromInclude(node) {
   }
   return null;
 }
-function extractIncludesWithDiagnostics(code) {
-  const sourceFile = ts3.createSourceFile(
+function extractIncludesWithDiagnostics(code, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
     code,
     ts3.ScriptTarget.Latest,
@@ -307,7 +344,7 @@ function extractIncludesWithDiagnostics(code) {
   return { resolved, unresolvable };
 }
 function resolveImportedVariable(code, localName) {
-  const importRegex = /import\s*\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
+  const importRegex = /import\s*(?:[\w$]+\s*,\s*)?\{([^}]+)\}\s*from\s*["']([^"']+)["']/g;
   let match;
   while ((match = importRegex.exec(code)) !== null) {
     const imports = match[1];
@@ -344,8 +381,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,
@@ -367,16 +404,20 @@ function extractUrlsBlockForVariable(code, varName) {
   visit(sourceFile);
   return result;
 }
-function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut, diagnosticsOut) {
+function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut, diagnosticsOut, memo) {
   const routeMap = {};
-  const localRoutes = extractRoutesFromSource(block);
+  const blockSourceFile = parseBlock(memo, block);
+  const localRoutes = extractRoutesFromSource(block, blockSourceFile);
   for (const { name, pattern, search } of localRoutes) {
     routeMap[name] = pattern;
     if (search && searchSchemasOut) {
       searchSchemasOut[name] = search;
     }
   }
-  const { resolved: includes, unresolvable } = extractIncludesWithDiagnostics(block);
+  const { resolved: includes, unresolvable } = extractIncludesWithDiagnostics(
+    block,
+    blockSourceFile
+  );
   if (diagnosticsOut) {
     for (const entry of unresolvable) {
       diagnosticsOut.push({ ...entry, sourceFile: filePath });
@@ -403,12 +444,15 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
         targetFile,
         imported.exportedName,
         visited,
-        diagnosticsOut
+        diagnosticsOut,
+        void 0,
+        memo
       );
     } else {
       const sameFileBlock = extractUrlsBlockForVariable(
         fullSource,
-        variableName
+        variableName,
+        parseBlock(memo, fullSource)
       );
       if (!sameFileBlock) {
         if (diagnosticsOut) {
@@ -426,7 +470,9 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
         filePath,
         variableName,
         visited,
-        diagnosticsOut
+        diagnosticsOut,
+        void 0,
+        memo
       );
     }
     if (namePrefix === null) {
@@ -450,24 +496,31 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
-function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut) {
+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) {
+    const extracted = extractUrlsBlockForVariable(
+      source,
+      variableName,
+      parseBlock(memo, source)
+    );
     if (!extracted) return { routes: {}, searchSchemas: {} };
     block = extracted;
   } else {
@@ -480,7 +533,8 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
     realPath,
     visited,
     searchSchemas,
-    diagnosticsOut
+    diagnosticsOut,
+    memo
   );
   visited.delete(key);
   return { routes, searchSchemas };
@@ -525,8 +579,16 @@ function writePerModuleRouteTypesForFile(filePath) {
     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 +602,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 +616,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 +635,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,
@@ -609,7 +796,7 @@ function findRouterFilesRecursive(dir, filter, results) {
     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;
   }
@@ -627,7 +814,7 @@ function findRouterFilesRecursive(dir, filter, results) {
     if (filter && !filter(fullPath)) continue;
     try {
       const source = readFileSync3(fullPath, "utf-8");
-      if (ROUTER_CALL_PATTERN.test(source)) {
+      if (ROUTER_CALL_PATTERN.test(source) && firstCodeMatchIndex(source, ROUTER_CALL_PATTERN_G) >= 0) {
         routerFilesInDir.push(fullPath);
       }
     } catch {
@@ -665,13 +852,13 @@ 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 extractUrlsFromRouter(code) {
   const sourceFile = ts5.createSourceFile(
     "router.tsx",
     code,
@@ -685,24 +872,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;
             }
@@ -715,6 +948,38 @@ 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 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 +987,40 @@ function buildCombinedRouteMapForRouterFile(routerFilePath) {
   } catch {
     return { routes: {}, searchSchemas: {} };
   }
-  const urlsVarName = extractUrlsVariableFromRouter(routerSource);
-  if (!urlsVarName) {
+  const extraction = extractUrlsFromRouter(routerSource);
+  if (!extraction) {
     return { routes: {}, searchSchemas: {} };
   }
-  const imported = resolveImportedVariable(routerSource, urlsVarName);
-  if (imported) {
-    const targetFile = resolveImportPath(imported.specifier, routerFilePath);
-    if (!targetFile) {
-      return { routes: {}, searchSchemas: {} };
+  const rawBasename = extractBasenameFromRouter(routerSource);
+  const basename = 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 (basename) {
+    result = applyBasenameToRoutes(result, basename);
+  }
+  return result;
 }
 function detectUnresolvableIncludes(routerFilePath) {
   const realPath = resolve2(routerFilePath);
@@ -744,9 +1030,20 @@ function detectUnresolvableIncludes(routerFilePath) {
   } catch {
     return [];
   }
-  const urlsVarName = extractUrlsVariableFromRouter(source);
-  if (!urlsVarName) return [];
-  const imported = resolveImportedVariable(source, urlsVarName);
+  const extraction = extractUrlsFromRouter(source);
+  if (!extraction) return [];
+  const diagnostics = [];
+  if (extraction.kind === "inline") {
+    buildCombinedRouteMapWithSearch(
+      realPath,
+      void 0,
+      /* @__PURE__ */ new Set(),
+      diagnostics,
+      extraction.block
+    );
+    return diagnostics;
+  }
+  const imported = resolveImportedVariable(source, extraction.name);
   let targetFile;
   let exportedName;
   if (imported) {
@@ -766,9 +1063,8 @@ function detectUnresolvableIncludes(routerFilePath) {
     exportedName = imported.exportedName;
   } else {
     targetFile = realPath;
-    exportedName = urlsVarName;
+    exportedName = extraction.name;
   }
-  const diagnostics = [];
   buildCombinedRouteMapWithSearch(
     targetFile,
     exportedName,
@@ -804,7 +1100,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 +1112,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 +1147,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;
   }
 });
 
@@ -920,7 +1203,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,11 +1214,16 @@ async function initializeApp() {
     createTemporaryReferenceSet,
   };
 
-  await initBrowserApp({ rscStream, deps });
+  // initBrowserApp resolves the initial payload and returns the browser app
+  // context, including strictMode (default true) from createRouter. StrictMode
+  // is the default; createRouter({ strictMode: false }) ships the opt-out in the
+  // payload metadata. StrictMode emits no DOM, so toggling never changes markup.
+  const { strictMode } = await initBrowserApp({ rscStream, deps });
 
+  const app = createElement(Rango);
   hydrateRoot(
     document,
-    createElement(StrictMode, null, createElement(RSCRouter))
+    strictMode === false ? app : createElement(StrictMode, null, app)
   );
 }
 
@@ -964,12 +1252,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 +1290,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 +1365,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
@@ -1080,6 +1384,7 @@ function createVersionPlugin() {
     enforce: "pre",
     configResolved(config) {
       isDev = config.command === "serve";
+      resolvedCacheDir = config.cacheDir ? String(config.cacheDir).replace(/\\/g, "/") : void 0;
     },
     configureServer(devServer) {
       server = devServer;
@@ -1116,11 +1421,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 +1455,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 +1512,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;
@@ -1305,22 +1622,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
@@ -1357,7 +1664,7 @@ var init_runtime_discovery = __esm({
 
 // 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 +1735,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();
 }