@rangojs/router 0.26.6 → 0.28.0

package/src/prerender/store.ts

@@ -159,6 +159,82 @@ export function createPrerenderStore(): PrerenderStore | null {
   };
 }
 
+/**
+ * The segments of a prerendered URL's intercept variant (`/i`): the main
+ * variant's without the intercepted route's own (`belongsToRoute`: its
+ * handler, layouts and slots), then the intercept's. A render under an
+ * intercept skips the route's entry (resolveAllSegments), so the variant
+ * holds what a cache() intercept record holds. The producer
+ * (matchForPrerender) encodes `interceptHandles` for exactly these segments.
+ */
+export function interceptVariantSegments(
+  segments: SerializedSegmentData[],
+  interceptSegments: SerializedSegmentData[],
+): SerializedSegmentData[] {
+  return [
+    ...segments.filter((s) => s.metadata.belongsToRoute !== true),
+    ...interceptSegments,
+  ];
+}
+
+/**
+ * The intercept variant as served under the intercept the match selected
+ * (findInterceptForRoute): its main segments and that intercept's slot,
+ * `slotId` in `intercept:<routeName>`. The build bakes every intercept that
+ * can target the route, since it cannot evaluate when(). Null when the
+ * variant does not hold that slot: the request renders live. The handles
+ * string is kept whole; decodeStoredEntry (cache-lookup.ts) replays only the
+ * served segments' pushes.
+ */
+export function selectInterceptVariant(
+  entry: PrerenderEntry,
+  slotId: string,
+  routeName: string,
+): PrerenderEntry | null {
+  const namespace = `intercept:${routeName}`;
+  let found = false;
+  const segments = entry.segments.filter(({ metadata }) => {
+    if (!metadata.namespace?.startsWith("intercept:")) return true;
+    if (metadata.id !== slotId || metadata.namespace !== namespace) {
+      return false;
+    }
+    found = true;
+    return true;
+  });
+  return found ? { segments, handles: entry.handles } : null;
+}
+
+/**
+ * The manifest entries ([key, PrerenderEntry JSON]) one prerendered URL
+ * bakes, keyed as the production store's get() reads them. The intercept
+ * variant (`/i`) holds interceptVariantSegments with the handle string the
+ * producer encoded for it. Written by the build
+ * (vite/discovery/prerender-collection.ts) and serveShellRequest.
+ */
+export function prerenderManifestEntries(
+  result: PrerenderEntry & {
+    routeName: string;
+    interceptSegments?: SerializedSegmentData[];
+    interceptHandles?: string;
+  },
+  paramHash: string,
+): Array<[key: string, value: string]> {
+  const { segments, handles, interceptSegments } = result;
+  const key = `${result.routeName}/${paramHash}`;
+  const entries: Array<[string, string]> = [
+    [key, JSON.stringify({ segments, handles })],
+  ];
+  if (interceptSegments?.length) {
+    const intercept = interceptVariantSegments(segments, interceptSegments);
+    const interceptHandles = result.interceptHandles ?? "";
+    entries.push([
+      `${key}/i`,
+      JSON.stringify({ segments: intercept, handles: interceptHandles }),
+    ]);
+  }
+  return entries;
+}
+
 /**
  * Create a static segment store.
  * Production only: backed by globalThis.__STATIC_MANIFEST injected at build time.

package/src/prerender/warm-request.ts

@@ -8,7 +8,10 @@
  */
 
 import type { HandlerCacheConfig } from "../rsc/types.js";
-import type { ShellCaptureDebugEvent } from "../rsc/shell-capture.js";
+import type {
+  ShellCaptureDebugEvent,
+  ShellCaptureState,
+} from "../rsc/shell-capture.js";
 import type { PrerenderWarmCaches } from "./on-demand.js";
 
 /** What one warm request did: written by the layers, read by the trigger. */
