@rangojs/router 0.5.1 → 0.6.0

package/src/urls/include-helper.ts

@@ -11,6 +11,12 @@ import {
 import type { UrlPatterns, IncludeOptions } from "./pattern-types.js";
 import type { IncludeProvider } from "./include-provider.js";
 import type { IncludeFn } from "./path-helper-types.js";
+import {
+  clientUrlIncludePatterns,
+  isClientUrlPatterns,
+  isClientUrlReference,
+} from "../client-urls/server-projection.js";
+import type { ClientUrlPatterns } from "../client-urls/types.js";
 
 function hasExplicitNameOption(options: IncludeOptions | undefined): boolean {
   return !!options && Object.prototype.hasOwnProperty.call(options, "name");
@@ -61,15 +67,27 @@ export function processItems(items: readonly AllUseItems[]): AllUseItems[] {
 export function createIncludeHelper<TEnv>(): IncludeFn<TEnv> {
   return (
     prefix: string,
-    // A `urls()` value (eager) OR an async provider thunk
+    // A `urls()` value (eager), an async provider thunk
     // (`() => import("./routes")`) whose evaluation is deferred to the first
-    // request matching `prefix`. The provider is stored unevaluated and
-    // resolved by the runtime lazy-include expansion / build-time discovery.
-    patterns: UrlPatterns<TEnv> | IncludeProvider<TEnv>,
+    // request matching `prefix`, or a clientUrls() definition (object or
+    // client reference). Providers are stored unevaluated and resolved by the
+    // runtime lazy-include expansion / build-time discovery.
+    patterns: UrlPatterns<TEnv> | IncludeProvider<TEnv> | ClientUrlPatterns,
     options?: IncludeOptions,
   ): IncludeItem => {
     const { ctx } = requireDslContext("include() must be called inside urls()");
 
+    // clientUrls() sources mount through include() like any urls() module.
+    // Detect them FIRST: a client REFERENCE is a callable proxy, so the
+    // downstream provider check (`typeof === "function"`) would otherwise
+    // invoke it as an async include thunk. The substituted handler defers
+    // materialization to evaluation time, when the discovery-installed
+    // projection is available; the include machinery then applies URL and
+    // route-name prefixes exactly as for server modules.
+    if (isClientUrlPatterns(patterns) || isClientUrlReference(patterns)) {
+      patterns = clientUrlIncludePatterns(patterns) as UrlPatterns<TEnv>;
+    }
+
     const explicitName = options?.name;
     const hasExplicitName = hasExplicitNameOption(options);
     if (hasExplicitName && explicitName) {

package/src/urls/path-helper-types.ts

@@ -5,6 +5,7 @@ import type {
   Handler,
   HandlerContext,
   LoaderDefinition,
+  LoaderOptions,
   MiddlewareFn,
   NotFoundBoundaryHandler,
   PartialCacheOptions,
@@ -57,6 +58,7 @@ import type {
   IncludeOptions,
 } from "./pattern-types.js";
 import type { ExtractRoutes, ExtractResponses } from "./type-extraction.js";
+import type { ClientUrlPatterns } from "../client-urls/types.js";
 
 /**
  * Base path function signature for defining routes with URL patterns.
@@ -175,6 +177,11 @@ export type IncludeArg<
   TResponses extends Record<string, unknown>,
 > =
   | UrlPatterns<TEnv, TRoutes, TResponses>
+  // clientUrls() definitions mount through include() like any urls() module;
+  // on the server the runtime value is the module's client reference, but the
+  // TypeScript type of that default export IS ClientUrlPatterns, so route
+  // names flow into NamedRoutes through the same TRoutes inference.
+  | ClientUrlPatterns<TRoutes>
   | (() =>
       | IncludeResolved<TEnv, TRoutes, TResponses>
       | Promise<IncludeResolved<TEnv, TRoutes, TResponses>>);
@@ -338,10 +345,16 @@ export type PathHelpers<TEnv> = {
   revalidate: (fn: ShouldRevalidateFn<any, TEnv>) => RevalidateItem;
 
   /**
-   * Attach a data loader to the current route/layout
+   * Attach a data loader to the current route/layout.
+   *
+   * Pass `{ stream: "navigation" }` to await this loader before first flush
+   * on DOCUMENT requests (see {@link LoaderOptions}) — the opt-in for loaders
+   * whose data, handle pushes, or thrown notFound()/redirect() must be in the
+   * SSR'd HTML. Per-loader: a dynamic sibling keeps streaming.
    */
   loader: <TData>(
     loaderDef: LoaderDefinition<TData>,
+    optionsOrUse?: LoaderOptions | (() => LoaderUseItem[]),
     use?: () => LoaderUseItem[],
   ) => LoaderItem;
 

package/src/use-loader.tsx

@@ -3,6 +3,7 @@
 import {
   isValidElement,
   startTransition,
+  use,
   useCallback,
   useContext,
   useEffect,
@@ -13,6 +14,7 @@ import {
 } from "react";
 import { OutletContext, type OutletContextValue } from "./outlet-context.js";
 import { loaderStore, type LoaderEntry } from "./loader-store.js";
+import { decodeLoaderEntry } from "./decode-loader-results.js";
 import type { LoaderDefinition, LoadOptions } from "./types.js";
 
 function isShareableGet(options: LoadOptions | undefined): boolean {
@@ -34,19 +36,47 @@ let privateGroupBucketSeq = 0;
 
 const NOT_FOUND = Symbol("not-found");
 
+/**
+ * SPIKE (streaming useLoader): lookup results distinguish a synchronously
+ * available value from a still-streaming per-loader promise. A pending stream
+ * is `use()`d at the read site (implicit suspension); the promise identity is
+ * stable per commit (it comes from the provider's memoized context value /
+ * element props), which use() requires across replays.
+ */
+type LoaderLookup =
+  | typeof NOT_FOUND
+  | { value: unknown }
+  | { stream: Promise<unknown> };
+
+function lookupLoaderStreams(
+  loaderStreams: Record<string, unknown> | undefined,
+  loaderId: string,
+): LoaderLookup {
+  if (!loaderStreams || !(loaderId in loaderStreams)) return NOT_FOUND;
+  const entry = loaderStreams[loaderId];
+  // Within the loaderStreams channel a Promise always means "still streaming";
+  // settled entries are undecoded result values, never promises.
+  return entry instanceof Promise
+    ? { stream: entry }
+    : { value: decodeLoaderEntry(entry) };
+}
+
 function extractContentLoaderData(
   node: ReactNode,
   loaderId: string,
-): unknown | typeof NOT_FOUND {
+): LoaderLookup {
   if (!isValidElement(node)) return NOT_FOUND;
   const props = node.props as Record<string, any> | undefined;
   if (!props) return NOT_FOUND;
 
   // Direct OutletProvider with loaderData
   if (props.loaderData && loaderId in props.loaderData) {
-    return props.loaderData[loaderId];
+    return { value: props.loaderData[loaderId] };
   }
 
+  const streamed = lookupLoaderStreams(props.loaderStreams, loaderId);
+  if (streamed !== NOT_FOUND) return streamed;
+
   if (
     props.loaderIds &&
     Array.isArray(props.loaderIds) &&
@@ -57,9 +87,9 @@ function extractContentLoaderData(
     if (idx !== -1) {
       const data = (props.loaderDataPromise as any[])[idx];
       if (data && typeof data === "object" && "ok" in data) {
-        return data.ok ? data.data : NOT_FOUND;
+        return data.ok ? { value: data.data } : NOT_FOUND;
       }
-      return data;
+      return { value: data };
     }
   }
 
@@ -102,9 +132,10 @@ function useLoaderInternal<T>(
 ): UseFetchLoaderResult<T> {
   const context = useContext(OutletContext);
 
-  const { contextData, hasContextData } = useMemo((): {
+  const walk = useMemo((): {
     contextData: T | undefined;
     hasContextData: boolean;
+    pendingStream?: Promise<unknown>;
   } => {
     let current: OutletContextValue | null | undefined = context;
     while (current) {
@@ -114,18 +145,48 @@ function useLoaderInternal<T>(
           hasContextData: true,
         };
       }
+      const streamed = lookupLoaderStreams(current.loaderStreams, loader.$$id);
+      if (streamed !== NOT_FOUND) {
+        if ("stream" in streamed) {
+          return {
+            contextData: undefined,
+            hasContextData: true,
+            pendingStream: streamed.stream,
+          };
+        }
+        return { contextData: streamed.value as T, hasContextData: true };
+      }
       const contentData = extractContentLoaderData(
         current.content,
         loader.$$id,
       );
       if (contentData !== NOT_FOUND) {
-        return { contextData: contentData as T, hasContextData: true };
+        if ("stream" in contentData) {
+          return {
+            contextData: undefined,
+            hasContextData: true,
+            pendingStream: contentData.stream,
+          };
+        }
+        return { contextData: contentData.value as T, hasContextData: true };
       }
       current = current.parent;
     }
     return { contextData: undefined, hasContextData: false };
   }, [context, loader.$$id]);
 
+  // SPIKE (streaming useLoader): a pending per-loader stream suspends HERE —
+  // the implicit-suspense read. use() is exempt from hook-order rules, so the
+  // conditional call is legal; on replay after resolution it returns
+  // synchronously and the decoded value takes the contextData slot. Hooks
+  // below never run in a suspended render, so their order is stable across
+  // every COMPLETED render.
+  const { hasContextData } = walk;
+  let contextData = walk.contextData;
+  if (walk.pendingStream) {
+    contextData = decodeLoaderEntry(use(walk.pendingStream)) as T;
+  }
+
   const loaderId = loader.$$id;
   const key = options?.key;
   const refreshGroupOption = options?.refreshGroup;

package/src/vite/discovery/client-urls-projection.ts

@@ -0,0 +1,322 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { normalizePath, parseAst } from "vite";
+import {
+  serializeClientUrlPatterns,
+  type ClientUrlProjection,
+} from "../../client-urls/server-projection.js";
+import type { ClientUrlPatterns } from "../../client-urls/types.js";
+import {
+  computeProductionHash,
+  hashRefKey,
+} from "../plugins/client-ref-hashing.js";
+import { hasUseClientDirective } from "../utils/directive-prologue.js";
+import { createRangoDebugger, NS } from "../debug.js";
+import { findTsFiles } from "../../build/route-types/scan-filter.js";
+import type { DiscoveryState } from "./state.js";
+
+const debug = createRangoDebugger(NS.discovery);
+
+interface ClientUrlSsrEnvironment {
+  readonly runner?: {
+    import(id: string): Promise<Record<string, unknown>>;
+  };
+}
+
+interface ClientUrlProjectionServerModule {
+  clearClientUrlProjections(): void;
+  setClientUrlProjection(
+    referenceId: string,
+    projection: ClientUrlProjection,
+  ): void;
+}
+
+function hasDefaultExport(code: string): boolean {
+  let program: { body?: any[] };
+  try {
+    program = parseAst(code, { lang: "tsx" }) as { body?: any[] };
+  } catch {
+    return false;
+  }
+
+  for (const node of program.body ?? []) {
+    if (node?.type === "ExportDefaultDeclaration") return true;
+    if (node?.type !== "ExportNamedDeclaration") continue;
+    for (const specifier of node.specifiers ?? []) {
+      const exportedName =
+        specifier?.exported?.name ?? specifier?.exported?.value;
+      if (exportedName === "default") return true;
+    }
+  }
+  return false;
+}
+
+function normalizeSource(state: DiscoveryState, id: string): string {
+  const cleanId = id.split("?", 1)[0];
+  const absoluteId = isAbsolute(cleanId)
+    ? cleanId
+    : resolve(state.projectRoot, cleanId);
+  return normalizePath(absoluteId);
+}
+
+function referenceId(referenceKey: string): string {
+  return `${referenceKey}#default`;
+}
+
+function withoutReferenceQuery(reference: string): string {
+  const exportIndex = reference.lastIndexOf("#");
+  const moduleId =
+    exportIndex === -1 ? reference : reference.slice(0, exportIndex);
+  const exportName = exportIndex === -1 ? "" : reference.slice(exportIndex);
+  const queryIndex = moduleId.indexOf("?");
+  return `${queryIndex === -1 ? moduleId : moduleId.slice(0, queryIndex)}${exportName}`;
+}
+
+export function recordClientUrlsModule(
+  state: DiscoveryState,
+  code: string,
+  id: string,
+): void {
+  if (
+    !code.includes("clientUrls(") ||
+    !hasUseClientDirective(code) ||
+    !hasDefaultExport(code)
+  ) {
+    return;
+  }
+
+  const source = normalizeSource(state, id);
+  const projectRoot = normalizePath(resolve(state.projectRoot));
+  const relativeId = normalizePath(relative(projectRoot, source));
+  const outsideProject =
+    relativeId === ".." ||
+    relativeId.startsWith("../") ||
+    isAbsolute(relativeId);
+  const devReferenceKey = outsideProject ? `/@fs${source}` : `/${relativeId}`;
+
+  const sourceByReferenceId = (state.clientUrlSourceByReferenceId ??=
+    new Map());
+  sourceByReferenceId.set(referenceId(devReferenceKey), source);
+
+  const productionReferenceKeys = new Set([
+    hashRefKey(relativeId),
+    computeProductionHash(projectRoot, devReferenceKey),
+  ]);
+  for (const productionReferenceKey of productionReferenceKeys) {
+    sourceByReferenceId.set(referenceId(productionReferenceKey), source);
+  }
+}
+
+export function resolveClientUrlsSource(
+  state: DiscoveryState,
+  referenceId: string,
+): string | undefined {
+  return state.clientUrlSourceByReferenceId?.get(
+    withoutReferenceQuery(referenceId),
+  );
+}
+
+/**
+ * Deterministic filesystem discovery of clientUrls modules. Transform-based
+ * recording only sees modules that some environment actually loads — a
+ * clientUrls module not yet reachable from any transformed graph at discovery
+ * time (cold ordering, a mount added before its first import is served) would
+ * never be recorded and its include would fail with empty projections. Walking
+ * the project source (the same walk static route-type generation performs)
+ * makes recording independent of module-graph timing. The transform hooks
+ * still record too — they refresh dev HMR edits between scans.
+ */
+export function scanForClientUrlModules(state: DiscoveryState): void {
+  if (!state.projectRoot) return;
+  for (const filePath of findTsFiles(state.projectRoot, state.scanFilter)) {
+    let code: string;
+    try {
+      code = readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    recordClientUrlsModule(state, code, filePath);
+  }
+}
+
+function projectionError(
+  referenceId: string,
+  source: string | undefined,
+  message: string,
+  cause?: unknown,
+): Error {
+  const sourceDescription = source ? ` from source "${source}"` : "";
+  const errorMessage = `Cannot discover client URL projection for reference "${referenceId}"${sourceDescription}: ${message}`;
+  return cause === undefined
+    ? new Error(errorMessage)
+    : new Error(errorMessage, { cause });
+}
+
+/**
+ * Lenient pre-entry projection refresh. Re-serializes every RECORDED clientUrls
+ * module before the discovery pass imports the entry, so routers re-created by
+ * that import materialize against the CURRENT module contents.
+ *
+ * Scar: node-preset HMR served stale client-urls routes after a route-shape
+ * edit — the clientUrls module is an HMR-accepted client boundary in the rsc
+ * graph, and the strict registry-driven pass below only runs AFTER the entry
+ * import, so `.routes(reference)` materialized the previous pass's projection.
+ *
+ * Errors are deliberately swallowed per source (a module mid-edit keeps its
+ * last-known projection); the strict discoverClientUrlProjections() pass still
+ * surfaces real failures afterwards. No-ops on cold start (nothing recorded
+ * yet) and when the SSR runner is unavailable.
+ */
+export async function refreshRecordedClientUrlProjections(
+  state: DiscoveryState,
+  ssrEnv: ClientUrlSsrEnvironment | undefined,
+  serverMod: ClientUrlProjectionServerModule,
+): Promise<void> {
+  const sourceByReferenceId = state.clientUrlSourceByReferenceId;
+  if (
+    !sourceByReferenceId?.size ||
+    typeof ssrEnv?.runner?.import !== "function"
+  ) {
+    return;
+  }
+
+  const referenceIdsBySource = new Map<string, string[]>();
+  for (const [refId, source] of sourceByReferenceId) {
+    const ids = referenceIdsBySource.get(source);
+    if (ids) {
+      ids.push(refId);
+    } else {
+      referenceIdsBySource.set(source, [refId]);
+    }
+  }
+
+  for (const [source, referenceIds] of referenceIdsBySource) {
+    let definition: unknown;
+    try {
+      definition = (await ssrEnv.runner.import(source)).default;
+    } catch {
+      continue;
+    }
+    if (
+      (typeof definition !== "object" && typeof definition !== "function") ||
+      definition === null ||
+      (definition as { __brand?: unknown }).__brand !== "client-urls"
+    ) {
+      continue;
+    }
+    const projection = serializeClientUrlPatterns(
+      definition as ClientUrlPatterns,
+    );
+    debug?.(
+      "pre-entry refresh %s -> [%s]",
+      source,
+      projection.routes.map((route) => route.pattern).join(", "),
+    );
+    for (const referenceId of referenceIds) {
+      serverMod.setClientUrlProjection(referenceId, projection);
+      // The eager routes-manifest virtual module REPLAYS this state map
+      // (clearClientUrlProjections + set) whenever it re-evaluates — and the
+      // watcher's gen-file write invalidates it right before the entry import,
+      // so a stale map here would clobber the registry install above before
+      // the router materializes its mount. Keep both in sync.
+      state.clientUrlProjectionMap?.set(referenceId, projection);
+    }
+  }
+}
+
+/**
+ * Strict projection discovery over every RECORDED clientUrls module. Recorded
+ * modules — not router references — are the source of truth: include() mounts
+ * materialize lazily from the projection registry, so there is no router-level
+ * reference list to consult. Serializes every source before atomically
+ * installing the new projections (a failure preserves last-known state).
+ *
+ * A recorded source whose file no longer exists is dropped silently
+ * (recordClientUrlsModule never un-records, so deletions must self-heal here).
+ * A present-but-broken module is a hard error: it is part of the app graph.
+ */
+export async function discoverClientUrlProjections(
+  state: DiscoveryState,
+  ssrEnv: ClientUrlSsrEnvironment | undefined,
+  serverMod: ClientUrlProjectionServerModule,
+): Promise<void> {
+  scanForClientUrlModules(state);
+  const sourceByReferenceId = state.clientUrlSourceByReferenceId;
+  if (!sourceByReferenceId?.size) {
+    serverMod.clearClientUrlProjections();
+    state.clientUrlProjectionMap = new Map();
+    return;
+  }
+
+  const referenceIdsBySource = new Map<string, string[]>();
+  for (const [referenceId, source] of sourceByReferenceId) {
+    const ids = referenceIdsBySource.get(source);
+    if (ids) {
+      ids.push(referenceId);
+    } else {
+      referenceIdsBySource.set(source, [referenceId]);
+    }
+  }
+
+  if (typeof ssrEnv?.runner?.import !== "function") {
+    const [source, ids] = referenceIdsBySource.entries().next().value as [
+      string,
+      string[],
+    ];
+    throw projectionError(
+      ids[0],
+      source,
+      "the SSR module runner is unavailable",
+    );
+  }
+
+  const nextProjections = new Map<string, ClientUrlProjection>();
+  const removedSources: string[] = [];
+  for (const [source, referenceIds] of referenceIdsBySource) {
+    let module: Record<string, unknown>;
+    try {
+      module = await ssrEnv.runner.import(source);
+    } catch (cause) {
+      if (!existsSync(source)) {
+        removedSources.push(source);
+        continue;
+      }
+      throw projectionError(
+        referenceIds[0],
+        source,
+        "failed to import the source module",
+        cause,
+      );
+    }
+    const definition = module.default;
+    if (
+      (typeof definition !== "object" && typeof definition !== "function") ||
+      definition === null ||
+      (definition as { __brand?: unknown }).__brand !== "client-urls"
+    ) {
+      throw projectionError(
+        referenceIds[0],
+        source,
+        'the module default export must be created by clientUrls() and have __brand === "client-urls"',
+      );
+    }
+    const projection = serializeClientUrlPatterns(
+      definition as ClientUrlPatterns,
+    );
+    for (const referenceId of referenceIds) {
+      nextProjections.set(referenceId, projection);
+    }
+  }
+
+  for (const source of removedSources) {
+    for (const [referenceId, recorded] of sourceByReferenceId) {
+      if (recorded === source) sourceByReferenceId.delete(referenceId);
+    }
+  }
+
+  serverMod.clearClientUrlProjections();
+  for (const [id, projection] of nextProjections) {
+    serverMod.setClientUrlProjection(id, projection);
+  }
+  state.clientUrlProjectionMap = nextProjections;
+}

package/src/vite/discovery/discover-routers.ts

@@ -21,6 +21,7 @@ import {
 // RangoContext from the runner realm) — see the runner.import below.
 import { buildPerRouterTrie } from "../../build/route-trie.js";
 import { collectFallbackClientRefs } from "../../build/collect-fallback-refs.js";
+import { mergeFullManifests } from "../../build/merge-full-manifests.js";
 import { flattenLeafEntries } from "../utils/manifest-utils.js";
 import type { DiscoveryState, PrecomputedEntry } from "./state.js";
 import {
@@ -34,6 +35,10 @@ import {
 } from "./discovery-errors.js";
 import { createRangoDebugger, timed, NS } from "../debug.js";
 import { computeProductionHash } from "../plugins/client-ref-hashing.js";
+import {
+  discoverClientUrlProjections,
+  refreshRecordedClientUrlProjections,
+} from "./client-urls-projection.js";
 
 const debug = createRangoDebugger(NS.discovery);
 
@@ -48,9 +53,25 @@ const debug = createRangoDebugger(NS.discovery);
 export async function discoverRouters(
   state: DiscoveryState,
   rscEnv: any,
+  ssrEnv?: any,
 ): Promise<any> {
   if (!state.resolvedEntryPath) return;
 
+  // Import the router package FIRST (leaf module, no side effects on user
+  // code) so recorded clientUrls projections can be refreshed BEFORE the entry
+  // import: routers re-created by that import call `.routes(reference)` at
+  // module scope and materialize whatever projection is installed at that
+  // moment. On HMR re-discovery that must be the CURRENT module contents, not
+  // the previous pass's snapshot (see refreshRecordedClientUrlProjections).
+  const serverMod = await timed(
+    debug,
+    "inner: import @rangojs/router/server",
+    () => rscEnv.runner.import("@rangojs/router/server"),
+  );
+  await timed(debug, "inner: refresh recorded client URL projections", () =>
+    refreshRecordedClientUrlProjections(state, ssrEnv, serverMod),
+  );
+
   // Import the entry file via RSC environment.
   // For node preset: this is the router file (createRouter() registers in RouterRegistry).
   // For cloudflare preset: this is the worker entry (which imports the router).
@@ -58,12 +79,6 @@ export async function discoverRouters(
     rscEnv.runner.import(state.resolvedEntryPath),
   );
 
-  // Import the router package to access the registry
-  const serverMod = await timed(
-    debug,
-    "inner: import @rangojs/router/server",
-    () => rscEnv.runner.import("@rangojs/router/server"),
-  );
   let registry: Map<string, any> = serverMod.RouterRegistry;
 
   if (!registry || registry.size === 0) {
@@ -114,6 +129,10 @@ export async function discoverRouters(
     }
   }
 
+  await timed(debug, "inner: discover client URL projections", () =>
+    discoverClientUrlProjections(state, ssrEnv, serverMod),
+  );
+
   // generateManifestFull must run in the RSC runner realm: it invokes the
   // user's urlpatterns.handler() via RangoContext, consuming router instances
   // from the runner. The trie/fallback-ref builders are pure transforms over
@@ -176,20 +195,27 @@ export async function discoverRouters(
 
   const manifestGenStart = debug ? performance.now() : 0;
   for (const [id, router] of registry) {
-    if (!router.urlpatterns || !generateManifestFull) {
+    if (!generateManifestFull) {
       continue;
     }
 
-    const manifest = await generateManifestFull(
-      router.urlpatterns,
-      routerMountIndex,
-      {
-        routerId: id,
-        ...(router.__basename ? { urlPrefix: router.__basename } : {}),
-        ...(collectClientFallbackRef ? { collectClientFallbackRef } : {}),
-      },
-    );
-    routerMountIndex++;
+    const mounts =
+      router.__urlpatternMounts ??
+      (router.urlpatterns ? [{ patterns: router.urlpatterns }] : []);
+    if (mounts.length === 0) continue;
+
+    const mountManifests = [];
+    for (const mount of mounts) {
+      mountManifests.push(
+        await generateManifestFull(mount.patterns, routerMountIndex, {
+          routerId: id,
+          ...(router.__basename ? { urlPrefix: router.__basename } : {}),
+          ...(collectClientFallbackRef ? { collectClientFallbackRef } : {}),
+        }),
+      );
+      routerMountIndex++;
+    }
+    const manifest = mergeFullManifests(mountManifests);
     allManifests.push({ id, manifest });
 
     // Router-level "use client" boundary defaults -> app-fallback (the