@rangojs/router 0.0.0-experimental.bd6e11bc → 0.0.0-experimental.bdaf10aa

package/src/browser/types.ts

@@ -14,7 +14,6 @@ import type { RenderSegmentsOptions } from "../segment-system.js";
 export interface RscPayload<TMetadata = RscMetadata> {
   metadata?: TMetadata;
   returnValue?: ActionResult;
-  formState?: unknown;
 }
 
 /**
@@ -32,8 +31,10 @@ export type HandleData = Record<string, Record<string, unknown[]>>;
 export interface RscMetadata {
   pathname: string;
   segments: ResolvedSegment[];
-  /** Router instance ID. When this changes between navigations, the client
-   *  forces a full tree replacement (app switch via host router). */
+  /** Router instance ID — the current app's identity. A mismatch with the
+   *  client's id (sent as _rsc_rid) is detected server-side and answered with
+   *  X-RSC-Reload (full document load), so the client never swaps apps
+   *  in-session; within a session this always equals the current app. */
   routerId?: string;
   isPartial?: boolean;
   isError?: boolean;
@@ -69,6 +70,22 @@ export interface RscMetadata {
    * Sent on initial render so the browser can configure its cache duration.
    */
   prefetchCacheTTL?: number;
+  /**
+   * Max entries in the client-side in-memory prefetch cache (FIFO eviction).
+   * Sent on initial render so the browser can configure its cache capacity.
+   */
+  prefetchCacheSize?: number;
+  /**
+   * Max concurrent speculative prefetch requests on the client.
+   * Sent on initial render so the browser can configure its prefetch queue.
+   */
+  prefetchConcurrency?: number;
+  /**
+   * Server-resolved rango state cookie name (`{prefix}_{routerId}`). The client
+   * reads it verbatim and binds the rango state cookie to it; composition
+   * happens only server-side.
+   */
+  stateCookieName?: string;
   /**
    * Theme configuration from router.
    * Included when theme is enabled in router config.
@@ -83,8 +100,18 @@ export interface RscMetadata {
   basename?: string;
   /** Whether connection warmup is enabled */
   warmupEnabled?: boolean;
-  /** Server-side redirect with optional state (for partial requests) */
-  redirect?: { url: string };
+  /**
+   * Whether the client should hydrate inside React.StrictMode. Carried on the
+   * initial full-render payload only; the browser entry reads it once at
+   * hydration. Defaults to true on the client when omitted.
+   */
+  strictMode?: boolean;
+  /**
+   * Server-side redirect with optional state (for partial requests).
+   * `external: true` (from redirect(url, { external: true })) tells the client
+   * to hard-navigate to an off-host target instead of validating same-origin.
+   */
+  redirect?: { url: string; external?: boolean };
   /** Server-set location state to include in history.pushState */
   locationState?: Record<string, unknown>;
 }
@@ -185,6 +212,15 @@ export interface TrackedActionState {
   result: unknown | null;
 }
 
+/**
+ * The value returned by {@link useAction} when called without a selector.
+ *
+ * This is the stable, public name for the action-state shape; consumers can
+ * name it in their own signatures (e.g. a wrapper hook). It aliases the
+ * internal {@link TrackedActionState}.
+ */
+export type ActionState = TrackedActionState;
+
 /**
  * Listener for action state changes
  *
@@ -322,8 +358,14 @@ export interface RouterInstance {
   replace(url: string, options?: RouterNavigateOptions): Promise<void>;
   /** Refresh the current route (re-fetch server data, preserve client state) */
   refresh(): Promise<void>;
-  /** Prefetch a URL for faster client-side transition */
-  prefetch(url: string): void;
+  /**
+   * Prefetch a URL for faster client-side transition.
+   *
+   * Pass `{ key: ":source" }` to source-scope the prefetch cache entry (parity
+   * with `<Link prefetchKey=":source">`) when the target's response can differ
+   * by source page.
+   */
+  prefetch(url: string, options?: { key?: ":source" }): void;
   /** Go back in browser history */
   back(): void;
   /** Go forward in browser history */