@@ -36,7 +39,7 @@ export interface PrerenderWarmRecord extends PrerenderWarmCaches {
 /** What the helpers read; a derived capture context inherits the record. */
 export interface WarmContext {
   _prerenderWarm?: PrerenderWarmRecord;
-  _shellCaptureRun?: boolean;
+  _shellCaptureState?: Pick<ShellCaptureState, "run">;
 }
 
 /**
@@ -79,14 +82,15 @@ export function readWarmMark(
  * "use cache" in-flight dedup lives outside the store, so a wrapper would
  * miss both.
  *
- * False in the warm's own shell capture (`_shellCaptureRun`): it runs after
+ * False in the warm's own shell capture (`_shellCaptureState`): it runs after
  * the warm's writes settled and must replay them, or it would render every
  * handler a second time and could bake another generation than the one just
  * written.
  */
 export function isWarmReplace(ctx: WarmContext | null | undefined): boolean {
   return (
-    ctx?._prerenderWarm?.mode === "replace" && ctx._shellCaptureRun !== true
+    ctx?._prerenderWarm?.mode === "replace" &&
+    ctx._shellCaptureState?.run !== true
   );
 }
 

package/src/prerender.ts

@@ -490,8 +490,8 @@ export function isPrerenderPassthrough(
  * A build handler signals passthrough by returning `ctx.passthrough()` (the
  * PRERENDER_PASSTHROUGH sentinel), which lands on the segment's `component`.
  * But when the route declares `loading()`, the handler result is deferred
- * upstream (segment-resolution/fresh.ts), so `component` is a thenable resolving
- * to the sentinel rather than the sentinel itself — a synchronous
+ * upstream (resolveEntryHandler), so `component` is a thenable
+ * resolving to the sentinel rather than the sentinel itself — a synchronous
  * `isPrerenderPassthrough(component)` on the Promise returns false and the build
  * bakes a corrupt artifact instead of deferring. Resolve thenables first.
  *

package/src/route-name.ts

@@ -63,3 +63,11 @@ export function validateUserRouteName(name: string): void {
     }
   }
 }
+
+/**
+ * The route key's last name segment ("item" for "shop.item"). An intercept
+ * that targets it is selected when none targets the full key (match-api.ts).
+ */
+export function localRouteName(routeKey: string): string {
+  return routeKey.slice(routeKey.lastIndexOf(".") + 1);
+}

package/src/router/error-handling.ts

