@rangojs/router 0.24.4 → 0.25.0

package/src/router/intercept-resolution.ts

@@ -16,11 +16,6 @@ import type {
   InternalHandlerContext,
   ResolvedSegment,
 } from "../types";
-import { evaluateRevalidation } from "./revalidation.js";
-import { getRequestContext } from "../server/request-context.js";
-import { executeInterceptMiddleware } from "./middleware.js";
-import { createReverseFunction } from "./handler-context.js";
-import { getGlobalRouteMap } from "../route-map-builder.js";
 import {
   handleHandlerResult,
   warnOnStreamedResponse,
@@ -29,15 +24,21 @@ import {
 import { catchSegmentError } from "./segment-resolution/helpers.js";
 import { trackStreamedHandler } from "./segment-resolution/streamed-handler-boundary.js";
 import { findInOrphans } from "./error-handling.js";
-import { resolveLoaderData } from "./segment-resolution/loader-cache.js";
+import {
+  deliverStartedLoaders,
+  resolveOwnerLoaders,
+} from "./segment-resolution/revalidation.js";
+import {
+  fillSends,
+  NOTHING_HELD,
+} from "./segment-resolution/prefetch-deferral.js";
 import type { SegmentResolutionDeps } from "./types.js";
-import { debugLog } from "./logging.js";
 import { getRouterContext } from "./router-context.js";
+import type { RevalidationContext } from "./router-context.js";
 import { runInSegmentTagScope } from "../cache/cache-tag.js";
 import {
   RangoContext,
   latchPprHeaderScopeForEntries,
-  runInsideLoaderScope,
 } from "../server/context.js";
 
 /**
@@ -48,7 +49,6 @@ import {
  * intercept over a ppr-declared target route, in its own store scope where
  * the main funnel's latch does not apply. Latch by declaration, off the
  * target route's manifest entry (same leaf input as the segment funnels).
- * Called AFTER intercept middleware runs — middleware stays the live lane.
  */
 function latchPprHeaderScopeForInterceptTarget(
   interceptEntry: InterceptEntry,
@@ -172,7 +172,7 @@ export function findInterceptForRoute(
  * An intercept handler's throw or notFound() renders the declaring entry's
  * boundary as the slot component (catchSegmentError, as for route handlers on
  * partial navigations: 500/404 status, onError "handler"). Responses and every
- * error on the background re-render (skipMiddleware) rethrow, so a failed
+ * error on the background re-render (`background`) rethrow, so a failed
  * re-render aborts its cache write instead of storing the fallback.
  */
 function renderInterceptHandlerError<TEnv>(
@@ -181,9 +181,9 @@ function renderInterceptHandlerError<TEnv>(
   params: Record<string, string>,
   context: HandlerContext<any, TEnv>,
   deps: SegmentResolutionDeps<TEnv>,
-  skipMiddleware: boolean | undefined,
+  background: boolean | undefined,
 ): ReactNode {
-  if (error instanceof Response || skipMiddleware) throw error;
+  if (error instanceof Response || background) throw error;
   return catchSegmentError(
     error,
     parentEntry,
@@ -198,8 +198,80 @@ function renderInterceptHandlerError<TEnv>(
   ).component;
 }
 
+/** The segment id of `intercept`'s slot on `parentEntry`. */
+export function interceptSlotId(
+  parentEntry: EntryData,
+  intercept: InterceptEntry,
+): string {
+  return `${parentEntry.shortCode}.${intercept.slotName}`;
+}
+
+/**
+ * Every segment id an intercept's slot owns, in order: the slot, then one
+ * loader segment per loader in declaration order, run or not. A request that
+ * resolves the intercept lists them in `matched` (match-result.ts).
+ */
+export function interceptSegmentIds(
+  parentEntry: EntryData,
+  intercept: InterceptEntry,
+): string[] {
+  const slotId = interceptSlotId(parentEntry, intercept);
+  return [
+    slotId,
+    ...intercept.loader.map((l, i) => `${slotId}D${i}.${l.loader.$$id}`),
+  ];
+}
+
+/**
+ * An intercept's loaders are loader segments of its slot, resolved through
+ * the partial lane's funnel (revalidation.ts resolveOwnerLoaders): each one
+ * revalidated on its own, kept in a fill, deferred by a prefetch when flagged.
+ */
+function resolveInterceptLoaders<TEnv>(
+  interceptEntry: InterceptEntry,
+  parentEntry: EntryData,
+  context: HandlerContext<any, TEnv>,
+  belongsToRoute: boolean,
+  deps: SegmentResolutionDeps<TEnv>,
+  rc: RevalidationContext,
+): Promise<{ segments: ResolvedSegment[] }> {
+  return resolveOwnerLoaders(
+    {
+      loaders: interceptEntry.loader,
+      namespace: `intercept:${interceptEntry.routeName}`,
+      segmentPrefix: interceptSlotId(parentEntry, interceptEntry),
+      boundary: parentEntry,
+      bakeLane: false,
+      traceSource: "intercept-loader",
+    },
+    context,
+    belongsToRoute,
+    rc.clientSegmentIds,
+    rc.prevParams,
+    rc.request,
+    rc.prevUrl,
+    rc.nextUrl,
+    rc.routeKey,
+    deps,
+    rc.actionContext,
+    rc.stale,
+  );
+}
+
 /**
- * Resolve an intercept entry and emit segment with the slot name.
+ * An intercept slot with no loading() waits for its loaders that are not
+ * deferred; the browser's side is foldInterceptLoaders (segment-system.tsx).
+ */
+async function settleLoaderSegments(
+  segments: readonly ResolvedSegment[],
+): Promise<void> {
+  await Promise.all(
+    segments.filter((s) => !s.deferred).map((s) => s.loaderData),
+  );
+}
+
+/**
+ * Resolve an intercept entry: its slot segment, then its loader segments.
  */
 export async function resolveInterceptEntry<TEnv>(
   interceptEntry: InterceptEntry,
@@ -208,150 +280,68 @@ export async function resolveInterceptEntry<TEnv>(
   context: HandlerContext<any, TEnv>,
   belongsToRoute: boolean,
   deps: SegmentResolutionDeps<TEnv>,
-  revalidationContext?: {
-    clientSegmentIds: Set<string>;
-    prevParams: Record<string, string>;
-    request: Request;
-    prevUrl: URL;
-    nextUrl: URL;
-    routeKey: string;
-    actionContext?: {
-      actionId?: string;
-      actionUrl?: URL;
-      actionResult?: any;
-      formData?: FormData;
-    };
-    stale?: boolean;
+  // The background re-render passes none: nothing held, rendered fresh.
+  revalidationContext: RevalidationContext = {
+    clientSegmentIds: NOTHING_HELD,
+    prevParams: {},
+    request: context.request,
+    prevUrl: context.url,
+    nextUrl: context.url,
+    routeKey: interceptEntry.routeName,
   },
   options?: {
     /**
-     * Skip the intercept's middleware execution. Set ONLY by the post-response
-     * background re-render paths (proactive caching, stale background
+     * Set ONLY by the post-response background re-render (stale background
      * revalidation), whose sole purpose is to re-render the segment tree to
-     * populate the cache. The foreground request already ran the intercept
-     * middleware before the response was sent — it validated auth, set cookies,
-     * and wrote context vars into the request context's shared `_variables`,
-     * which the background render reuses. Re-running middleware here would fire
-     * its side effects a SECOND time, and a middleware that short-circuits with
-     * a Response would `throw` and silently abort the cache write. Never set on
-     * the foreground path.
+     * populate the cache: a handler error rejects instead of rendering the
+     * error boundary, so a failure is never cached. Never set on the
+     * foreground path.
      */
-    skipMiddleware?: boolean;
+    background?: boolean;
   },
 ): Promise<ResolvedSegment[]> {
-  const segments: ResolvedSegment[] = [];
-
-  if (!options?.skipMiddleware && interceptEntry.middleware.length > 0) {
-    const requestCtx = getRequestContext();
-    if (!requestCtx?.res) {
-      throw new Error(
-        "Request context with stubResponse is required for intercept middleware",
-      );
-    }
-    const middlewareResponse = await executeInterceptMiddleware(
-      interceptEntry.middleware,
-      context.request,
-      context.env,
-      params,
-      (context as InternalHandlerContext<any, TEnv>)._variables,
-      requestCtx.res,
-      createReverseFunction(getGlobalRouteMap()),
-    );
-    if (middlewareResponse) throw middlewareResponse;
-  }
-
   latchPprHeaderScopeForInterceptTarget(interceptEntry);
 
-  // The intercept segment's id: the tag scope its handler and layout record in
-  // (#957, cache-tag.ts runInSegmentTagScope) and the owner of its handler's
-  // and loaders' handle pushes, pinned before the loader kickoffs as
-  // fresh.ts/revalidation.ts pin theirs (createLoaderExecutor captures it at
-  // kickoff; a handler's ctx.use(Handle) reads it when called).
-  const slotSegmentId = `${parentEntry.shortCode}.${interceptEntry.slotName}`;
+  const slotSegmentId = interceptSlotId(parentEntry, interceptEntry);
+  const { segments: loaderSegments } = await resolveInterceptLoaders(
+    interceptEntry,
+    parentEntry,
+    context,
+    belongsToRoute,
+    deps,
+    revalidationContext,
+  );
+  // The slot's tag scope (#957, cache-tag.ts runInSegmentTagScope) and the
+  // owner of its handler's handle pushes (a handler's ctx.use(Handle) reads
+  // it when called).
   (context as InternalHandlerContext<any, TEnv>)._currentSegmentId =
     slotSegmentId;
-  const hasLoaders = interceptEntry.loader.length > 0;
-
-  const loaderPromises: Promise<any>[] = [];
-  const loaderIds: string[] = [];
-
-  for (let i = 0; i < interceptEntry.loader.length; i++) {
-    const loaderEntry = interceptEntry.loader[i];
-    const { loader, revalidate: loaderRevalidateFns } = loaderEntry;
-    const segmentId = `${slotSegmentId}D${i}.${loader.$$id}`;
-
-    if (revalidationContext) {
-      const {
-        clientSegmentIds,
-        prevParams,
-        request,
-        prevUrl,
-        nextUrl,
-        routeKey,
-        actionContext,
-        stale,
-      } = revalidationContext;
-
-      if (clientSegmentIds.has(slotSegmentId)) {
-        const dummySegment: ResolvedSegment = {
-          id: segmentId,
-          namespace: `intercept:${interceptEntry.routeName}`,
-          type: "loader",
-          index: i,
-          component: null,
-          params,
-          loaderId: loader.$$id,
-          belongsToRoute,
-        };
-
-        const shouldRevalidate = await evaluateRevalidation({
-          segment: dummySegment,
-          prevParams,
-          getPrevSegment: null,
-          request,
-          prevUrl,
-          nextUrl,
-          revalidations: loaderRevalidateFns.map((fn, j) => ({
-            name: `intercept-loader-revalidate${j}`,
-            fn,
-          })),
-          routeKey,
-          context,
-          actionContext,
-          stale,
-          traceSource: "intercept-loader",
-        });
-
-        if (!shouldRevalidate) {
-          debugLog("intercept.loader", "skipped revalidation", {
-            loaderId: loader.$$id,
-          });
-          continue;
-        }
-        debugLog("intercept.loader", "revalidating", {
-          loaderId: loader.$$id,
-          stale,
-        });
-      }
-    }
 
-    loaderIds.push(loader.$$id);
-    loaderPromises.push(
-      deps.wrapLoaderPromise(
-        // The DSL binding's funnel, as for route loaders: a loader's own
-        // cache() applies here too.
-        runInsideLoaderScope(
-          () => resolveLoaderData(loaderEntry, context, context.pathname),
-          loader.$$id,
-        ),
-        parentEntry,
-        segmentId,
-        context.pathname,
-        // Report a throwing intercept loader to onError + loader.error telemetry,
-        // matching the fresh/revalidation paths.
-        buildLoaderErrorContext(context),
-      ),
-    );
+  const slotSegment = (
+    component: ReactNode,
+    layout: ReactNode | undefined,
+  ): ResolvedSegment => ({
+    id: slotSegmentId,
+    namespace: `intercept:${interceptEntry.routeName}`,
+    type: "parallel",
+    index: 0,
+    component,
+    loading: interceptEntry.loading === false ? null : interceptEntry.loading,
+    layout,
+    params,
+    slot: interceptEntry.slotName,
+    belongsToRoute,
+    parallelName: `intercept:${interceptEntry.routeName}.${interceptEntry.slotName}`,
+  });
+
+  // A fill keeps a slot the client holds: neither its handler nor its layout
+  // runs, only the loaders the client lacks (match-result.ts leaves the null
+  // slot out of the response).
+  if (
+    fillSends(context, slotSegmentId, revalidationContext.clientSegmentIds) ===
+    false
+  ) {
+    return [slotSegment(null, undefined), ...loaderSegments];
   }
 
   let handlerResult: ReactNode;
@@ -370,7 +360,7 @@ export async function resolveInterceptEntry<TEnv>(
       params,
       context,
       deps,
-      options?.skipMiddleware,
+      options?.background,
     );
   }
   // Consumed only after the layout and loader awaits below; a rejection in that
@@ -397,11 +387,10 @@ export async function resolveInterceptEntry<TEnv>(
   }
 
   let component: ReactNode;
-  let loaderDataPromise: Promise<any[]> | any[] | undefined;
   // A streamed (loading()) handler resolves after the 200 has started: tracked
   // like route handlers (onError report, handle-store completion) and
-  // recovered into the declared boundary, except on the skipMiddleware
-  // background re-render, which must reject so a failure is never cached.
+  // recovered into the declared boundary, except on the background
+  // re-render, which must reject so a failure is never cached.
   const streamedComponent = (promise: Promise<unknown>): ReactNode =>
     trackStreamedHandler(deps, promise, {
       boundaryEntry: parentEntry,
@@ -410,10 +399,10 @@ export async function resolveInterceptEntry<TEnv>(
       context,
       routeKey: interceptEntry.routeName,
       params,
-      recover: !options?.skipMiddleware,
+      recover: !options?.background,
     });
 
-  if (interceptEntry.loading && loaderPromises.length > 0) {
+  if (interceptEntry.loading && loaderSegments.length > 0) {
     if (handlerResult instanceof Promise) {
       warnOnStreamedResponse(
         handlerResult,
@@ -424,13 +413,10 @@ export async function resolveInterceptEntry<TEnv>(
       handlerResult instanceof Promise
         ? streamedComponent(handlerResult)
         : (Promise.resolve(handlerResult) as ReactNode);
-    loaderDataPromise = Promise.all(loaderPromises);
   } else if (interceptEntry.loading && handlerResult instanceof Promise) {
     component = streamedComponent(handlerResult);
   } else {
-    if (loaderPromises.length > 0) {
-      loaderDataPromise = await Promise.all(loaderPromises);
-    }
+    if (!interceptEntry.loading) await settleLoaderSegments(loaderSegments);
     component = handlerResult;
     if (handlerResult instanceof Promise) {
       try {
@@ -442,172 +428,40 @@ export async function resolveInterceptEntry<TEnv>(
           params,
           context,
           deps,
-          options?.skipMiddleware,
+          options?.background,
         );
       }
     }
   }
+  // After the handler is awaited, or at once when it streams: the loaders it
+  // started with ctx.use() by now are delivered from this response.
+  deliverStartedLoaders(context, loaderSegments);
 
-  // The aggregate lists the loaders that ran; empty, not absent, when the
-  // client holds the slot and all skipped. Absent replaces the client's
-  // aggregate, empty merges into it (merge-segment-loaders.ts).
-  if (hasLoaders && loaderPromises.length === 0) {
-    loaderDataPromise = [];
-  }
-
-  const interceptSegment = {
-    id: slotSegmentId,
-    namespace: `intercept:${interceptEntry.routeName}`,
-    type: "parallel" as const,
-    index: 0,
-    component,
-    loading: interceptEntry.loading === false ? null : interceptEntry.loading,
-    layout: layoutElement,
-    params,
-    slot: interceptEntry.slotName,
-    belongsToRoute,
-    parallelName: `intercept:${interceptEntry.routeName}.${interceptEntry.slotName}`,
-    loaderDataPromise,
-    loaderIds: hasLoaders ? loaderIds : undefined,
-  };
-  segments.push(interceptSegment);
-
-  return segments;
+  return [slotSegment(component, layoutElement), ...loaderSegments];
 }
 
 /**
- * Resolve only the loaders for a cached intercept segment.
- * Used on intercept cache hit to get fresh loader data while keeping cached component/layout.
+ * The loader segments of a cached intercept slot, on a cache hit: the slot
+ * keeps its cached component and layout, its loaders are never cached.
  */
 export async function resolveInterceptLoadersOnly<TEnv>(
   interceptEntry: InterceptEntry,
   parentEntry: EntryData,
-  params: Record<string, string>,
   context: HandlerContext<any, TEnv>,
   belongsToRoute: boolean,
   deps: SegmentResolutionDeps<TEnv>,
-  revalidationContext: {
-    clientSegmentIds: Set<string>;
-    prevParams: Record<string, string>;
-    request: Request;
-    prevUrl: URL;
-    nextUrl: URL;
-    routeKey: string;
-    actionContext?: {
-      actionId?: string;
-      actionUrl?: URL;
-      actionResult?: any;
-      formData?: FormData;
-    };
-    stale?: boolean;
-  },
-): Promise<{
-  loaderDataPromise: Promise<any[]> | any[];
-  loaderIds: string[];
-} | null> {
-  if (interceptEntry.loader.length === 0) {
-    return null;
-  }
-
+  revalidationContext: RevalidationContext,
+): Promise<ResolvedSegment[]> {
   latchPprHeaderScopeForInterceptTarget(interceptEntry);
-
-  // The loaders' handle push owner, as in resolveInterceptEntry.
-  const slotSegmentId = `${parentEntry.shortCode}.${interceptEntry.slotName}`;
-  (context as InternalHandlerContext<any, TEnv>)._currentSegmentId =
-    slotSegmentId;
-  const loaderPromises: Promise<any>[] = [];
-  const loaderIds: string[] = [];
-
-  const {
-    clientSegmentIds,
-    prevParams,
-    request,
-    prevUrl,
-    nextUrl,
-    routeKey,
-    actionContext,
-    stale,
-  } = revalidationContext;
-
-  for (let i = 0; i < interceptEntry.loader.length; i++) {
-    const loaderEntry = interceptEntry.loader[i];
-    const { loader, revalidate: loaderRevalidateFns } = loaderEntry;
-    const segmentId = `${slotSegmentId}D${i}.${loader.$$id}`;
-
-    if (clientSegmentIds.has(slotSegmentId)) {
-      const dummySegment: ResolvedSegment = {
-        id: segmentId,
-        namespace: `intercept:${interceptEntry.routeName}`,
-        type: "loader",
-        index: i,
-        component: null,
-        params,
-        loaderId: loader.$$id,
-        belongsToRoute,
-      };
-
-      const shouldRevalidate = await evaluateRevalidation({
-        segment: dummySegment,
-        prevParams,
-        getPrevSegment: null,
-        request,
-        prevUrl,
-        nextUrl,
-        revalidations: loaderRevalidateFns.map((fn, j) => ({
-          name: `intercept-loader-revalidate${j}`,
-          fn,
-        })),
-        routeKey,
-        context,
-        actionContext,
-        stale,
-        traceSource: "intercept-loader",
-      });
-
-      if (!shouldRevalidate) {
-        debugLog("intercept.loader", "skipped on cache hit", {
-          loaderId: loader.$$id,
-        });
-        continue;
-      }
-      debugLog("intercept.loader", "revalidating on cache hit", {
-        loaderId: loader.$$id,
-        stale,
-      });
-    }
-
-    loaderIds.push(loader.$$id);
-    loaderPromises.push(
-      deps.wrapLoaderPromise(
-        // The DSL binding's funnel, as for route loaders: a loader's own
-        // cache() applies here too.
-        runInsideLoaderScope(
-          () => resolveLoaderData(loaderEntry, context, context.pathname),
-          loader.$$id,
-        ),
-        parentEntry,
-        segmentId,
-        context.pathname,
-        // Report a throwing intercept loader to onError + loader.error telemetry,
-        // matching the fresh/revalidation paths. resolveInterceptLoadersOnly is
-        // only called on the cache-hit partial-update path (handleCacheHitIntercept),
-        // so flag isPartial:true exactly like revalidation.ts's partial path.
-        { ...buildLoaderErrorContext(context), isPartial: true },
-      ),
-    );
-  }
-
-  // Every loader held: the empty aggregate (see resolveInterceptEntry).
-  if (loaderPromises.length === 0) {
-    return { loaderDataPromise: [], loaderIds };
-  }
-
-  // Match fresh-path semantics: only defer (no await) when loading is truthy.
-  // `loading: false` means "no loading UI, await loaders before render" —
-  // same as the fresh path's `if (interceptEntry.loading && ...)` check.
-  const loaderDataPromise = interceptEntry.loading
-    ? Promise.all(loaderPromises)
-    : await Promise.all(loaderPromises);
-
-  return { loaderDataPromise, loaderIds };
+  const { segments } = await resolveInterceptLoaders(
+    interceptEntry,
+    parentEntry,
+    context,
+    belongsToRoute,
+    deps,
+    revalidationContext,
+  );
+  if (!interceptEntry.loading) await settleLoaderSegments(segments);
+  deliverStartedLoaders(context, segments);
+  return segments;
 }

package/src/router/lazy-includes.ts

@@ -102,36 +102,51 @@ export function evaluateLazyEntry<TEnv = any>(
   }
 
   // Async provider (`() => import("./routes")`): the route module is evaluated
-  // off the startup path, on the first request reaching this prefix. Concurrent
-  // first-hits share one in-flight promise so the import + expansion run exactly
-  // once. The eager path below stays fully synchronous (no Promise), so the
-  // per-entry match loop pays no microtask for normal includes.
+  // off the startup path, on the first request reaching this prefix. The eager
+  // path below stays fully synchronous (no Promise), so the per-entry match
+  // loop pays no microtask for normal includes.
   const lazyPatterns = entry.lazyPatterns;
   if (isIncludeProvider(lazyPatterns)) {
-    const inflight = (entry as { _lazyInflight?: Promise<void> })._lazyInflight;
-    if (inflight) return inflight;
-    const work = (async () => {
-      const resolved = resolveIncludeModule(
-        await lazyPatterns(),
-        entry.staticPrefix,
-      );
-      // Cache the resolved patterns: any later re-entry expands synchronously.
-      entry.lazyPatterns = resolved as unknown as UrlPatterns<TEnv>;
-      runExpansion(entry, deps, resolved as UrlPatterns<TEnv>);
-    })();
-    (entry as { _lazyInflight?: Promise<void> })._lazyInflight = work;
-    const clear = () => {
-      (entry as { _lazyInflight?: Promise<void> })._lazyInflight = undefined;
-    };
-    // On failure, clear the flag (lazyEvaluated stays false) so a later request
-    // can retry the import rather than wedging the route permanently.
-    work.then(clear, clear);
-    return work;
+    // Concurrent first-hits share the import; the first to resume expands.
+    return resolveEntryPatterns(entry).then((resolved) => {
+      if (!entry.lazyEvaluated) runExpansion(entry, deps, resolved);
+    });
   }
 
   runExpansion(entry, deps, lazyPatterns as UrlPatterns<TEnv>);
 }
 
+type ProviderEntry<TEnv> = RouteEntry<TEnv> & {
+  _providerInflight?: Promise<UrlPatterns<TEnv>>;
+};
+
+/**
+ * Resolve an async include entry's provider once and cache the patterns on
+ * `entry.lazyPatterns`. Concurrent callers (match-time expansion and
+ * render-time loadManifest) share one in-flight import; it clears when it
+ * settles, so a rejected import is retried by the next request.
+ */
+export function resolveEntryPatterns<TEnv = any>(
+  entry: RouteEntry<TEnv>,
+): Promise<UrlPatterns<TEnv>> {
+  const target = entry as ProviderEntry<TEnv>;
+  const lazyPatterns = target.lazyPatterns;
+  if (!isIncludeProvider(lazyPatterns)) {
+    return Promise.resolve(lazyPatterns as UrlPatterns<TEnv>);
+  }
+  target._providerInflight ??= (async () => {
+    const resolved = resolveIncludeModule(
+      await lazyPatterns(),
+      target.staticPrefix,
+    ) as UrlPatterns<TEnv>;
+    target.lazyPatterns = resolved;
+    return resolved;
+  })().finally(() => {
+    target._providerInflight = undefined;
+  });
+  return target._providerInflight;
+}
+
 /**
  * Synchronously expand a lazy entry's (already-resolved) patterns into routes
  * and splice any nested lazy includes as new entries. Runs once per entry.
@@ -143,10 +158,9 @@ function runExpansion<TEnv = any>(
 ): void {
   // lazyEvaluated is set at the END, only after the handler ran and the routes
   // (and any nested includes) were spliced. Setting it up-front would mark the
-  // entry done even if the handler throws mid-expansion: the async provider
-  // path clears _lazyInflight on rejection so a later request can retry, but a
-  // premature lazyEvaluated=true would make evaluateLazyEntry short-circuit
-  // (line ~77) forever, wedging the route at 404 until the isolate restarts.
+  // entry done even if the handler throws mid-expansion, so a later request
+  // could not retry: evaluateLazyEntry would short-circuit forever, wedging the
+  // route at 404 until the isolate restarts.
   const lazyContext = entry.lazyContext;
 
   const manifest = new Map<string, EntryData>();
@@ -173,6 +187,8 @@ function runExpansion<TEnv = any>(
       rootScoped: lazyContext?.rootScoped,
       routerId: lazyContext?.routerId,
       includeScope: lazyContext?.includeScope,
+      scopePath: lazyContext?.scopePath,
+      hiddenScopePath: lazyContext?.hiddenScopePath,
     },
     () => {
       const includePrefix = (entry as any)._lazyPrefix || "";