@@ -415,6 +457,10 @@ export interface NavigationStore {
   // History-based segment cache (for back/forward navigation and partial merging)
   getHistoryKey(): string;
   setHistoryKey(key: string): void;
+  /** Monotonic token of the most recently committed navigation. */
+  getNavInstance(): number;
+  /** Nav-instance token recorded on a cache entry (undefined if absent). */
+  getCacheEntryInstance(historyKey: string): number | undefined;
   cacheSegmentsForHistory(
     historyKey: string,
     segments: ResolvedSegment[],
@@ -426,20 +472,44 @@ export interface NavigationStore {
         stale: boolean;
         handleData?: HandleData;
         routerId?: string;
+        /**
+         * True when the entry's handle data is incomplete (a deferred Meta was
+         * still pending at navigate-away). A popstate return must revalidate with
+         * a FULL re-render so the server re-streams handles.
+         */
+        handlesPending?: boolean;
       }
     | undefined;
   hasHistoryCache(historyKey: string): boolean;
-  updateCacheHandleData(historyKey: string, handleData: HandleData): void;
+  /**
+   * Update only the handleData (and optionally the stale / handlesPending flags)
+   * of an existing cache entry. When a flag is omitted the entry's current value
+   * is preserved. `stale=true` marks a single entry stale so a popstate return
+   * revalidates it; `handlesPending=true` additionally forces that revalidation
+   * to be a full re-render (so a deferred Meta re-streams).
+   */
+  updateCacheHandleData(
+    historyKey: string,
+    handleData: HandleData,
+    stale?: boolean,
+    handlesPending?: boolean,
+  ): void;
+  /**
+   * Owner-guarded variant of updateCacheHandleData: writes only when the entry
+   * is still owned by `ownerInstance`. Folds the caller's separate ownership
+   * probe and write into one historyCache scan for the per-yield streaming path.
+   */
+  updateCacheHandleDataIfOwned(
+    historyKey: string,
+    handleData: HandleData,
+    ownerInstance: number,
+    stale?: boolean,
+    handlesPending?: boolean,
+  ): void;
   markCacheAsStale(): void;
+  markHistoryCacheStale(): void;
   markCacheAsStaleAndBroadcast(): void;
   clearHistoryCache(): void;
-  /**
-   * Clear this tab's nav + prefetch caches without broadcasting or rotating
-   * shared state. Intended for app-switch transitions that affect only this
-   * tab's session.
-   */
-  clearHistoryCacheLocal(): void;
-  broadcastCacheInvalidation(): void;
 
   // Cross-tab refresh callback (set by navigation bridge)
   setCrossTabRefreshCallback(callback: () => void): void;
@@ -495,6 +565,15 @@ export interface FetchPartialResult {
   payload: RscPayload;
   /** Promise that resolves when the response stream is fully consumed */
   streamComplete: Promise<void>;
+  /**
+   * True only when this payload came from a prefetch-cache hit whose stream had
+   * ALREADY fully drained at fetch time (the route was fully prefetched). The
+   * commit then runs in a startTransition so loading()/Suspense content — already
+   * resolved — swaps in directly without flashing a fallback. A partially-warmed
+   * (still-streaming) prefetch hit and a cold fetch leave this false so their
+   * fallbacks stream as usual.
+   */
+  fullyPrefetched?: boolean;
 }
 
 /**
@@ -556,13 +635,6 @@ export interface NavigationBridge {
   getVersion(): string | undefined;
   /** Update the RSC version (e.g. after HMR). Clears prefetch cache. */
   updateVersion(newVersion: string): void;
-  /**
-   * Replace the active app-shell snapshot (rootLayout, basename, version)
-   * atomically. Used on cross-app navigations when the response's routerId
-   * indicates the user entered a different app. Theme, warmup, and prefetch
-   * TTL are document-lifetime and not part of the shell.
-   */
-  updateAppShell(next: import("./app-shell.js").AppShell): void;
 }
 
 /**

package/src/browser/validate-redirect-origin.ts

@@ -1,29 +1,56 @@
+import {
+  resolveSameOriginRedirect,
+  resolveExternalRedirect,
+} from "../redirect-origin.js";
+
 /**
  * Validate that a client-consumed redirect URL (from headers or Flight payload)
  * targets the same origin as the current page. Prevents open-redirect attacks
  * via crafted responses.
  *
+ * Thin wrapper over the shared {@link resolveSameOriginRedirect} rule (also used
+ * by the server guard in `rsc/redirect-guard.ts`) so client and server enforce
+ * the identical same-origin contract. Adds the client-side `console.error` on a
+ * block; the resolver itself stays pure.
+ *
  * @returns The canonical (normalized) URL string on success, or null if blocked.
  */
 export function validateRedirectOrigin(
   url: string,
   currentOrigin: string,
 ): string | null {
-  try {
-    const target = new URL(url, currentOrigin);
-    if (target.origin !== currentOrigin) {
-      console.error(
-        `[rango] Redirect blocked: origin mismatch (${target.origin})`,
-      );
-      return null;
-    }
-    // Return pathname+search+hash for relative inputs, full href for absolute.
-    // This normalizes protocol-relative and other ambiguous forms.
-    return target.href.startsWith(currentOrigin)
-      ? target.href
-      : target.pathname + target.search + target.hash;
-  } catch {
-    console.error(`[rango] Redirect blocked: invalid URL "${url}"`);
-    return null;
+  const resolved = resolveSameOriginRedirect(url, currentOrigin);
+  if (resolved === null) {
+    console.error(
+      `[rango] Redirect blocked: cross-origin or invalid target "${url}"`,
+    );
+  }
+  return resolved;
+}
+
+/**
+ * Validate an explicit off-origin redirect (`redirect(url, { external: true })`)
+ * the client is about to hard-navigate to via `window.location.assign()`.
+ *
+ * Thin wrapper over the shared {@link resolveExternalRedirect} rule (also used by
+ * the server guard in `rsc/redirect-guard.ts`) so client and server enforce the
+ * identical contract: `external` allows an off-origin target but only an
+ * http(s) scheme. This stops a forged or mistaken external payload carrying a
+ * `javascript:`/`data:` URL from turning `location.assign` into a scriptable
+ * navigation. Adds the client-side `console.error` on a block; the resolver
+ * itself stays pure.
+ *
+ * @returns The normalized URL string on success, or null if blocked.
+ */
+export function validateExternalRedirect(
+  url: string,
+  currentOrigin: string,
+): string | null {
+  const resolved = resolveExternalRedirect(url, currentOrigin);
+  if (resolved === null) {
+    console.error(
+      `[rango] External redirect blocked: non-http(s) target "${url}"`,
+    );
   }
+  return resolved;
 }

package/src/build/generate-manifest.ts

@@ -17,6 +17,11 @@ import type { TrailingSlashMode } from "../types.js";
 import { createRouteHelpers } from "../route-definition.js";
 import MapRootLayout from "../server/root-layout.js";
 import { collectFallbackClientRefs } from "./collect-fallback-refs.js";
+import {
+  isIncludeProvider,
+  resolveIncludeModule,
+  type IncludeProvider,
+} from "../urls/include-provider.js";
 
 /**
  * Node in the prefix tree
@@ -61,13 +66,32 @@ export interface GeneratedManifest {
 // Merge tracked nested includes into `target`. Multiple includes can share a
 // fullPrefix (e.g. include("/", a), include("/", b)) — concat their routes and
 // Object.assign children rather than overwrite.
-function mergeIncludeNodes(
+async function mergeIncludeNodes(
   target: Record<string, PrefixTreeNode>,
   includes: TrackedInclude[],
-  buildChild: (include: TrackedInclude) => PrefixTreeNode,
-): void {
+  buildChild: (include: TrackedInclude) => Promise<PrefixTreeNode>,
+): Promise<void> {
   for (const include of includes) {
-    const node = buildChild(include);
+    let node: PrefixTreeNode;
+    try {
+      node = await buildChild(include);
+    } catch (err) {
+      // Discovery (build-time, and the dev trie-rebuild) populates the
+      // manifest / trie / generated types for the WHOLE app. A failing async
+      // include provider here — a broken import, a module that throws at eval —
+      // must HARD-FAIL, not be swallowed: swallowing produces a green build with
+      // the entire route group silently absent from the manifest/trie/types, so
+      // CI passes, the deploy ships, and every one of that group's URLs then
+      // 404s/500s in production. On main an eager include that threw failed the
+      // build loudly; the async form must keep that contract. Rethrow with the
+      // offending prefix so the failure is actionable. (Sibling isolation
+      // belongs at PER-REQUEST runtime — see find-match.ts — not at discovery.)
+      throw new Error(
+        `[@rangojs/router] Failed to resolve include at prefix "${include.fullPrefix}" ` +
+          `during route discovery: ${(err as Error)?.message ?? String(err)}`,
+        { cause: err },
+      );
+    }
     const existing = target[include.fullPrefix];
     if (existing) {
       existing.routes.push(...node.routes);
@@ -78,10 +102,10 @@ function mergeIncludeNodes(
   }
 }
 
-function buildPrefixTreeNode(
+async function buildPrefixTreeNode(
   urlPrefix: string,
   namePrefix: string | undefined,
-  patterns: UrlPatterns<any>,
+  patternsOrProvider: UrlPatterns<any> | IncludeProvider<any>,
   routeManifest: Record<string, string>,
   routeAncestry: Record<string, string[]>, // internal: feeds trie building, not exported
   mountIndex: number,
@@ -92,7 +116,14 @@ function buildPrefixTreeNode(
   passthroughRoutes?: string[],
   responseTypeRoutes?: Record<string, string>,
   routeSearchSchemas?: Record<string, Record<string, string>>,
-): PrefixTreeNode {
+): Promise<PrefixTreeNode> {
+  // Resolve an async include provider (`() => import("./routes")`) so its routes
+  // are walked into the build-time manifest/types/href. Runtime matching still
+  // defers the import via lazy-includes; this only runs during build/dev
+  // discovery, which is async.
+  const patterns: UrlPatterns<any> = isIncludeProvider(patternsOrProvider)
+    ? resolveIncludeModule(await patternsOrProvider(), urlPrefix)
+    : patternsOrProvider;
   if (visited.has(patterns)) {
     console.warn(
       `[@rangojs/router] Circular include detected at prefix "${urlPrefix}". Skipping.`,
@@ -106,118 +137,117 @@ function buildPrefixTreeNode(
     };
   }
   visited.add(patterns);
-  // Create context for running patterns with include tracking
-  const manifest = new Map<string, EntryData>();
-  const patternsMap = new Map<string, string>();
-  const patternsByPrefix = new Map<string, Map<string, string>>();
-  const trailingSlashMap = new Map<string, TrailingSlashMode>();
-  const searchSchemasMap = new Map<string, Record<string, string>>();
-  const trackedIncludes: TrackedInclude[] = [];
+  try {
+    // Create context for running patterns with include tracking
+    const manifest = new Map<string, EntryData>();
+    const patternsMap = new Map<string, string>();
+    const patternsByPrefix = new Map<string, Map<string, string>>();
+    const trailingSlashMap = new Map<string, TrailingSlashMode>();
+    const searchSchemasMap = new Map<string, Record<string, string>>();
+    const trackedIncludes: TrackedInclude[] = [];
 
-  RangoContext.run(
-    {
-      manifest,
-      patterns: patternsMap,
-      patternsByPrefix,
-      trailingSlash: trailingSlashMap,
-      searchSchemas: searchSchemasMap,
-      namespace: "build",
-      parent: null,
-      counters: {},
-      mountIndex,
-      trackedIncludes, // Enable nested include tracking
-    },
-    () => {
-      const helpers = createRouteHelpers();
-      // Wrap in root layout for correct parent hierarchy (matches runtime)
-      helpers.layout(MapRootLayout, () => {
-        if (urlPrefix || namePrefix) {
-          return runWithPrefixes(urlPrefix, namePrefix, () => {
-            return patterns.handler() as AllUseItems[];
-          });
-        }
-        return patterns.handler() as AllUseItems[];
-      });
-    },
-  );
+    RangoContext.run(
+      {
+        manifest,
+        patterns: patternsMap,
+        patternsByPrefix,
+        trailingSlash: trailingSlashMap,
+        searchSchemas: searchSchemasMap,
+        namespace: "build",
+        parent: null,
+        counters: {},
+        mountIndex,
+        trackedIncludes, // Enable nested include tracking
+      },
+      () => {
+        const helpers = createRouteHelpers();
+        // Wrap in root layout for correct parent hierarchy (matches runtime)
+        helpers.layout(MapRootLayout, () => {
+          if (urlPrefix || namePrefix) {
+            return runWithPrefixes(urlPrefix, namePrefix, () => {
+              return patterns.handler() as AllUseItems[];
+            });
+          }
+          return patterns.handler() as AllUseItems[];
+        });
+      },
+    );
 
-  // Collect route names defined in this include (routes have prefixes applied)
-  const routes: string[] = [];
-  for (const [name, pattern] of patternsMap.entries()) {
-    routes.push(name);
-    routeManifest[name] = pattern;
-  }
+    // Collect route names defined in this include (routes have prefixes applied)
+    const routes = [...patternsMap.keys()];
+    Object.assign(routeManifest, Object.fromEntries(patternsMap));
 
-  // Collect trailing slash config
-  if (routeTrailingSlash) {
-    for (const [name, mode] of trailingSlashMap.entries()) {
-      routeTrailingSlash[name] = mode;
+    // Collect trailing slash config
+    if (routeTrailingSlash) {
+      for (const [name, mode] of trailingSlashMap.entries()) {
+        routeTrailingSlash[name] = mode;
+      }
     }
-  }
-  if (routeSearchSchemas) {
-    for (const [name, schema] of searchSchemasMap.entries()) {
-      routeSearchSchemas[name] = schema;
+    if (routeSearchSchemas) {
+      for (const [name, schema] of searchSchemasMap.entries()) {
+        routeSearchSchemas[name] = schema;
+      }
     }
-  }
 
-  // Capture ancestry from manifest entries' parent chains
-  captureAncestry(manifest, routeAncestry);
+    // Capture ancestry from manifest entries' parent chains
+    captureAncestry(manifest, routeAncestry);
 
-  // Collect prerender route names and handler definitions from manifest entries
-  if (prerenderRoutes) {
-    for (const [name, entry] of manifest) {
-      if (entry.type === "route" && entry.isPrerender) {
-        prerenderRoutes.push(name);
-        if (prerenderDefs && entry.prerenderDef) {
-          prerenderDefs[name] = entry.prerenderDef;
-        }
-        if (passthroughRoutes && entry.isPassthrough === true) {
-          passthroughRoutes.push(name);
+    // Collect prerender route names and handler definitions from manifest entries
+    if (prerenderRoutes) {
+      for (const [name, entry] of manifest) {
+        if (entry.type === "route" && entry.isPrerender) {
+          prerenderRoutes.push(name);
+          if (prerenderDefs && entry.prerenderDef) {
+            prerenderDefs[name] = entry.prerenderDef;
+          }
+          if (passthroughRoutes && entry.isPassthrough === true) {
+            passthroughRoutes.push(name);
+          }
         }
       }
     }
-  }
 
-  // Collect response type routes from manifest entries
-  if (responseTypeRoutes) {
-    for (const [name, entry] of manifest) {
-      if (entry.type === "route" && entry.responseType) {
-        responseTypeRoutes[name] = entry.responseType;
+    // Collect response type routes from manifest entries
+    if (responseTypeRoutes) {
+      for (const [name, entry] of manifest) {
+        if (entry.type === "route" && entry.responseType) {
+          responseTypeRoutes[name] = entry.responseType;
+        }
       }
     }
-  }
-
-  const children: Record<string, PrefixTreeNode> = {};
-  mergeIncludeNodes(children, trackedIncludes, (include) =>
-    buildPrefixTreeNode(
-      include.fullPrefix,
-      include.namePrefix,
-      include.patterns as UrlPatterns<any>,
-      routeManifest,
-      routeAncestry,
-      mountIndex,
-      visited,
-      routeTrailingSlash,
-      prerenderRoutes,
-      prerenderDefs,
-      passthroughRoutes,
-      responseTypeRoutes,
-      routeSearchSchemas,
-    ),
-  );
 
-  // Remove from visited so sibling branches can reuse the same patterns
-  // without false circular-include detection. Only ancestors in the current
-  // recursion path should trigger the cycle guard.
-  visited.delete(patterns);
+    const children: Record<string, PrefixTreeNode> = {};
+    await mergeIncludeNodes(children, trackedIncludes, (include) =>
+      buildPrefixTreeNode(
+        include.fullPrefix,
+        include.namePrefix,
+        include.patterns as UrlPatterns<any> | IncludeProvider<any>,
+        routeManifest,
+        routeAncestry,
+        mountIndex,
+        visited,
+        routeTrailingSlash,
+        prerenderRoutes,
+        prerenderDefs,
+        passthroughRoutes,
+        responseTypeRoutes,
+        routeSearchSchemas,
+      ),
+    );
 
-  return {
-    staticPrefix: extractStaticPrefix(urlPrefix),
-    fullPrefix: urlPrefix,
-    namePrefix: namePrefix || undefined,
-    children,
-    routes,
-  };
+    return {
+      staticPrefix: extractStaticPrefix(urlPrefix),
+      fullPrefix: urlPrefix,
+      namePrefix: namePrefix || undefined,
+      children,
+      routes,
+    };
+  } finally {
+    // Remove from visited so sibling branches can reuse the same patterns without
+    // false circular-include detection — and so a throwing handler (caught by the
+    // parent mergeIncludeNodes) does not leak this entry into the shared set.
+    visited.delete(patterns);
+  }
 }
 
 /**
@@ -261,7 +291,8 @@ export interface FullManifest extends GeneratedManifest {
  * import { generateManifest } from "@rangojs/router/build";
  * import { urlpatterns } from "./urls";
  *
- * const manifest = generateManifest(urlpatterns);
+ * // Async: awaits async include() providers (`() => import("./routes")`).
+ * const manifest = await generateManifest(urlpatterns);
  * // Write to file for runtime use
  * fs.writeFileSync(
  *   "src/generated/route-manifest.json",
@@ -269,15 +300,12 @@ export interface FullManifest extends GeneratedManifest {
  * );
  * ```
  */
-export function generateManifest<TEnv>(
+export async function generateManifest<TEnv>(
   urlpatterns: UrlPatterns<TEnv, any>,
   mountIndex: number = 0,
-): GeneratedManifest {
-  const {
-    _routeAncestry: _,
-    _prerenderDefs: __,
-    ...publicManifest
-  } = generateManifestFull(urlpatterns, mountIndex);
+): Promise<GeneratedManifest> {
+  const { _routeAncestry, _prerenderDefs, ...publicManifest } =
+    await generateManifestFull(urlpatterns, mountIndex);
   return publicManifest;
 }
 
@@ -288,7 +316,7 @@ export function generateManifest<TEnv>(
  * @rangojs/router/build), manifest-init (direct import), and trie
  * building. Not intended for external use.
  */
-export function generateManifestFull<TEnv>(
+export async function generateManifestFull<TEnv>(
   urlpatterns: UrlPatterns<TEnv, any>,
   mountIndex: number = 0,
   options?: {
@@ -302,7 +330,7 @@ export function generateManifestFull<TEnv>(
      */
     collectClientFallbackRef?: (refKey: string) => void;
   },
-): FullManifest {
+): Promise<FullManifest> {
   const routeManifest: Record<string, string> = {};
   const routeAncestry: Record<string, string[]> = {};
   const prefixTree: Record<string, PrefixTreeNode> = {};
@@ -356,17 +384,13 @@ export function generateManifestFull<TEnv>(
   }
 
   // Collect root-level routes and trailing slash config
-  const routeTrailingSlash: Record<string, string> = {};
-  for (const [name, pattern] of patternsMap.entries()) {
-    routeManifest[name] = pattern;
-  }
-  for (const [name, mode] of trailingSlashMap.entries()) {
-    routeTrailingSlash[name] = mode;
-  }
-  const routeSearchSchemas: Record<string, Record<string, string>> = {};
-  for (const [name, schema] of searchSchemasMap.entries()) {
-    routeSearchSchemas[name] = schema;
-  }
+  Object.assign(routeManifest, Object.fromEntries(patternsMap));
+  const routeTrailingSlash: Record<string, string> =
+    Object.fromEntries(trailingSlashMap);
+  const routeSearchSchemas: Record<
+    string,
+    Record<string, string>
+  > = Object.fromEntries(searchSchemasMap);
 
   // Capture ancestry from manifest entries' parent chains
   captureAncestry(manifest, routeAncestry);
@@ -393,11 +417,11 @@ export function generateManifestFull<TEnv>(
 
   // Shared visited set for cycle detection across all root-level includes.
   const visited = new Set<unknown>();
-  mergeIncludeNodes(prefixTree, trackedIncludes, (include) =>
+  await mergeIncludeNodes(prefixTree, trackedIncludes, (include) =>
     buildPrefixTreeNode(
       include.fullPrefix,
       include.namePrefix,
-      include.patterns as UrlPatterns<any>,
+      include.patterns as UrlPatterns<any> | IncludeProvider<any>,
       routeManifest,
       routeAncestry,
       mountIndex,
@@ -441,14 +465,14 @@ export function generateManifestFull<TEnv>(
  *
  * @example
  * ```typescript
- * const code = generateManifestCode(urlpatterns);
+ * const code = await generateManifestCode(urlpatterns);
  * fs.writeFileSync("src/generated/route-manifest.ts", code);
  * ```
  */
-export function generateManifestCode<TEnv>(
+export async function generateManifestCode<TEnv>(
   urlpatterns: UrlPatterns<TEnv, any>,
-): string {
-  const manifest = generateManifest(urlpatterns);
+): Promise<string> {
+  const manifest = await generateManifest(urlpatterns);
 
   return `/**
  * Auto-generated route manifest

package/src/build/generate-route-types.ts

@@ -24,7 +24,6 @@ export {
   extractIncludesWithDiagnostics,
 } from "./route-types/include-resolution.js";
 export {
-  extractUrlsVariableFromRouter,
   extractUrlsFromRouter,
   extractBasenameFromRouter,
   type UrlsExtractionResult,
@@ -34,6 +33,7 @@ export {
   findNestedRouterConflict,
   formatNestedRouterConflictError,
   findRouterFiles,
+  findHostRouterFiles,
   writeCombinedRouteTypes,
   genFileTsPath,
   resolveSearchSchemas,