@@ -111,10 +111,10 @@ export function invokeOnError<TEnv = any>(
 /**
  * First non-undefined `pick(orphan)` over the routeless entries in
  * `entry.layout` and, recursively, in theirs: depth-first in render order
- * (resolveOrphanLayout in segment-resolution/fresh.ts). Since #922 a routeless
- * entry nested in another renders (a layout() after a bare cache() marker, a
- * layout() in a routeless wrapper); a one-level scan missed the boundaries and
- * intercepts it declares (#926).
+ * (resolveOrphanLayout in segment-resolution/revalidation.ts).
+ * Since #922 a routeless entry nested in another renders (a layout() after a
+ * bare cache() marker, a layout() in a routeless wrapper); a one-level scan
+ * missed the boundaries and intercepts it declares (#926).
  *
  * `skip` is the entry an upward walk came from. Only a bare cache() marker is
  * both in its layout's layout[] and in the chain, and its subtree was already

package/src/router/instrument.ts

@@ -428,9 +428,10 @@ function observeInSegmentScope<C, R>(
  *     loop (request.start/end/error, cache.decision, ...).
  *   - segment-resolution/helpers.ts emits via a caller-provided report.telemetry
  *     sink rather than the ALS router context.
- *   - rsc/handler.ts handleTimeoutResponse (request.timeout), the origin guard
- *     (request.origin-rejected), and handleStore.onError (late-handle
- *     handler.error) emit via router.telemetry directly — they run outside the
+ *   - rsc/request-stages.ts timeoutResponse (request.timeout) and
+ *     originRejectedResponse (request.origin-rejected), and rsc/handler.ts
+ *     handleStore.onError (late-handle handler.error) emit via
+ *     router.telemetry directly — they run outside the
  *     RouterContext ALS (only match()/matchPartial() enter it), so a
  *     getRouterContext() read there throws and the event would vanish.
  */

package/src/router/intercept-resolution.ts

@@ -11,11 +11,7 @@ import type {
   InterceptEntry,
   InterceptSelectorContext,
 } from "../server/context";
-import type {
-  HandlerContext,
-  InternalHandlerContext,
-  ResolvedSegment,
-} from "../types";
+import type { InternalHandlerContext, ResolvedSegment } from "../types";
 import {
   handleHandlerResult,
   warnOnStreamedResponse,
@@ -28,18 +24,15 @@ 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 { fillSends } from "./segment-resolution/prefetch-deferral.js";
+import type { ResolutionPass } from "./segment-resolution/resolution-pass.js";
 import { getRouterContext } from "./router-context.js";
-import type { RevalidationContext } from "./router-context.js";
 import { runInSegmentTagScope } from "../cache/cache-tag.js";
 import {
   RangoContext,
   latchPprHeaderScopeForEntries,
 } from "../server/context.js";
+import { _getRequestContext } from "../server/request-context.js";
 
 /**
  * Header-guard latch for the intercept funnels (issue #713). ppr and
@@ -171,31 +164,38 @@ 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 (`background`) rethrow, so a failed
- * re-render aborts its cache write instead of storing the fallback.
+ * partial navigations: 500/404 status, onError "handler"). Responses rethrow.
+ * The background re-render (`background`) reports the error the same way and
+ * then rethrows it, so a failed re-render aborts its cache write instead of
+ * storing the fallback.
  */
 function renderInterceptHandlerError<TEnv>(
+  pass: ResolutionPass<TEnv>,
   error: unknown,
   parentEntry: EntryData,
-  params: Record<string, string>,
-  context: HandlerContext<any, TEnv>,
-  deps: SegmentResolutionDeps<TEnv>,
   background: boolean | undefined,
 ): ReactNode {
-  if (error instanceof Response || background) throw error;
-  return catchSegmentError(
+  if (error instanceof Response) throw error;
+  // A background re-render's waitUntil task may run outside the router
+  // context, as the segment walk's report allows.
+  let telemetry;
+  try {
+    telemetry = getRouterContext()?.telemetry;
+  } catch {}
+  const { component } = catchSegmentError(
     error,
     parentEntry,
-    params,
-    deps,
+    pass.params,
+    pass.deps,
     {
-      ...buildLoaderErrorContext(context),
+      ...buildLoaderErrorContext(pass.context),
       isPartial: true,
-      telemetry: getRouterContext()?.telemetry,
+      telemetry,
     },
-    context.pathname,
-  ).component;
+    pass.context.pathname,
+  );
+  if (background) throw error;
+  return component;
 }
 
 /** The segment id of `intercept`'s slot on `parentEntry`. */
@@ -206,6 +206,33 @@ export function interceptSlotId(
   return `${parentEntry.shortCode}.${intercept.slotName}`;
 }
 
+/**
+ * The intercept a match selected (findInterceptForRoute), as its cache()
+ * record names it (CacheScope): the slot id, then `~` and its position among
+ * the intercepts its entry declares for the same slot and target route. Two
+ * such intercepts share the slot id, and the position tells them apart; one
+ * for another slot or route does not renumber it. `~` is unreserved in a
+ * URL, so a store that maps the key onto one unencoded keeps the whole key.
+ * Undefined when the match selected none.
+ */
+export function interceptRecordKey(
+  selected: { intercept: InterceptEntry; entry: EntryData } | null,
+): string | undefined {
+  if (!selected) return undefined;
+  const { intercept, entry } = selected;
+  let position = 0;
+  for (const other of entry.intercept) {
+    if (other === intercept) break;
+    if (
+      other.slotName === intercept.slotName &&
+      other.routeName === intercept.routeName
+    ) {
+      position++;
+    }
+  }
+  return `${interceptSlotId(entry, intercept)}~${position}`;
+}
+
 /**
  * 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
@@ -228,14 +255,13 @@ export function interceptSegmentIds(
  * revalidated on its own, kept in a fill, deferred by a prefetch when flagged.
  */
 function resolveInterceptLoaders<TEnv>(
+  pass: ResolutionPass<TEnv>,
   interceptEntry: InterceptEntry,
   parentEntry: EntryData,
-  context: HandlerContext<any, TEnv>,
   belongsToRoute: boolean,
-  deps: SegmentResolutionDeps<TEnv>,
-  rc: RevalidationContext,
 ): Promise<{ segments: ResolvedSegment[] }> {
   return resolveOwnerLoaders(
+    pass,
     {
       loaders: interceptEntry.loader,
       namespace: `intercept:${interceptEntry.routeName}`,
@@ -244,17 +270,7 @@ function resolveInterceptLoaders<TEnv>(
       bakeLane: false,
       traceSource: "intercept-loader",
     },
-    context,
     belongsToRoute,
-    rc.clientSegmentIds,
-    rc.prevParams,
-    rc.request,
-    rc.prevUrl,
-    rc.nextUrl,
-    rc.routeKey,
-    deps,
-    rc.actionContext,
-    rc.stale,
   );
 }
 
@@ -271,45 +287,37 @@ async function settleLoaderSegments(
 }
 
 /**
- * Resolve an intercept entry: its slot segment, then its loader segments.
+ * Resolve an intercept entry: its slot segment, then its loader segments. The
+ * background re-render resolves with a pass that holds nothing
+ * (heldNothingPassInput, resolution-pass.ts): every segment renders fresh, and
+ * its loaders are skipped (skipLoaders), each registered for the handler's
+ * read.
  */
 export async function resolveInterceptEntry<TEnv>(
+  pass: ResolutionPass<TEnv>,
   interceptEntry: InterceptEntry,
   parentEntry: EntryData,
-  params: Record<string, string>,
-  context: HandlerContext<any, TEnv>,
   belongsToRoute: boolean,
-  deps: SegmentResolutionDeps<TEnv>,
-  // 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?: {
     /**
      * 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: a handler error rejects instead of rendering the
-     * error boundary, so a failure is never cached. Never set on the
-     * foreground path.
+     * populate the cache: a handler error is reported, then rejects instead
+     * of rendering the error boundary, so a failure is never cached. Never
+     * set on the foreground path.
      */
     background?: boolean;
   },
 ): Promise<ResolvedSegment[]> {
   latchPprHeaderScopeForInterceptTarget(interceptEntry);
 
+  const { context, params } = pass;
   const slotSegmentId = interceptSlotId(parentEntry, interceptEntry);
   const { segments: loaderSegments } = await resolveInterceptLoaders(
+    pass,
     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
@@ -337,10 +345,7 @@ export async function resolveInterceptEntry<TEnv>(
   // 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
-  ) {
+  if (fillSends(context, slotSegmentId, pass.client) === false) {
     return [slotSegment(null, undefined), ...loaderSegments];
   }
 
@@ -355,11 +360,9 @@ export async function resolveInterceptEntry<TEnv>(
         : handler;
   } catch (error) {
     handlerResult = renderInterceptHandlerError(
+      pass,
       error,
       parentEntry,
-      params,
-      context,
-      deps,
       options?.background,
     );
   }
@@ -392,7 +395,7 @@ export async function resolveInterceptEntry<TEnv>(
   // 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, {
+    trackStreamedHandler(pass.deps, promise, {
       boundaryEntry: parentEntry,
       segmentId: slotSegmentId,
       segmentType: "parallel",
@@ -423,11 +426,9 @@ export async function resolveInterceptEntry<TEnv>(
         component = await handlerResult;
       } catch (error) {
         component = renderInterceptHandlerError(
+          pass,
           error,
           parentEntry,
-          params,
-          context,
-          deps,
           options?.background,
         );
       }
@@ -445,23 +446,24 @@ export async function resolveInterceptEntry<TEnv>(
  * keeps its cached component and layout, its loaders are never cached.
  */
 export async function resolveInterceptLoadersOnly<TEnv>(
+  pass: ResolutionPass<TEnv>,
   interceptEntry: InterceptEntry,
   parentEntry: EntryData,
-  context: HandlerContext<any, TEnv>,
   belongsToRoute: boolean,
-  deps: SegmentResolutionDeps<TEnv>,
-  revalidationContext: RevalidationContext,
 ): Promise<ResolvedSegment[]> {
   latchPprHeaderScopeForInterceptTarget(interceptEntry);
+  const handleStore = _getRequestContext()?._handleStore;
   const { segments } = await resolveInterceptLoaders(
+    pass,
     interceptEntry,
     parentEntry,
-    context,
     belongsToRoute,
-    deps,
-    revalidationContext,
+  );
+  // Where resolveInterceptEntry runs the handler.
+  handleStore?.releaseRecordedValues(
+    interceptSlotId(parentEntry, interceptEntry),
   );
   if (!interceptEntry.loading) await settleLoaderSegments(segments);
-  deliverStartedLoaders(context, segments);
+  deliverStartedLoaders(pass.context, segments);
   return segments;
 }

package/src/router/loader-resolution.ts

@@ -341,7 +341,8 @@ export function wrapLoaderWithErrorHandling<T>(
       // Render fallback on server. The user ErrorBoundaryHandler may throw
       // synchronously; if it does we must NOT let that rejection escape — the
       // wrapped LoaderDataResult promise is contracted to never reject (see
-      // segment-resolution/fresh.ts `await Promise.all(...wrapped)`), and a
+      // resolveOwnerLoaders `await Promise.all(...)` in
+      // segment-resolution/revalidation.ts), and a
       // rejection here would collapse the whole entry and discard healthy
       // sibling loader data. On a fallback-render throw, fall back to the
       // no-boundary result (fallback: null) so the client throws the ORIGINAL
@@ -585,7 +586,7 @@ function createLoaderExecutor<TEnv>(
     const variables = internal._variables;
 
     // Capture whether this loader is being started from a DSL loader scope
-    // (runInsideLoaderScope in fresh.ts). Handler-invoked loaders are NOT
+    // (runInsideLoaderScope in resolveOwnerLoaders). Handler-invoked loaders are NOT
     // inside loader scope. This determines whether rendered() is allowed.
     const isDslLoader = isInsideLoaderScope();
     // The body resolves ctx.reverse(".name") in its DSL declaration's module
@@ -596,7 +597,7 @@ function createLoaderExecutor<TEnv>(
 
     // Owning segment for ctx.handle() attribution, captured SYNCHRONOUSLY at
     // kickoff: segment resolution sets _currentSegmentId while resolving the
-    // segment that declares this loader (fresh.ts), and the value moves on as
+    // segment that declares this loader (resolveOwnerLoaders), and the value moves on as
     // resolution continues — by the time the async body pushes, it would be
     // stale. Attributing to the owning route/layout segment gives handle
     // pushes the same granularity handler pushes have (segmentOrder-correct
@@ -844,7 +845,7 @@ function createLoaderExecutor<TEnv>(
     // Run the loader body inside loader scope so request-scoped reads
     // (cookies()/headers() and non-cacheable ctx.get) are exempt from the
     // cache-purity guards: loaders always run fresh, so their reads never leak
-    // into a cached segment. DSL loaders are already wrapped by fresh.ts; this
+    // into a cached segment. DSL loaders are already wrapped by resolveOwnerLoaders; this
     // also covers handler-invoked loaders (ctx.use(Loader) from a handler),
     // which otherwise execute in the caller's cache scope and would wrongly
     // throw. rendered() gating uses the captured isDslLoader (above), so this

package/src/router/match-api.ts

@@ -184,8 +184,9 @@ export async function createMatchContextForFull<TEnv>(
   // A shell capture credits a push under a live-lane loader's body to that
   // loader (shell-capture.ts deriveShellCaptureContext). The lanes are set
   // before any loader runs: a bake-lane loader can start a later one.
-  if (reqCtx?._shellCaptureRun) {
-    reqCtx._shellCaptureLoaderLanes = routeLoaderLanes(snapshot.entries);
+  const captureState = reqCtx?._shellCaptureState;
+  if (captureState?.run) {
+    captureState.loaderLanes = routeLoaderLanes(snapshot.entries);
   }
   // A document never defers; the plan feeds the ctx.rendered() guards.
   (handlerContext as InternalHandlerContext<any, TEnv>)._prefetchDeferral =
@@ -208,7 +209,6 @@ export async function createMatchContextForFull<TEnv>(
     routeKey: matched.routeKey,
     localRouteName: snapshot.localRouteName,
     handlerContext,
-    loaderPromises,
     routeMap: deps.getRouteMap(),
     metricsStore,
     Store,
@@ -492,7 +492,7 @@ export async function createMatchContextForPartial<TEnv>(
       prefetch: kind === "prefetch",
       method: request.method,
       isAction,
-      isShellCapture: reqCtx?._shellCaptureRun === true,
+      isShellCapture: reqCtx?._shellCaptureState?.run === true,
     }),
     matched,
     cacheScope,
@@ -523,7 +523,6 @@ export async function createMatchContextForPartial<TEnv>(
     routeKey: matched.routeKey,
     localRouteName: snapshot.localRouteName,
     handlerContext,
-    loaderPromises,
     routeMap: deps.getRouteMap(),
     metricsStore,
     Store,

package/src/router/match-context.ts

@@ -63,7 +63,6 @@
  *
  * Handler Context:
  *   - handlerContext: Context passed to loaders
- *   - loaderPromises: Memoized loader promises
  *
  * Intercepts:
  *   - interceptResult: Detected intercept (if soft navigation)
@@ -118,16 +117,8 @@ import type {
 import type { HandlerContext, ResolvedSegment } from "../types.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
 import type { InterceptResult } from "./router-context.js";
-
-/**
- * Action context passed to matchPartial
- */
-export interface ActionContext {
-  actionId?: string;
-  actionUrl?: URL;
-  actionResult?: any;
-  formData?: FormData;
-}
+import type { ResolutionPassInput } from "./segment-resolution/resolution-pass.js";
+import type { ActionContext } from "./types.js";
 
 /**
  * Match context containing all state for the match pipeline
@@ -160,7 +151,6 @@ export interface MatchContext<TEnv = any> {
 
   // Handler context (for loaders)
   handlerContext: HandlerContext<any, TEnv>;
-  loaderPromises: Map<string, Promise<any>>;
 
   // Route map for server-side ctx.reverse() resolution
   routeMap: Record<string, string>;
@@ -201,6 +191,37 @@ export interface MatchContext<TEnv = any> {
   isFullMatch: boolean;
 }
 
+/**
+ * An action, or a stale partial (`_rsc_stale`: Back/Forward onto an entry
+ * marked stale, `refresh()`, the cross-tab refresh, the action follow-up, a
+ * zero-segment refetch), renders live: no route-cache or prerender-store read
+ * a live handler can replace, and no store. An action's render is never
+ * stored, so a record can be older than the copy the client holds after it.
+ */
+export function rendersLive(
+  ctx: Pick<MatchContext, "isAction" | "stale">,
+): boolean {
+  return ctx.isAction || ctx.stale;
+}
+
+/** This match as the input of a revalidating resolution pass (resolution-pass.ts). */
+export function resolutionPassInput<TEnv>(
+  ctx: MatchContext<TEnv>,
+): ResolutionPassInput<TEnv> {
+  return {
+    context: ctx.handlerContext,
+    client: ctx.clientSegmentSet,
+    params: ctx.matched.params,
+    prevParams: ctx.prevParams,
+    request: ctx.request,
+    prevUrl: ctx.prevUrl,
+    nextUrl: ctx.url,
+    routeKey: ctx.routeKey,
+    actionContext: ctx.actionContext,
+    stale: ctx.stale,
+  };
+}
+
 /**
  * Mutable state that flows through the pipeline
  */