@rangojs/router 0.32.0 → 0.33.0

package/dist/bin/chunk-TO6CRWLN.js

@@ -0,0 +1,1429 @@
+import {
+  firstCodeMatchIndex,
+  isAutoGeneratedRouteName,
+  isUniversallySkippedScanDir,
+  normalizeBasename
+} from "./chunk-LD7UBHT4.js";
+
+// src/build/route-types/param-extraction.ts
+function extractParamsFromPattern(pattern) {
+  const params = {};
+  const regex = /:([a-zA-Z_$][\w$]*)(?:\([^)]+\))?(\?)?/g;
+  let match;
+  while ((match = regex.exec(pattern)) !== null) {
+    params[match[1]] = match[2] ? "string?" : "string";
+  }
+  return Object.keys(params).length > 0 ? params : void 0;
+}
+function formatRouteEntry(key, pattern, _params, search) {
+  const hasSearch = search && Object.keys(search).length > 0;
+  if (!hasSearch) {
+    return `  ${key}: ${JSON.stringify(pattern)},`;
+  }
+  const searchBody = Object.entries(search).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
+  return `  ${key}: { path: ${JSON.stringify(pattern)}, search: { ${searchBody} } },`;
+}
+
+// src/build/route-types/codegen.ts
+function generatePerModuleTypesSource(routes) {
+  const valid = routes.filter(({ name }) => {
+    if (!name || /["'\\`\n\r]/.test(name)) {
+      console.warn(
+        `[rango] Skipping route with invalid name: ${JSON.stringify(name)}`
+      );
+      return false;
+    }
+    return true;
+  });
+  const deduped = /* @__PURE__ */ new Map();
+  for (const { name, pattern, params, search } of valid) {
+    if (deduped.has(name)) {
+      console.warn(
+        `[rango] Duplicate route name "${name}" \u2014 keeping first definition`
+      );
+      continue;
+    }
+    deduped.set(name, { pattern, params, search });
+  }
+  const sorted = [...deduped.entries()].sort(
+    ([a], [b]) => a.localeCompare(b, "en")
+  );
+  const body = sorted.map(([name, { pattern, params, search }]) => {
+    const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
+    return formatRouteEntry(key, pattern, params, search);
+  }).join("\n");
+  return `// Auto-generated by @rangojs/router - do not edit
+export const routes = {
+${body}
+} as const;
+export type routes = typeof routes;
+`;
+}
+function generateRouteTypesSource(routeManifest, searchSchemas) {
+  const entries = Object.entries(routeManifest).filter(([name]) => !isAutoGeneratedRouteName(name)).sort(([a], [b]) => a.localeCompare(b, "en"));
+  const filteredSearchSchemas = searchSchemas ? Object.fromEntries(
+    Object.entries(searchSchemas).filter(
+      ([name]) => !isAutoGeneratedRouteName(name)
+    )
+  ) : void 0;
+  const objectBody = entries.map(([name, pattern]) => {
+    const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
+    const params = extractParamsFromPattern(pattern);
+    const search = filteredSearchSchemas?.[name];
+    return formatRouteEntry(key, pattern, params, search);
+  }).join("\n");
+  return `// Auto-generated by @rangojs/router - do not edit
+export const NamedRoutes = {
+${objectBody}
+} as const;
+
+// Aliased so the augmentation below does not pay a homomorphic mapped-type
+// instantiation per route; \`as const\` already makes the members readonly.
+type NamedRoutesShape = typeof NamedRoutes;
+
+declare global {
+  namespace Rango {
+    interface GeneratedRouteMap extends NamedRoutesShape {}
+  }
+}
+`;
+}
+
+// src/build/route-types/per-module-writer.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "node:fs";
+import ts4 from "typescript";
+
+// src/build/route-types/ast-route-extraction.ts
+import ts2 from "typescript";
+
+// src/build/route-types/ast-helpers.ts
+import ts from "typescript";
+function getStringValue(node) {
+  if (ts.isStringLiteral(node)) return node.text;
+  if (ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+  return null;
+}
+function extractObjectStringProperties(node) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue;
+    const key = ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : null;
+    if (!key) continue;
+    const val = getStringValue(prop.initializer);
+    if (val !== null) result[key] = val;
+  }
+  return result;
+}
+
+// src/build/route-types/ast-route-extraction.ts
+function extractRoutesFromSource(code, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts2.createSourceFile(
+    "input.tsx",
+    code,
+    ts2.ScriptTarget.Latest,
+    true,
+    ts2.ScriptKind.TSX
+  );
+  const routes = [];
+  function visit(node) {
+    if (ts2.isCallExpression(node)) {
+      const callee = node.expression;
+      const isPath = ts2.isIdentifier(callee) && callee.text === "path" || ts2.isPropertyAccessExpression(callee) && ts2.isIdentifier(callee.expression) && callee.expression.text === "path";
+      if (isPath && node.arguments.length >= 1) {
+        const route = extractRouteFromCallExpression(node);
+        if (route) routes.push(route);
+      }
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return routes;
+}
+function extractRouteFromCallExpression(node) {
+  const patternNode = node.arguments[0];
+  const pattern = getStringValue(patternNode);
+  if (pattern === null) return null;
+  let name = null;
+  let search;
+  for (let i = 1; i < node.arguments.length; i++) {
+    const arg = node.arguments[i];
+    if (ts2.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.properties) {
+        if (!ts2.isPropertyAssignment(prop)) continue;
+        const propName = ts2.isIdentifier(prop.name) ? prop.name.text : null;
+        if (propName === "name") {
+          name = getStringValue(prop.initializer);
+        } else if (propName === "search" && ts2.isObjectLiteralExpression(prop.initializer)) {
+          search = extractObjectStringProperties(prop.initializer);
+        }
+      }
+    }
+  }
+  if (!name) return null;
+  const params = extractParamsFromPattern(pattern);
+  return {
+    name,
+    pattern,
+    ...params ? { params } : {},
+    ...search && Object.keys(search).length > 0 ? { search } : {}
+  };
+}
+
+// src/build/route-types/include-resolution.ts
+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, aliases) {
+  const callee = node.expression;
+  return ts3.isIdentifier(callee) && (callee.text === "urls" || callee.text === "clientUrls" || aliases?.has(callee.text) === true);
+}
+function collectUrlsImportAliases(sourceFile) {
+  const aliases = /* @__PURE__ */ new Set();
+  for (const stmt of sourceFile.statements) {
+    if (!ts3.isImportDeclaration(stmt) || !ts3.isStringLiteral(stmt.moduleSpecifier) || stmt.moduleSpecifier.text !== "@rangojs/router" && stmt.moduleSpecifier.text !== "@rangojs/router/client") {
+      continue;
+    }
+    const bindings = stmt.importClause?.namedBindings;
+    if (!bindings || !ts3.isNamedImports(bindings)) continue;
+    for (const el of bindings.elements) {
+      const imported = (el.propertyName ?? el.name).text;
+      if (imported === "urls" || imported === "clientUrls") {
+        aliases.add(el.name.text);
+      }
+    }
+  }
+  return aliases;
+}
+function extractNamePrefixFromInclude(node) {
+  if (node.arguments.length >= 3) {
+    const thirdArg = node.arguments[2];
+    if (ts3.isObjectLiteralExpression(thirdArg)) {
+      for (const prop of thirdArg.properties) {
+        if (!ts3.isPropertyAssignment(prop)) continue;
+        const propName = ts3.isIdentifier(prop.name) ? prop.name.text : null;
+        if (propName === "name") {
+          return getStringValue(prop.initializer);
+        }
+      }
+    }
+  }
+  return null;
+}
+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,
+    true,
+    ts3.ScriptKind.TSX
+  );
+  const resolved = [];
+  const unresolvable = [];
+  function visit(node) {
+    if (ts3.isCallExpression(node)) {
+      const callee = node.expression;
+      if (ts3.isIdentifier(callee) && callee.text === "include") {
+        if (node.arguments.length < 2) {
+          ts3.forEachChild(node, visit);
+          return;
+        }
+        const pathPrefix = getStringValue(node.arguments[0]);
+        if (pathPrefix === null) {
+          ts3.forEachChild(node, visit);
+          return;
+        }
+        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({
+            pathPrefix,
+            namePrefix,
+            reason: "factory-call",
+            detail: `${callText}()`
+          });
+        } else {
+          unresolvable.push({
+            pathPrefix,
+            namePrefix,
+            reason: "dynamic-expression",
+            detail: secondArg.getText(sourceFile)
+          });
+        }
+      }
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return { resolved, unresolvable };
+}
+function resolveImportedVariable(code, localName) {
+  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];
+    const specifier = match[2];
+    const parts = imports.split(",").map((s) => s.trim()).filter(Boolean);
+    for (const part of parts) {
+      const asMatch = part.match(/^(\w+)\s+as\s+(\w+)$/);
+      if (asMatch && asMatch[2] === localName)
+        return { specifier, exportedName: asMatch[1] };
+      if (part === localName) return { specifier, exportedName: localName };
+    }
+  }
+  return null;
+}
+function resolveImportPath(importSpec, fromFile) {
+  if (!importSpec.startsWith(".")) return null;
+  const dir = dirname(fromFile);
+  let base = importSpec;
+  if (base.endsWith(".js")) base = base.slice(0, -3);
+  else if (base.endsWith(".mjs")) base = base.slice(0, -4);
+  else if (base.endsWith(".jsx")) base = base.slice(0, -4);
+  const candidates = [
+    resolve(dir, base + ".ts"),
+    resolve(dir, base + ".tsx"),
+    resolve(dir, base + ".js"),
+    resolve(dir, base + ".jsx"),
+    resolve(dir, base + "/index.ts"),
+    resolve(dir, base + "/index.tsx"),
+    resolve(dir, base + "/index.js"),
+    resolve(dir, base + "/index.jsx")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function extractUrlsBlockForVariable(code, varName, sourceFileArg) {
+  const sourceFile = sourceFileArg ?? ts3.createSourceFile(
+    "input.tsx",
+    code,
+    ts3.ScriptTarget.Latest,
+    true,
+    ts3.ScriptKind.TSX
+  );
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.name.text === varName && node.initializer && ts3.isCallExpression(node.initializer)) {
+      if (isUrlsDefinitionCall(node.initializer)) {
+        result = node.initializer.getText(sourceFile);
+        return;
+      }
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSchemasOut, diagnosticsOut, memo) {
+  const routeMap = {};
+  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,
+    blockSourceFile
+  );
+  if (diagnosticsOut) {
+    for (const entry of unresolvable) {
+      diagnosticsOut.push({ ...entry, sourceFile: filePath });
+    }
+  }
+  for (const inc of includes) {
+    const { pathPrefix, namePrefix } = inc;
+    let childResult;
+    if (inc.moduleSpecifier) {
+      const targetFile = resolveImportPath(inc.moduleSpecifier, filePath);
+      if (!targetFile) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to no file`
+        });
+        continue;
+      }
+      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 (!def) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "unresolvable-import",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") has no resolvable \`export default urls(...)\``
+        });
+        continue;
+      }
+      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,
+        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;
+    }
+    for (const [name, pattern] of Object.entries(childResult.routes)) {
+      const prefixedName = namePrefix ? `${namePrefix}.${name}` : name;
+      let prefixedPattern;
+      if (pattern === "/") {
+        prefixedPattern = pathPrefix || "/";
+      } else if (pathPrefix.endsWith("/") && pattern.startsWith("/")) {
+        prefixedPattern = pathPrefix + pattern.slice(1);
+      } else {
+        prefixedPattern = pathPrefix + pattern;
+      }
+      routeMap[prefixedName] = prefixedPattern;
+      if (childResult.searchSchemas[name] && searchSchemasOut) {
+        searchSchemasOut[prefixedName] = childResult.searchSchemas[name];
+      }
+    }
+  }
+  return routeMap;
+}
+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(`[rango] Circular include detected, skipping: ${key}`);
+    return { routes: {}, searchSchemas: {} };
+  }
+  visited.add(key);
+  let source;
+  try {
+    source = readSourceMemoized(memo, realPath);
+  } catch {
+    return { routes: {}, searchSchemas: {} };
+  }
+  let block;
+  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 {
+    block = source;
+  }
+  const searchSchemas = {};
+  const routes = buildRouteMapFromBlock(
+    block,
+    source,
+    realPath,
+    visited,
+    searchSchemas,
+    diagnosticsOut,
+    memo
+  );
+  visited.delete(key);
+  return { routes, searchSchemas };
+}
+
+// src/build/route-types/per-module-writer.ts
+function findUrlsVariableNames(code) {
+  const sourceFile = ts4.createSourceFile(
+    "input.tsx",
+    code,
+    ts4.ScriptTarget.Latest,
+    true,
+    ts4.ScriptKind.TSX
+  );
+  const names = [];
+  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" || callee.text === "clientUrls")) {
+        names.push(node.name.text);
+      }
+    }
+    ts4.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return names;
+}
+function planPerModuleRouteTypesForFile(filePath) {
+  const source = readFileSync2(filePath, "utf-8");
+  if (!source.includes("urls(") && !source.includes("clientUrls(")) return null;
+  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,
+        void 0,
+        void 0,
+        void 0,
+        memo
+      );
+      for (const [name, pattern] of Object.entries(routeMap)) {
+        const params = extractParamsFromPattern(pattern);
+        routes.push({
+          name,
+          pattern,
+          ...params ? { params } : {},
+          ...searchSchemas[name] ? { search: searchSchemas[name] } : {}
+        });
+      }
+    }
+  } else {
+    routes = extractRoutesFromSource(source);
+  }
+  const genPath = filePath.replace(/\.(tsx?|jsx?)$/, ".gen.ts");
+  if (routes.length === 0) {
+    if (varNames.length === 0) return null;
+    return {
+      genPath,
+      isPlaceholder: true,
+      content: generatePerModuleTypesSource([])
+    };
+  }
+  return {
+    genPath,
+    isPlaceholder: false,
+    content: generatePerModuleTypesSource(routes)
+  };
+}
+function writePerModuleRouteTypesForFile(filePath) {
+  try {
+    const plan = planPerModuleRouteTypesForFile(filePath);
+    if (!plan) return;
+    const { genPath, isPlaceholder, content } = plan;
+    const exists = existsSync2(genPath);
+    if (isPlaceholder) {
+      if (!exists) {
+        writeFileSync(genPath, content);
+        console.log(
+          `[rango] Generated route types (placeholder) -> ${genPath}`
+        );
+      }
+      return;
+    }
+    if (!exists || readFileSync2(genPath, "utf-8") !== content) {
+      writeFileSync(genPath, content);
+      console.log(`[rango] Generated route types -> ${genPath}`);
+    }
+  } catch (err) {
+    console.warn(
+      `[rango] Failed to generate route types for ${filePath}: ${err.message}`
+    );
+  }
+}
+
+// src/build/route-types/router-processing.ts
+import {
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync3,
+  unlinkSync,
+  readdirSync
+} from "node:fs";
+import {
+  join,
+  dirname as dirname2,
+  resolve as resolve2,
+  sep,
+  basename as pathBasename
+} from "node:path";
+import ts5 from "typescript";
+function countPublicRouteEntries(source) {
+  const matches = source.matchAll(/^\s+(?:"([^"]+)"|([a-zA-Z_$][^:]*)):\s*["{]/gm) ?? [];
+  let count = 0;
+  for (const match of matches) {
+    const routeName = match[1] || match[2];
+    if (routeName && !isAutoGeneratedRouteName(routeName.trim())) {
+      count++;
+    }
+  }
+  return count;
+}
+var ROUTER_CALL_PATTERN = /\bcreateRouter\s*[<(]/;
+var ROUTER_CALL_PATTERN_G = /\bcreateRouter\s*[<(]/g;
+function isRoutableSourceFile(name) {
+  return (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".jsx")) && !name.includes(".gen.") && !name.includes(".test.") && !name.includes(".rsc-test.") && !name.includes(".spec.");
+}
+function isExcludedScanDir(name) {
+  return isUniversallySkippedScanDir(name) || name === "__tests__" || name === "__mocks__";
+}
+function findCallSiteFilesRecursive(dir, pattern, patternG, stopAtMatchDir, filter, results) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    console.warn(
+      `[rango] Failed to scan directory ${dir}: ${err.message}`
+    );
+    return;
+  }
+  const childDirs = [];
+  const matchesInDir = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      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 (pattern.test(source) && firstCodeMatchIndex(source, patternG) >= 0) {
+        matchesInDir.push(fullPath);
+      }
+    } catch {
+      continue;
+    }
+  }
+  results.push(...matchesInDir);
+  if (!stopAtMatchDir || matchesInDir.length === 0) {
+    for (const childDir of childDirs) {
+      findCallSiteFilesRecursive(
+        childDir,
+        pattern,
+        patternG,
+        stopAtMatchDir,
+        filter,
+        results
+      );
+    }
+  }
+}
+function findNestedRouterConflict(routerFiles) {
+  const routerDirs = [
+    ...new Set(routerFiles.map((filePath) => dirname2(resolve2(filePath))))
+  ].sort((a, b) => a.length - b.length);
+  for (let i = 0; i < routerDirs.length; i++) {
+    const ancestorDir = routerDirs[i];
+    const prefix = ancestorDir.endsWith(sep) ? ancestorDir : `${ancestorDir}${sep}`;
+    for (let j = i + 1; j < routerDirs.length; j++) {
+      const nestedDir = routerDirs[j];
+      if (!nestedDir.startsWith(prefix)) continue;
+      const ancestorFile = routerFiles.find(
+        (filePath) => dirname2(resolve2(filePath)) === ancestorDir
+      );
+      const nestedFile = routerFiles.find(
+        (filePath) => dirname2(resolve2(filePath)) === nestedDir
+      );
+      if (ancestorFile && nestedFile) {
+        return { ancestor: ancestorFile, nested: nestedFile };
+      }
+    }
+  }
+  return null;
+}
+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 isCreateRouterCall(node) {
+  if (!ts5.isCallExpression(node)) return false;
+  const callee = node.expression;
+  return ts5.isIdentifier(callee) && callee.text === "createRouter";
+}
+function extractUrlsArgument(arg, sourceFile, urlsAliases) {
+  const node = unwrapTypeOperators(arg);
+  if (ts5.isIdentifier(node)) {
+    return { kind: "variable", name: node.text };
+  }
+  if (ts5.isArrowFunction(node) || ts5.isFunctionExpression(node) || ts5.isCallExpression(node) && isUrlsDefinitionCall(node, urlsAliases)) {
+    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 collectExportedLocalNames(sourceFile) {
+  const names = /* @__PURE__ */ new Set();
+  const addIdentifier = (expr) => {
+    const node = expr && unwrapTypeOperators(expr);
+    if (node && ts5.isIdentifier(node)) names.add(node.text);
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts5.isExportAssignment(statement)) {
+      addIdentifier(statement.expression);
+    } else if (ts5.isExportDeclaration(statement) && !statement.moduleSpecifier && !statement.isTypeOnly && statement.exportClause && ts5.isNamedExports(statement.exportClause)) {
+      for (const element of statement.exportClause.elements) {
+        if (!element.isTypeOnly) {
+          names.add((element.propertyName ?? element.name).text);
+        }
+      }
+    } else if (ts5.isVariableStatement(statement) && hasModifier(statement, ts5.SyntaxKind.ExportKeyword)) {
+      for (const decl of statement.declarationList.declarations) {
+        addIdentifier(decl.initializer);
+      }
+    }
+  }
+  return names;
+}
+function isExportedChain(chainEnd, exportedNames) {
+  let current = chainEnd;
+  while (current.parent && (ts5.isAsExpression(current.parent) || ts5.isSatisfiesExpression(current.parent) || ts5.isParenthesizedExpression(current.parent))) {
+    current = current.parent;
+  }
+  const parent = current.parent;
+  if (!parent) return false;
+  if (ts5.isExportAssignment(parent))
+    return parent.parent === current.getSourceFile();
+  if (!ts5.isVariableDeclaration(parent) || parent.initializer !== current || !ts5.isIdentifier(parent.name)) {
+    return false;
+  }
+  const statement = parent.parent.parent;
+  if (!ts5.isVariableStatement(statement) || !ts5.isSourceFile(statement.parent)) {
+    return false;
+  }
+  return hasModifier(statement, ts5.SyntaxKind.ExportKeyword) || exportedNames.has(parent.name.text);
+}
+function findRouterUrls(sourceFile) {
+  const exported = [];
+  const local = [];
+  let anyExported = false;
+  const seen = /* @__PURE__ */ new Set();
+  const urlsAliases = collectUrlsImportAliases(sourceFile);
+  const exportedNames = collectExportedLocalNames(sourceFile);
+  function visit(node) {
+    if (ts5.isCallExpression(node)) {
+      const chain = collectCreateRouterCallChain(node);
+      if (chain && !seen.has(chain[0])) {
+        const extracted = [];
+        const unreadable = [];
+        const createRouterCall = chain[0];
+        seen.add(createRouterCall);
+        const addMount = (arg, mount) => {
+          const urls = extractUrlsArgument(arg, sourceFile, urlsAliases);
+          if (urls) extracted.push(urls);
+          else
+            unreadable.push(
+              mount(arg.getText(sourceFile).replace(/\s+/g, " "))
+            );
+        };
+        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;
+            }
+            addMount(prop.initializer, (text) => `urls: ${text}`);
+            break;
+          }
+        }
+        for (const call of chain.slice(1)) {
+          if (!ts5.isPropertyAccessExpression(call.expression) || call.expression.name.text !== "routes" || call.arguments.length === 0) {
+            continue;
+          }
+          addMount(call.arguments[0], (text) => `.routes(${text})`);
+        }
+        const isExported = isExportedChain(node, exportedNames);
+        if (isExported) anyExported = true;
+        if (extracted.length > 0 || unreadable.length > 0) {
+          (isExported ? exported : local).push({
+            createRouterCall,
+            extractions: extracted,
+            unreadable
+          });
+        }
+      }
+    }
+    ts5.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  const candidates = anyExported ? exported : local;
+  return candidates.find((c) => c.extractions.length > 0) ?? candidates[0] ?? null;
+}
+function parseRouterSource(code) {
+  return ts5.createSourceFile(
+    "router.tsx",
+    code,
+    ts5.ScriptTarget.Latest,
+    true,
+    ts5.ScriptKind.TSX
+  );
+}
+function extractAllUrlsFromRouter(code) {
+  return findRouterUrls(parseRouterSource(code))?.extractions ?? [];
+}
+function extractUrlsFromRouter(code) {
+  const extractions = extractAllUrlsFromRouter(code);
+  return extractions[extractions.length - 1] ?? null;
+}
+function unwrapTypeOperators(expr) {
+  while (ts5.isAsExpression(expr) || ts5.isSatisfiesExpression(expr) || ts5.isParenthesizedExpression(expr)) {
+    expr = expr.expression;
+  }
+  return expr;
+}
+function hasModifier(statement, kind) {
+  return ts5.canHaveModifiers(statement) && (ts5.getModifiers(statement)?.some((m) => m.kind === kind) ?? false);
+}
+function findTopLevelConst(sourceFile, name, exported) {
+  for (const statement of sourceFile.statements) {
+    if (ts5.isVariableStatement(statement) && statement.declarationList.flags & ts5.NodeFlags.Const && !hasModifier(statement, ts5.SyntaxKind.DeclareKeyword) && (!exported || hasModifier(statement, ts5.SyntaxKind.ExportKeyword))) {
+      for (const decl of statement.declarationList.declarations) {
+        if (ts5.isIdentifier(decl.name) && decl.name.text === name) {
+          return decl.initializer && unwrapTypeOperators(decl.initializer);
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function findNamedImport(sourceFile, name) {
+  for (const statement of sourceFile.statements) {
+    if (!ts5.isImportDeclaration(statement) || !ts5.isStringLiteral(statement.moduleSpecifier) || statement.importClause?.isTypeOnly) {
+      continue;
+    }
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings || !ts5.isNamedImports(bindings)) continue;
+    for (const el of bindings.elements) {
+      if (!el.isTypeOnly && el.name.text === name) {
+        return {
+          specifier: statement.moduleSpecifier.text,
+          exportedName: el.propertyName?.text ?? name
+        };
+      }
+    }
+  }
+  return void 0;
+}
+function resolveTopLevelConst(name, sourceFile, routerFilePath) {
+  const local = findTopLevelConst(sourceFile, name, false);
+  if (local) return local;
+  const imported = findNamedImport(sourceFile, name);
+  if (!imported) return void 0;
+  const target = resolveImportPath(imported.specifier, routerFilePath);
+  if (!target) return void 0;
+  const targetSource = readFileSync3(target, "utf-8");
+  return findTopLevelConst(
+    ts5.createSourceFile(target, targetSource, ts5.ScriptTarget.Latest, true),
+    imported.exportedName,
+    true
+  );
+}
+function isTopLevelScope(node) {
+  for (let p = node.parent; !ts5.isSourceFile(p); p = p.parent) {
+    if (ts5.isFunctionLike(p) || ts5.isClassLike(p) || ts5.isBlock(p) || ts5.isCaseBlock(p) || ts5.isModuleBlock(p) || ts5.isIterationStatement(p, false)) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveRouterBasename(routerSource, routerFilePath) {
+  const sourceFile = ts5.createSourceFile(
+    routerFilePath,
+    routerSource,
+    ts5.ScriptTarget.Latest,
+    true,
+    ts5.ScriptKind.TSX
+  );
+  const options = findRouterUrls(sourceFile)?.createRouterCall.arguments[0];
+  const prop = options && ts5.isObjectLiteralExpression(options) ? options.properties.find(
+    (p) => (ts5.isPropertyAssignment(p) || ts5.isShorthandPropertyAssignment(p)) && ts5.isIdentifier(p.name) && p.name.text === "basename"
+  ) : void 0;
+  if (!prop) return {};
+  const valueExpr = ts5.isPropertyAssignment(prop) ? prop.initializer : prop.name;
+  const expr = unwrapTypeOperators(valueExpr);
+  let value = getStringValue(expr);
+  if (value === null && isTopLevelScope(prop)) {
+    if (ts5.isIdentifier(expr)) {
+      const init = resolveTopLevelConst(expr.text, sourceFile, routerFilePath);
+      value = init ? getStringValue(init) : null;
+    } else if (ts5.isPropertyAccessExpression(expr) && ts5.isIdentifier(expr.expression)) {
+      const owner = resolveTopLevelConst(
+        expr.expression.text,
+        sourceFile,
+        routerFilePath
+      );
+      value = owner ? resolveConstMember(owner, expr.name.text) : null;
+    }
+  }
+  return value === null ? { unresolved: valueExpr.getText(sourceFile).replace(/\s+/g, " ") } : { value };
+}
+function resolveConstMember(owner, name) {
+  if (!ts5.isObjectLiteralExpression(owner) || owner.properties.some(ts5.isSpreadAssignment)) {
+    return null;
+  }
+  const member = owner.properties.find(
+    (p) => ts5.isPropertyAssignment(p) && ts5.isIdentifier(p.name) && p.name.text === name
+  );
+  return member ? getStringValue(unwrapTypeOperators(member.initializer)) : null;
+}
+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 join(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 {
+    routerSource = readFileSync3(routerFilePath, "utf-8");
+  } catch {
+    return { routes: {}, searchSchemas: {} };
+  }
+  const extractions = extractAllUrlsFromRouter(routerSource);
+  if (extractions.length === 0) {
+    return { routes: {}, searchSchemas: {} };
+  }
+  const basename = normalizeBasename(
+    resolveRouterBasename(routerSource, routerFilePath).value
+  );
+  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 result;
+}
+function detectUnresolvableIncludes(routerFilePath) {
+  const realPath = resolve2(routerFilePath);
+  let source;
+  try {
+    source = readFileSync3(realPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const routerUrls = findRouterUrls(parseRouterSource(source));
+  if (!routerUrls) return [];
+  const diagnostics = [];
+  for (const mount of routerUrls.unreadable) {
+    diagnostics.push({
+      pathPrefix: "/",
+      namePrefix: null,
+      reason: "unresolvable-routes",
+      sourceFile: realPath,
+      detail: `\`${mount}\` is not a urls() call (as imported from @rangojs/router), a builder function or a variable; its routes would be missing`
+    });
+  }
+  const memo = createScanMemo();
+  for (const extraction of routerUrls.extractions) {
+    resolveRouterUrlsExtraction(
+      realPath,
+      source,
+      extraction,
+      diagnostics,
+      memo
+    );
+  }
+  const { unresolved } = resolveRouterBasename(source, realPath);
+  if (unresolved !== void 0) {
+    diagnostics.push({
+      pathPrefix: "/",
+      namePrefix: null,
+      reason: "unresolvable-basename",
+      sourceFile: realPath,
+      detail: `basename \`${unresolved}\` is not a string literal or top-level const; every pattern would lack the prefix`
+    });
+  }
+  return diagnostics;
+}
+function detectUnresolvableIncludesForUrlsFile(filePath) {
+  const realPath = resolve2(filePath);
+  let source;
+  try {
+    source = readFileSync3(realPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const varNames = findUrlsVariableNames(source);
+  if (varNames.length === 0) return [];
+  const diagnostics = [];
+  for (const varName of varNames) {
+    buildCombinedRouteMapWithSearch(realPath, varName, /* @__PURE__ */ new Set(), diagnostics);
+  }
+  return diagnostics;
+}
+function findRouterFiles(root, filter) {
+  const result = [];
+  findCallSiteFilesRecursive(
+    root,
+    ROUTER_CALL_PATTERN,
+    ROUTER_CALL_PATTERN_G,
+    true,
+    filter,
+    result
+  );
+  return result;
+}
+function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
+  try {
+    const oldCombinedPath = join(root, "src", "named-routes.gen.ts");
+    if (existsSync3(oldCombinedPath)) {
+      unlinkSync(oldCombinedPath);
+      console.log(
+        `[rango] Removed stale combined route types: ${oldCombinedPath}`
+      );
+    }
+  } catch {
+  }
+  const routerFilePaths = knownRouterFiles ?? findRouterFiles(root);
+  if (routerFilePaths.length === 0) return;
+  const nestedRouterConflict = findNestedRouterConflict(routerFilePaths);
+  if (nestedRouterConflict) {
+    throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
+  }
+  for (const routerFilePath of routerFilePaths) {
+    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 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;
+    }
+    const hasSearchSchemas = Object.keys(result.searchSchemas).length > 0;
+    const source = generateRouteTypesSource(
+      result.routes,
+      hasSearchSchemas ? result.searchSchemas : void 0
+    );
+    if (existing !== source) {
+      if (opts?.preserveIfLarger && existing) {
+        const existingCount = countPublicRouteEntries(existing);
+        const newCount = Object.keys(result.routes).filter(
+          (name) => !isAutoGeneratedRouteName(name)
+        ).length;
+        if (existingCount > newCount) {
+          continue;
+        }
+      }
+      opts?.onWrite?.(outPath, source);
+      writeFileSync2(outPath, source);
+      console.log(
+        `[rango] Generated route types (${Object.keys(result.routes).length} routes) -> ${outPath}`
+      );
+    }
+  }
+}
+
+export {
+  generateRouteTypesSource,
+  writePerModuleRouteTypesForFile,
+  isRoutableSourceFile,
+  findNestedRouterConflict,
+  formatNestedRouterConflictError,
+  genFileTsPath,
+  resolveSearchSchemas,
+  detectUnresolvableIncludes,
+  detectUnresolvableIncludesForUrlsFile,
+  writeCombinedRouteTypes
+};