@rangojs/router 0.0.0-experimental.137 → 0.0.0-experimental.139

package/src/build/route-types/include-resolution.ts

@@ -97,6 +97,147 @@ function extractNamePrefixFromInclude(node: ts.CallExpression): string | null {
   return null;
 }
 
+/**
+ * True when the thunk transforms its dynamic import via a `.then(cb)` whose
+ * callback selects a NAMED export other than `default` (e.g.
+ * `import("./x").then((m) => m.routes)`). The static resolver walks the module's
+ * `export default`, so such a selector would resolve the WRONG export — the
+ * caller must treat it as unresolvable instead of silently mis-resolving. Returns
+ * false for the supported shapes (no `.then`, `.then((m) => m)`,
+ * `.then((m) => m.default)`) and for any shape it cannot positively identify as a
+ * non-default member selection (those keep the existing resolve-via-default path).
+ */
+function thenSelectsNonDefaultMember(expr: ts.Expression): boolean {
+  const findThenCall = (e: ts.Expression): ts.CallExpression | null => {
+    if (
+      ts.isCallExpression(e) &&
+      ts.isPropertyAccessExpression(e.expression) &&
+      e.expression.name.text === "then"
+    ) {
+      return e;
+    }
+    if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression)) {
+      return findThenCall(e.expression.expression);
+    }
+    if (ts.isPropertyAccessExpression(e)) return findThenCall(e.expression);
+    if (ts.isParenthesizedExpression(e)) return findThenCall(e.expression);
+    if (ts.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 (!ts.isArrowFunction(cb) && !ts.isFunctionExpression(cb)) return false;
+
+  let ret: ts.Expression | undefined;
+  if (ts.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      if (ts.isReturnStatement(stmt) && stmt.expression) {
+        ret = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    ret = cb.body;
+  }
+  if (!ret) return false;
+
+  if (ts.isPropertyAccessExpression(ret)) {
+    return ret.name.text !== "default";
+  }
+  return false;
+}
+
+/**
+ * Extract the module specifier from an async include thunk
+ * (`() => import("./mod")`). Handles arrow and function-expression thunks,
+ * concise or block bodies, and `import("./mod").then(...)` chains. Returns the
+ * specifier string, or null when the second arg is not a dynamic-import thunk
+ * (so the caller can fall through to identifier / factory-call / dynamic-expr
+ * classification).
+ */
+function extractDynamicImportSpecifier(node: ts.Expression): string | null {
+  let body: ts.ConciseBody | undefined;
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    body = node.body;
+  }
+  if (!body) return null;
+
+  // Concise body is the expression itself; block body: first `return <expr>`.
+  let expr: ts.Expression | undefined;
+  if (ts.isBlock(body)) {
+    for (const stmt of body.statements) {
+      if (ts.isReturnStatement(stmt) && stmt.expression) {
+        expr = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    expr = body;
+  }
+  if (!expr) return null;
+
+  // Descend `import("./mod").then(...)` / parenthesized / await wrappers down to
+  // the `import(...)` call itself.
+  const findImportCall = (e: ts.Expression): ts.CallExpression | null => {
+    if (
+      ts.isCallExpression(e) &&
+      e.expression.kind === ts.SyntaxKind.ImportKeyword
+    ) {
+      return e;
+    }
+    if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression)) {
+      return findImportCall(e.expression.expression);
+    }
+    if (ts.isPropertyAccessExpression(e)) return findImportCall(e.expression);
+    if (ts.isParenthesizedExpression(e)) return findImportCall(e.expression);
+    if (ts.isAwaitExpression(e)) return findImportCall(e.expression);
+    return null;
+  };
+
+  const importCall = findImportCall(expr);
+  if (!importCall || importCall.arguments.length === 0) return null;
+  // A `.then()` selecting a non-default named export can't be statically
+  // resolved to `export default`; return null so the caller emits a diagnostic
+  // rather than silently generating types for the wrong export.
+  if (thenSelectsNonDefaultMember(expr)) return null;
+  return getStringValue(importCall.arguments[0]);
+}
+
+/**
+ * Resolve a module's `export default` to either a same-file `urls()` variable
+ * name (`export default shopPatterns`) or the inline call block
+ * (`export default urls(...)`). Used to walk async include modules
+ * (`() => import("./mod")`), whose convention is `export default urls(...)`.
+ */
+function resolveDefaultExportTarget(
+  code: string,
+  sourceFile: ts.SourceFile,
+): { variableName?: string; inlineBlock?: string } | null {
+  let result: { variableName?: string; inlineBlock?: string } | null = null;
+
+  function visit(node: ts.Node) {
+    if (result) return;
+    if (ts.isExportAssignment(node) && !node.isExportEquals) {
+      const expr = node.expression;
+      if (ts.isIdentifier(expr)) {
+        result = { variableName: expr.text };
+      } else if (ts.isCallExpression(expr)) {
+        const callee = expr.expression;
+        if (ts.isIdentifier(callee) && callee.text === "urls") {
+          result = { inlineBlock: expr.getText(sourceFile) };
+        }
+      }
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return result;
+}
+
 /**
  * Extract include() calls with diagnostics for unresolvable ones.
  * Returns both resolved includes (identifier second args) and unresolvable
@@ -108,7 +249,12 @@ export function extractIncludesWithDiagnostics(
 ): {
   resolved: Array<{
     pathPrefix: string;
-    variableName: string;
+    // Exactly one of variableName / moduleSpecifier is set. variableName is the
+    // classic `include("/api", apiUrls)` identifier form; moduleSpecifier is the
+    // async `include("/api", () => import("./api"))` form, carrying the imported
+    // module path so resolution can walk its `export default`.
+    variableName?: string;
+    moduleSpecifier?: string;
     namePrefix: string | null;
   }>;
   unresolvable: Array<{
@@ -130,7 +276,8 @@ export function extractIncludesWithDiagnostics(
     );
   const resolved: Array<{
     pathPrefix: string;
-    variableName: string;
+    variableName?: string;
+    moduleSpecifier?: string;
     namePrefix: string | null;
   }> = [];
   const unresolvable: Array<{
@@ -158,12 +305,22 @@ export function extractIncludesWithDiagnostics(
         const secondArg = node.arguments[1];
         const namePrefix = extractNamePrefixFromInclude(node);
 
+        const dynamicImportSpec = extractDynamicImportSpecifier(secondArg);
+
         if (ts.isIdentifier(secondArg)) {
           resolved.push({
             pathPrefix,
             variableName: secondArg.text,
             namePrefix,
           });
+        } else if (dynamicImportSpec !== null) {
+          // Async include: `include("/api", () => import("./api"))`. Resolvable
+          // statically by walking the imported module's `export default`.
+          resolved.push({
+            pathPrefix,
+            moduleSpecifier: dynamicImportSpec,
+            namePrefix,
+          });
         } else if (ts.isCallExpression(secondArg)) {
           const callText = secondArg.expression.getText(sourceFile);
           unresolvable.push({
@@ -348,65 +505,120 @@ function buildRouteMapFromBlock(
     }
   }
 
-  for (const { pathPrefix, variableName, namePrefix } of includes) {
+  for (const inc of includes) {
+    const { pathPrefix, namePrefix } = inc;
     let childResult: {
       routes: Record<string, string>;
       searchSchemas: Record<string, Record<string, string>>;
     };
 
-    // Try import resolution first
-    const imported = resolveImportedVariable(fullSource, variableName);
-    if (imported) {
-      const targetFile = resolveImportPath(imported.specifier, filePath);
+    if (inc.moduleSpecifier) {
+      // Async include `() => import("./mod")`: resolve the imported module's
+      // `export default` (convention: `export default urls(...)`), then recurse
+      // into it exactly like an identifier include. Nested include()s inside the
+      // async module — eager or async — resolve through the same recursion.
+      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,
-        undefined,
-        memo,
-      );
-    } else {
-      // Check if variable exists as a same-file urls() definition. Share the
-      // full-source SourceFile parse via the memo (block === fullSource hits the
-      // same cache entry already used above).
-      const sameFileBlock = extractUrlsBlockForVariable(
-        fullSource,
-        variableName,
-        parseBlock(memo, fullSource),
+      let targetSource: string;
+      try {
+        targetSource = readSourceMemoized(memo, resolve(targetFile));
+      } catch (err) {
+        // Every other failure path in this function emits a diagnostic; a bare
+        // `continue` here would drop the group from generated types with no
+        // signal at all. Emit one like the siblings do.
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to "${targetFile}" but reading it failed: ${(err as Error)?.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) {
+        // `export default urls(...)` — recurse into the inline call block.
+        childResult = buildCombinedRouteMapWithSearch(
+          targetFile,
+          undefined,
+          visited,
+          diagnosticsOut,
+          def.inlineBlock,
+          memo,
+        );
+      } else {
+        // `export default <name>`. That name may be a same-file
+        // `const name = urls(...)` OR itself re-exported from an import
+        // (`import { name } from "./x"; export default name`). The shared helper
+        // resolves the import chain first, then falls back to same-file
+        // extraction — without this a re-exported default silently yields empty
+        // routes. Resolution scope is the imported module (targetFile); the
+        // diagnostic is still attributed to the file with the async include.
+        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) {
+      // Identifier include `include(prefix, patterns)`: resolve `patterns`
+      // (imported or same-file) through the same shared helper as the async
+      // `export default <name>` form above.
+      const variableName = inc.variableName;
+      const resolved = resolveIncludedVariable({
         variableName,
+        resolutionFile: filePath,
+        resolutionSource: fullSource,
+        reportFile: filePath,
+        memo,
         visited,
         diagnosticsOut,
-        undefined,
-        memo,
-      );
+        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;
     }
 
     // Includes without a name keep their child names private to the mounted
@@ -438,6 +650,94 @@ function buildRouteMapFromBlock(
   return routeMap;
 }
 
+/**
+ * Resolve an include's target VARIABLE to its child route map. The variable may
+ * be imported (`import { name } from "./x"`) or defined in the same file
+ * (`const name = urls(...)`). Shared by the identifier include branch and the
+ * async-include `export default <name>` branch so a future import-resolution fix
+ * cannot silently miss one form. Returns null (with a diagnostic pushed) when
+ * the variable is unresolvable — the caller should skip the include.
+ *
+ * `resolutionFile`/`resolutionSource` is the module whose import + same-file
+ * scope is searched; `reportFile` is the file the diagnostic is attributed to
+ * (the one containing the include() call), which differs for async includes.
+ */
+function resolveIncludedVariable(opts: {
+  variableName: string;
+  resolutionFile: string;
+  resolutionSource: string;
+  reportFile: string;
+  memo: ScanMemo | undefined;
+  visited: Set<string> | undefined;
+  diagnosticsOut: UnresolvableInclude[] | undefined;
+  pathPrefix: string;
+  namePrefix: string | null;
+  fileNotFoundDetail: (specifier: string) => string;
+  notFoundDetail: () => string;
+}): {
+  routes: Record<string, string>;
+  searchSchemas: Record<string, Record<string, string>>;
+} | null {
+  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,
+      undefined,
+      memo,
+    );
+  }
+  // Not imported: it must be a same-file `const name = urls(...)`. Confirm it
+  // exists so an undefined name emits a diagnostic instead of empty routes.
+  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,
+    undefined,
+    memo,
+  );
+}
+
 /**
  * Build route map and search schemas together.
  * Internal helper used by the include resolution path.

package/src/build/route-types/router-processing.ts

@@ -54,8 +54,33 @@ function isRoutableSourceFile(name: string): boolean {
   );
 }
 
-function findRouterFilesRecursive(
+function isExcludedScanDir(name: string): boolean {
+  return (
+    name === "node_modules" ||
+    name === "dist" ||
+    name === "coverage" ||
+    name === "__tests__" ||
+    name === "__mocks__" ||
+    name.startsWith(".")
+  );
+}
+
+/**
+ * Recursively collect source files whose code contains `pattern` (a comment- or
+ * string-only mention is ignored via firstCodeMatchIndex). Shared by createRouter
+ * and createHostRouter discovery, which differ only in the call pattern and
+ * `stopAtMatchDir`: createRouter treats a directory containing a match as a router
+ * root and stops descending it; createHostRouter descends the whole tree (the host
+ * entry sits above the sub-app router roots).
+ *
+ * `pattern` is the non-global tester (no lastIndex state); `patternG` is its global
+ * twin for the code-region scan.
+ */
+function findCallSiteFilesRecursive(
   dir: string,
+  pattern: RegExp,
+  patternG: RegExp,
+  stopAtMatchDir: boolean,
   filter: ScanFilter | undefined,
   results: string[],
 ): void {
@@ -70,21 +95,12 @@ function findRouterFilesRecursive(
   }
 
   const childDirs: string[] = [];
-  const routerFilesInDir: string[] = [];
+  const matchesInDir: string[] = [];
 
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     if (entry.isDirectory()) {
-      if (
-        entry.name === "node_modules" ||
-        entry.name === "dist" ||
-        entry.name === "coverage" ||
-        entry.name === "__tests__" ||
-        entry.name === "__mocks__" ||
-        entry.name.startsWith(".")
-      )
-        continue;
-      childDirs.push(fullPath);
+      if (!isExcludedScanDir(entry.name)) childDirs.push(fullPath);
       continue;
     }
 
@@ -100,26 +116,29 @@ function findRouterFilesRecursive(
       // so a mention inside a comment or string is not mistaken for a real
       // router file (which previously triggered a spurious "Multiple routers
       // found" error).
-      if (
-        ROUTER_CALL_PATTERN.test(source) &&
-        firstCodeMatchIndex(source, ROUTER_CALL_PATTERN_G) >= 0
-      ) {
-        routerFilesInDir.push(fullPath);
+      if (pattern.test(source) && firstCodeMatchIndex(source, patternG) >= 0) {
+        matchesInDir.push(fullPath);
       }
     } catch {
       continue;
     }
   }
 
-  // A directory that contains a router file is treated as a router root.
-  // Once found, deeper directories are skipped to avoid redundant scans.
-  if (routerFilesInDir.length > 0) {
-    results.push(...routerFilesInDir);
-    return;
-  }
-
-  for (const childDir of childDirs) {
-    findRouterFilesRecursive(childDir, filter, results);
+  results.push(...matchesInDir);
+
+  // createRouter (stopAtMatchDir): a directory that contains a match is a router
+  // root, so deeper directories are skipped. createHostRouter: always descend.
+  if (!stopAtMatchDir || matchesInDir.length === 0) {
+    for (const childDir of childDirs) {
+      findCallSiteFilesRecursive(
+        childDir,
+        pattern,
+        patternG,
+        stopAtMatchDir,
+        filter,
+        results,
+      );
+    }
   }
 }
 
@@ -552,7 +571,38 @@ export function detectUnresolvableIncludesForUrlsFile(
  */
 export function findRouterFiles(root: string, filter?: ScanFilter): string[] {
   const result: string[] = [];
-  findRouterFilesRecursive(root, filter, result);
+  findCallSiteFilesRecursive(
+    root,
+    ROUTER_CALL_PATTERN,
+    ROUTER_CALL_PATTERN_G,
+    true,
+    filter,
+    result,
+  );
+  return result;
+}
+
+const HOST_ROUTER_CALL_PATTERN = /\bcreateHostRouter\s*[<(]/;
+const HOST_ROUTER_CALL_PATTERN_G = /\bcreateHostRouter\s*[<(]/g;
+
+/**
+ * Scan for files containing createHostRouter() and return their paths. Unlike
+ * findRouterFiles, this does NOT stop at the first router-root directory -- a host
+ * entry typically sits above the sub-app router roots, so the whole tree is scanned.
+ */
+export function findHostRouterFiles(
+  root: string,
+  filter?: ScanFilter,
+): string[] {
+  const result: string[] = [];
+  findCallSiteFilesRecursive(
+    root,
+    HOST_ROUTER_CALL_PATTERN,
+    HOST_ROUTER_CALL_PATTERN_G,
+    false,
+    filter,
+    result,
+  );
   return result;
 }
 

package/src/build/runtime-discovery.ts

@@ -139,7 +139,10 @@ export async function discoverAndWriteRouteTypes(
     for (const [id, router] of registry) {
       if (!router.urlpatterns) continue;
 
-      const manifest = generateManifest(router.urlpatterns, routerMountIndex);
+      const manifest = await generateManifest(
+        router.urlpatterns,
+        routerMountIndex,
+      );
       routerMountIndex++;
 
       // Filter out auto-generated route names that the runtime creates for

package/src/cache/cf/cf-cache-store.ts

@@ -2267,6 +2267,28 @@ export class CFCacheStore<TEnv = unknown> implements SegmentCacheStore<TEnv> {
     if (!this.kv || !this.waitUntil || totalTtl < 60) return;
 
     const kvKey = this.toKVKey(key);
+
+    // Reject an oversized data-segment KV key the same way tag-marker keys are
+    // rejected in invalidateTags(). A key over KV_MAX_KEY_BYTES makes kv.put()
+    // fail, so the segment silently never lands in L2 (KV) and every cold-colo
+    // or TTL-expired read re-renders instead of serving stale. Segment keys can
+    // grow with user-controlled inputs (e.g. a route's search params), so report
+    // a clear, actionable error and skip the doomed write rather than letting it
+    // reject deep inside waitUntil as an opaque cache-write failure.
+    const kvKeyBytes = kvKeyByteLength(kvKey);
+    if (kvKeyBytes > KV_MAX_KEY_BYTES) {
+      reportCacheError(
+        new Error(
+          `cache segment key produces a ${kvKeyBytes}-byte KV key, over the ` +
+            `${KV_MAX_KEY_BYTES}-byte limit; the segment was not persisted to KV (L2). ` +
+            `Reduce the cache-key inputs (e.g. large search params on this route).`,
+        ),
+        "cache-write",
+        "[CFCacheStore] kvSetSegment",
+      );
+      return;
+    }
+
     const expiresAt = staleAt + swrWindow * 1000;
 
     this.waitUntil(() =>

package/src/cache/index.ts

@@ -24,6 +24,18 @@ export {
   KV_READ_TIMEOUT_MS,
 } from "./cf/index.js";
 
+export {
+  VercelCacheStore,
+  type VercelCacheStoreOptions,
+  type VercelRuntimeCache,
+  type VercelCacheDebug,
+  type VercelCacheReadDebugEvent,
+  type VercelCacheReadOutcome,
+  VERCEL_MAX_ITEM_BYTES,
+  VERCEL_MAX_TAGS_PER_ITEM,
+  VERCEL_MAX_TAG_BYTES,
+} from "./vercel/index.js";
+
 export { CacheScope, createCacheScope } from "./cache-scope.js";
 
 export {

package/src/cache/vercel/index.ts

@@ -0,0 +1,11 @@
+export {
+  VercelCacheStore,
+  type VercelCacheStoreOptions,
+  type VercelRuntimeCache,
+  type VercelCacheDebug,
+  type VercelCacheReadDebugEvent,
+  type VercelCacheReadOutcome,
+  VERCEL_MAX_ITEM_BYTES,
+  VERCEL_MAX_TAGS_PER_ITEM,
+  VERCEL_MAX_TAG_BYTES,
+} from "./vercel-cache-store.js";