@rangojs/router 0.18.0 → 0.19.1

package/src/router/loader-resolution.ts

@@ -14,9 +14,13 @@ import {
   linkRecordedTags,
   linkValueTags,
   loaderTagSetsArmed,
+  markTagSetStart,
+  readStartedLoaderValue,
   readValueTags,
   tagLoaderValue,
+  trackLoaderRun,
 } from "../cache/cache-tag.js";
+import { executionStart } from "../cache/tag-invalidation.js";
 import type {
   ResolvedSegment,
   HandlerContext,
@@ -55,8 +59,10 @@ import {
   assertNonCacheableReadAllowed,
   isInsideLoaderScope,
   runInsideLoaderBodyScope,
+  runInsideLoaderRun,
   isInsidePushCallbackScope,
   runInsidePushCallbackScope,
+  type LoaderRunIdentity,
 } from "../server/context.js";
 import { debugLog } from "./logging.js";
 
@@ -396,6 +402,12 @@ function createLoaderExecutor<TEnv>(
      * payload's handle-stream lifetime.
      */
     silentHandles?: boolean;
+    /**
+     * A stale refresh's executor (setupLoaderAccess _runLoaderIsolated): its
+     * runs' pushes are diverted from the page's store, so a run's end says
+     * nothing about the page's replayed values (HandleStore.settleLoaderRun).
+     */
+    detached?: boolean;
     /**
      * loaderId -> the cache() tags of that loader's binding in this request
      * (setupLoaderAccess _bindLoaderCacheTags): an execution of it outside
@@ -410,6 +422,8 @@ function createLoaderExecutor<TEnv>(
   // Capture RequestContext eagerly for cookie access (ALS protection on Cloudflare)
   const reqCtxRef = _getRequestContext();
   const silentHandles = executorOptions?.silentHandles === true;
+  // A run's end reports to the page's store only when its pushes reach it.
+  const reportsRunEnd = !silentHandles && executorOptions?.detached !== true;
   const internal = ctx as InternalHandlerContext<any, TEnv>;
 
   // Dependency graph: loaderId -> set of loader IDs it directly depends on.
@@ -469,7 +483,9 @@ function createLoaderExecutor<TEnv>(
     const memo = bound || loaderPromises.get(loader.$$id);
     if (memo) {
       if (recordTags) readValueTags(memo);
-      return memo;
+      // A "use cache" body reading it refuses an identity read the run made
+      // (#1011): the body ran outside the cached function, unguarded.
+      return readStartedLoaderValue(memo, loader.$$id);
     }
 
     // Get loader function - either from loader object or fetchable registry
@@ -712,21 +728,37 @@ function createLoaderExecutor<TEnv>(
     //
     // The CONSUMPTION-LANE RULE: a handler-consumed loader's value is a
     // BAKED copy in every shared artifact (cache(), "use cache", the PPR
-    // shell). The cache-purity guards permit its identity reads; the PPR
-    // capture guard does not (server/context.ts assertNotInsideShellCapture).
+    // shell). The cache() guard permits its identity reads; a "use cache"
+    // body it was entered in and a PPR capture do not (server/context.ts
+    // guardIdentityRead), and a "use cache" body that reads the value after
+    // another reader started it refuses what `identity` recorded (#1011).
 
+    const identity: LoaderRunIdentity = { loaderId: loader.$$id };
     const recordedTags = recordTags ? new Set<string>() : undefined;
+    // A loader-cache write that stores or reads this value gates on the
+    // earliest start behind it (#977, earliestRecordedStart).
+    if (recordedTags) markTagSetStart(recordedTags, executionStart());
+    const runEndStore = reportsRunEnd
+      ? (reqCtxRef ?? _getRequestContext())?._handleStore
+      : undefined;
     const promise = observePhase(PHASES.loader(loader.$$id), () =>
       Promise.resolve(
         runInsideLoaderBodyScope(
-          () => loaderFn(loaderCtx as LoaderContext<any, TEnv>),
+          () =>
+            runInsideLoaderRun(identity, () =>
+              loaderFn(loaderCtx as LoaderContext<any, TEnv>),
+            ),
           loader.$$id,
           recordedTags,
         ),
       ).finally(() => {
         pendingLoaders.delete(loader.$$id);
+        // Its pushes are made: values replayed for it that none replaced
+        // go (a hole that throws or skips its push shows none).
+        runEndStore?.settleLoaderRun(loader.$$id);
       }),
     );
+    trackLoaderRun(promise, identity);
     if (recordedTags) {
       tagLoaderValue(promise, recordedTags);
       readValueTags(promise);
@@ -809,7 +841,12 @@ export function setupLoaderAccess<TEnv>(
         _loaderCacheOverrides: { value: undefined },
       }),
       new Map(),
-      executor,
+      {
+        get bindingTags() {
+          return executor.bindingTags;
+        },
+        detached: true,
+      },
     )(loader, null);
 
   ctx.use = ((item: LoaderDefinition<any, any> | Handle<any, any>) => {

package/src/router/logging.ts

@@ -1,3 +1,4 @@
+import { requestHeaders } from "../server/request-headers.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { INTERNAL_RANGO_DEBUG } from "../internal-debug.js";
 
@@ -61,10 +62,11 @@ function nextId(prefix: string, counter: number): string {
 }
 
 function getHeaderRequestId(request: Request): string | null {
+  const headers = requestHeaders(request);
   const candidate =
-    request.headers.get("x-rsc-router-request-id") ??
-    request.headers.get("x-request-id") ??
-    request.headers.get("cf-ray");
+    headers.get("x-rsc-router-request-id") ??
+    headers.get("x-request-id") ??
+    headers.get("cf-ray");
   if (!candidate) return null;
   const trimmed = candidate.trim();
   return trimmed.length > 0 ? trimmed : null;

package/src/router/match-api.ts

@@ -1,10 +1,14 @@
+import { requestHeaders } from "../server/request-headers.js";
 import {
   CacheScope,
   createCacheScope,
   resolveShellImplicitCacheScope,
 } from "../cache/cache-scope.js";
 import { armLoaderTagSets, armRecordTagOwners } from "../cache/cache-tag.js";
-import { bindsLoaderCache } from "./segment-resolution/loader-cache.js";
+import {
+  bindsLoaderCache,
+  routeLoaderLanes,
+} from "./segment-resolution/loader-cache.js";
 import { RouteNotFoundError } from "../errors";
 import {
   createErrorInfo,
@@ -37,8 +41,7 @@ import {
   _getRequestContext,
   setRequestContextPrevRouteKey,
 } from "../server/request-context.js";
-import { isAutoGeneratedRouteName } from "../route-name.js";
-import type { DefaultRouteName } from "../types/global-namespace.js";
+import { publicRouteName } from "../route-name.js";
 import { debugLog, debugWarn } from "./logging.js";
 import {
   resolveRoute,
@@ -62,7 +65,7 @@ export async function createMatchContextForFull<TEnv>(
 
   const metricsStore = deps.getMetricsStore();
 
-  const isHmr = !!request.headers.get("X-RSC-HMR");
+  const isHmr = !!requestHeaders(request).get("X-RSC-HMR");
   // HMR: clear the manifest cache so stale handler references are discarded.
   if (isHmr) {
     clearManifestCache();
@@ -165,6 +168,12 @@ export async function createMatchContextForFull<TEnv>(
     armRecordTagOwners();
   }
   if (bindsLoaderCache(snapshot.entries)) armLoaderTagSets();
+  // 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);
+  }
 
   return {
     request,
@@ -188,18 +197,20 @@ export async function createMatchContextForFull<TEnv>(
     metricsStore,
     Store,
     interceptContextMatch: null,
-    interceptSelectorContext: {
-      from: cleanUrl,
-      to: cleanUrl,
-      params: matched.params,
-      request,
-      env,
-      segments: { path: [], ids: [] },
-      toRouteName:
-        matched.routeKey && !isAutoGeneratedRouteName(matched.routeKey)
-          ? (matched.routeKey as DefaultRouteName)
-          : undefined,
-    },
+    interceptSelectorContext: (() => {
+      const here = {
+        url: cleanUrl,
+        params: matched.params,
+        routeName: publicRouteName(matched.routeKey),
+      };
+      return {
+        from: here,
+        to: here,
+        request,
+        env,
+        segments: { path: [], ids: [] },
+      };
+    })(),
     isSameRouteNavigation: false,
     interceptResult: null,
     cacheScope,
@@ -231,7 +242,7 @@ export async function createMatchContextForPartial<TEnv>(
 
   const metricsStore = deps.getMetricsStore();
 
-  const isHmr = !!request.headers.get("X-RSC-HMR");
+  const isHmr = !!requestHeaders(request).get("X-RSC-HMR");
 
   // HMR: clear manifest cache so stale handler references are discarded
   if (isHmr) {
@@ -349,31 +360,27 @@ export async function createMatchContextForPartial<TEnv>(
     });
   }
 
-  setRequestContextPrevRouteKey(
-    nav.effectiveFromMatch?.routeKey,
-    nav.effectiveFromUrl,
-    nav.effectiveFromMatch?.params ?? nav.prevParams,
-  );
+  setRequestContextPrevRouteKey(nav.effectiveFromMatch?.routeKey);
 
   const interceptSelectorContext: InterceptSelectorContext = {
-    from: nav.effectiveFromUrl,
-    to: cleanUrl,
-    params: matched.params,
+    // The source's params come from matching its URL (the intercept source
+    // while one is open), like its route name.
+    from: {
+      url: nav.effectiveFromUrl,
+      params: nav.effectiveFromMatch?.params ?? {},
+      routeName: publicRouteName(nav.effectiveFromMatch?.routeKey),
+    },
+    to: {
+      url: cleanUrl,
+      params: matched.params,
+      routeName: publicRouteName(matched.routeKey),
+    },
     request,
     env,
     segments: {
       path: nav.effectiveFromUrl.pathname.split("/").filter(Boolean),
       ids: nav.filteredSegmentIds,
     },
-    fromRouteName:
-      nav.effectiveFromMatch?.routeKey &&
-      !isAutoGeneratedRouteName(nav.effectiveFromMatch.routeKey)
-        ? (nav.effectiveFromMatch.routeKey as DefaultRouteName)
-        : undefined,
-    toRouteName:
-      matched.routeKey && !isAutoGeneratedRouteName(matched.routeKey)
-        ? (matched.routeKey as DefaultRouteName)
-        : undefined,
   };
   const isAction = !!actionContext;
 
@@ -414,6 +421,26 @@ export async function createMatchContextForPartial<TEnv>(
     clientSegmentSet.delete(snapshot.manifestEntry.shortCode);
   }
 
+  // Whether an intercept targets this route at all: the same walk as above
+  // with isAction=true, which skips when(). If one does, the response depends
+  // on the source even when none applied (a when() that rejected it, a
+  // same-route navigation), so it must not share the source-agnostic prefetch
+  // slot (#1007). The walk is over the TARGET's chain, so a route no
+  // intercept targets never depends on the source this way.
+  const targetsIntercept = (routeKey: string): boolean =>
+    findInterceptForRoute(
+      routeKey,
+      snapshot.manifestEntry.parent,
+      null,
+      true,
+    ) !== null;
+  const interceptTargeted =
+    !!interceptResult ||
+    (!skipInterceptForAction &&
+      (targetsIntercept(matched.routeKey) ||
+        (snapshot.localRouteName !== matched.routeKey &&
+          targetsIntercept(snapshot.localRouteName))));
+
   const isIntercept = !!interceptResult;
   // A normal-route navigation may replay a PPR shell's canonical segment
   // snapshot. Intercepts remain source-dependent and always use their normal
@@ -451,6 +478,7 @@ export async function createMatchContextForPartial<TEnv>(
     interceptSelectorContext,
     isSameRouteNavigation: nav.isSameRouteNavigation,
     interceptResult,
+    interceptTargeted,
     cacheScope,
     isIntercept,
     actionContext,

package/src/router/match-context.ts

@@ -176,6 +176,11 @@ export interface MatchContext<TEnv = any> {
   interceptSelectorContext: InterceptSelectorContext;
   isSameRouteNavigation: boolean;
   interceptResult: InterceptResult | null;
+  /**
+   * An intercept targets this route, matched or not (a same-route navigation
+   * skips it), so the response depends on the source. Partial matches only.
+   */
+  interceptTargeted?: boolean;
 
   // Cache
   cacheScope: CacheScope | null;

package/src/router/match-handlers.ts

@@ -9,7 +9,6 @@ import type {
   NotFoundBoundaryHandler,
 } from "../types";
 import {
-  isPprEntry,
   type EntryData,
   type InterceptEntry,
   type InterceptSelectorContext,
@@ -48,7 +47,7 @@ import {
 } from "./telemetry.js";
 import { _getRequestContext } from "../server/request-context.js";
 import { ShellRecordUnavailableError } from "../cache/shell-snapshot.js";
-import { evaluatePprTransitionWhen } from "./transition-when.js";
+import { recordTransitionWhenRefs } from "./transition-when.js";
 
 /**
  * Per-call telemetry lifecycle emitter for match()/matchPartial(). Each method
@@ -235,33 +234,14 @@ export function createMatchHandlers<TEnv = any>(
     if (reqCtx) reqCtx._cacheSignal = segments;
   };
 
-  const evaluatePprTransitionWhenForMatch = (
-    ctx: MatchContext<TEnv>,
-    isPartial: boolean,
-  ): void => {
+  const recordTransitionWhenRefsForMatch = (ctx: MatchContext<TEnv>): void => {
     const reqCtx = _getRequestContext();
     if (!reqCtx) return;
-    reqCtx._pprTransitionDecisions = undefined;
-    if (!isPprEntry(ctx.manifestEntry)) return;
-
-    evaluatePprTransitionWhen(
-      ctx.entries,
-      reqCtx,
-      {
-        params: ctx.matched.params,
-        routeName: ctx.interceptSelectorContext.toRouteName,
-      },
-      (error, segmentId) =>
-        callOnError(error, "rendering", {
-          request: ctx.request,
-          url: ctx.url,
-          env: ctx.env,
-          params: ctx.matched.params,
-          segmentId,
-          isPartial,
-          handledByBoundary: false,
-        }),
-    );
+    const entry = ctx.manifestEntry;
+    recordTransitionWhenRefs(ctx.entries, reqCtx, {
+      routeName: ctx.routeKey,
+      pattern: entry?.type === "route" ? entry.pattern : undefined,
+    });
   };
 
   async function createMatchContextForFull(
@@ -350,7 +330,7 @@ export function createMatchHandlers<TEnv = any>(
           }
 
           const ctx = result as MatchContext<TEnv>;
-          evaluatePprTransitionWhenForMatch(ctx, false);
+          recordTransitionWhenRefsForMatch(ctx);
 
           try {
             const state = createPipelineState();
@@ -466,7 +446,7 @@ export function createMatchHandlers<TEnv = any>(
               emitter.end(0, false);
               return null;
             }
-            evaluatePprTransitionWhenForMatch(ctx, true);
+            recordTransitionWhenRefsForMatch(ctx);
 
             if (isRouterDebugEnabled()) {
               startRevalidationTrace({

package/src/router/match-middleware/background-revalidation.ts

@@ -107,6 +107,7 @@ import type { GeneratorMiddleware } from "./cache-lookup.js";
 import { debugLog, debugWarn, getOrCreateRequestId } from "../logging.js";
 import { INTERNAL_RANGO_DEBUG } from "../../internal-debug.js";
 import { getContext } from "../../server/context.js";
+import { executionStart } from "../../cache/tag-invalidation.js";
 import {
   createRequestContext,
   runWithRequestContext,
@@ -134,10 +135,6 @@ import {
  *     cache-scope.ts), so a swap sent live pushes into this render.
  *     setupLoaderAccess binds the store at setup, so it runs inside the
  *     derived context too.
- *   - _transitionWhen: fresh resolution appends transition({ when })
- *     predicates; the foreground's gateTransitions reads the array after the
- *     match, and a stale HIT (which replays the stored transition) must not
- *     evaluate this render's predicates.
  *   - _metricsStore: undefined, and the DSL store below has `metrics` unset
  *     (track() reads that one), so nothing lands on the foreground's perf
  *     timeline. ctx.Store.run closes over ctx.Store, so the derived store
@@ -156,6 +153,7 @@ export async function rerenderAndCacheRoute<TEnv>(
   cacheScope: CacheScope,
   routerCtx: RouterContext<TEnv>,
 ): Promise<number> {
+  const start = executionStart();
   const handleStore = routerCtx.createHandleStore();
   // Response writes land in a throwaway context nothing merges or drains. Its
   // mutators are closures over its own stub, and they keep the same guards.
@@ -172,7 +170,6 @@ export async function rerenderAndCacheRoute<TEnv>(
     }),
     {
       _handleStore: handleStore,
-      _transitionWhen: [],
       _metricsStore: undefined,
       _onResponseCallbacks: [],
       header: sink.header,
@@ -253,6 +250,7 @@ export async function rerenderAndCacheRoute<TEnv>(
       ctx.matched.params,
       segments,
       ctx.isIntercept,
+      start,
     );
     return segments.length;
   });

package/src/router/match-middleware/cache-lookup.ts

@@ -92,12 +92,14 @@
  *   - Action context (if POST)
  */
 import type { InternalHandlerContext, ResolvedSegment } from "../../types.js";
+import type { OwnedPushDelivery } from "../../cache/handle-snapshot.js";
 import type { EntryData } from "../../server/context.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
 import { getRouterContext, type RouterContext } from "../router-context.js";
 import { observeEvent } from "../instrument.js";
 import { pushRevalidationTraceEntry, isTraceActive } from "../logging.js";
 import { treeHasStreaming } from "./segment-resolution.js";
+import { liveLaneLoaderIds } from "../segment-resolution/loader-cache.js";
 import type { PrerenderStore, PrerenderEntry } from "../../prerender/store.js";
 import {
   _getRequestContext,
@@ -297,8 +299,7 @@ async function* yieldFromStore<TEnv>(
       !paramsChanged &&
       ctx.clientSegmentSet.has(segment.id)
     ) {
-      segment.component = null;
-      segment.loading = undefined;
+      keepClientSegment(segment);
     }
     yield segment;
   }
@@ -405,6 +406,21 @@ async function* tryPrerenderLookup<TEnv>(
   return true;
 }
 
+/**
+ * Keep the client's copy of a stored (runtime cache, prerender, or shell
+ * replay) segment this navigation does not re-render. collectMatchResult
+ * (match-result.ts) omits a null-component segment the client holds, as the
+ * live partial path omits a segment whose revalidation said no
+ * (segment-resolution/revalidation.ts).
+ *
+ * A transition({ when }) is no exception: it is decided in the browser for
+ * kept segments too, so no segment is re-sent to carry a decision (#986).
+ */
+function keepClientSegment(segment: ResolvedSegment): void {
+  segment.component = null;
+  segment.loading = undefined;
+}
+
 /**
  * Async generator middleware type
  */
@@ -531,14 +547,24 @@ export function withCacheLookup<TEnv>(
     }
 
     // A record's loader-owned handle values claim their loader, so its own
-    // cache() HIT does not replay them again (restoreHandles).
-    const claimLoaderPushes = (ctx.handlerContext as InternalHandlerContext)
-      ._claimLoaderPushes;
+    // cache() HIT does not replay them again (restoreHandles). A document
+    // HIT tail restores a bake-lane owner's values as the prelude's, unclaimed:
+    // they stand against any later push of that loader
+    // (HandleStore.pushRestored). An owner the route runs on the live lane is
+    // a hole, so its live run still replaces them, even inside a restored
+    // loader's body.
+    const ownedPushes: OwnedPushDelivery = {
+      claim: (ctx.handlerContext as InternalHandlerContext)._claimLoaderPushes,
+    };
+    if (tailMarker) {
+      ownedPushes.liveLane = liveLaneLoaderIds(ctx.entries);
+      ownedPushes.restore = tailMarker.docTail === true;
+    }
     const explicitLookup = await ctx.cacheScope.lookupRouteDetailed(
       ctx.pathname,
       ctx.matched.params,
       ctx.isIntercept,
-      claimLoaderPushes,
+      ownedPushes,
     );
     let cacheResult =
       explicitLookup.status === "hit" ? explicitLookup.result : null;
@@ -582,7 +608,7 @@ export function withCacheLookup<TEnv>(
           ctx.pathname,
           ctx.matched.params,
           ctx.isIntercept,
-          claimLoaderPushes,
+          ownedPushes,
         );
       } else if (explicitLookup.status === "bypass") {
         // condition() refused at lookup time (the gate only pre-decides the
@@ -675,7 +701,6 @@ export function withCacheLookup<TEnv>(
       ...liveMatchedIds,
       ...cacheResult.segments.map((s) => s.id),
     ];
-    const pprTransitionDecisions = pipelineReqCtx?._pprTransitionDecisions;
 
     const canCheckSegmentRevalidation =
       !ctx.isFullMatch &&
@@ -751,13 +776,7 @@ export function withCacheLookup<TEnv>(
             reason: "cached-no-rules",
           });
         }
-        // A PPR transition decision must reach the client even when this cached
-        // segment otherwise needs no update. Keep its replayed component so the
-        // partial result retains the segment for gateTransitions().
-        if (!pprTransitionDecisions?.has(segment.id)) {
-          segment.component = null;
-          segment.loading = undefined;
-        }
+        keepClientSegment(segment);
         yield segment;
         continue;
       }
@@ -789,10 +808,7 @@ export function withCacheLookup<TEnv>(
         shouldRevalidate,
       });
 
-      if (!shouldRevalidate && !pprTransitionDecisions?.has(segment.id)) {
-        segment.component = null;
-        segment.loading = undefined;
-      }
+      if (!shouldRevalidate) keepClientSegment(segment);
 
       yield segment;
     }

package/src/router/match-middleware/cache-store.ts

@@ -106,11 +106,9 @@ import {
   type RequestContext,
 } from "../../server/request-context.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
-import {
-  createShellImplicitDocScope,
-  resolveCacheTags,
-} from "../../cache/cache-scope.js";
+import { createShellImplicitDocScope } from "../../cache/cache-scope.js";
 import { recordSegmentTags } from "../../cache/cache-tag.js";
+import { executionStart } from "../../cache/tag-invalidation.js";
 import { getRouterContext } from "../router-context.js";
 import { debugLog, debugWarn, getOrCreateRequestId } from "../logging.js";
 import { INTERNAL_RANGO_DEBUG } from "../../internal-debug.js";
@@ -131,6 +129,9 @@ export function withCacheStore<TEnv>(
     source: AsyncGenerator<ResolvedSegment>,
   ): AsyncGenerator<ResolvedSegment> {
     const ms = ctx.metricsStore;
+    // Before the lookup and the handlers below it run: the record's write
+    // gate (#977, CacheScope.cacheRoute).
+    const renderStart = executionStart();
 
     const allSegments: ResolvedSegment[] = [];
     for await (const segment of source) {
@@ -266,6 +267,10 @@ export function withCacheStore<TEnv>(
             ctx.matched.params,
             allSegmentsToCache,
             ctx.isIntercept,
+            // A capture's doc record lives only in the shell entry, which
+            // putShell gates by the capture start; skipping it here would
+            // read as a render that produced no record.
+            cacheScope.isShellImplicitDocScope ? undefined : renderStart,
           );
           if (INTERNAL_RANGO_DEBUG) {
             const dur = performance.now() - start;
@@ -341,13 +346,14 @@ function recordShellCaptureDocRecord<TEnv>(
   if (!scope.allowsCache("write")) return;
 
   const docScope = createShellImplicitDocScope(marker);
-  // The route scope's cache({ tags }) describe these segments too: on its
-  // HIT they arrive with the replayed record (recordSegmentTags in
-  // lookupRouteDetailed); on a fresh render they are recorded here, so the
-  // doc record, and the shell taking its tags, carries them either way.
+  // The route scope's cache({ tags }), and its enclosing scopes' (#974),
+  // describe these segments too: on its HIT they arrive with the replayed
+  // record (recordSegmentTags in lookupRouteDetailed); on a fresh render they
+  // are recorded here, so the doc record, and the shell taking its tags,
+  // carries them either way.
   recordSegmentTags(
     segments.map((s) => s.id),
-    resolveCacheTags(scope.config, requestCtx),
+    scope.resolveTags(requestCtx),
     requestCtx,
   );
   // Through onResponse, like the implicit scope's own write: the capture

package/src/router/match-result.ts

@@ -281,6 +281,7 @@ export function buildMatchResult<TEnv>(
     routeName: ctx.routeKey,
     slots: Object.keys(state.slots).length > 0 ? state.slots : undefined,
     ...(interceptTargets.length > 0 ? { interceptTargets } : {}),
+    ...(ctx.interceptTargeted ? { interceptTargeted: true } : {}),
     routeMiddleware:
       ctx.routeMiddleware.length > 0 ? ctx.routeMiddleware : undefined,
   };

package/src/router/middleware.ts

@@ -31,7 +31,7 @@ import {
 } from "../cache/taint.js";
 import { getCacheExecScope } from "../cache/cache-exec-scope.js";
 import { assertNonCacheableReadAllowed } from "../server/context.js";
-import { assertThemeReadAllowed } from "../server/cookie-store.js";
+import { readGuardedTheme } from "../server/cookie-store.js";
 import type { Theme } from "../theme/types.js";
 
 // Re-export types consumed through this module's path.
@@ -52,10 +52,7 @@ export type {
  */
 const MIDDLEWARE_THEME_DESCRIPTOR: PropertyDescriptor = {
   get(): Theme | undefined {
-    const reqCtx = _getRequestContext();
-    if (!reqCtx?._themeConfig) return undefined;
-    assertThemeReadAllowed(reqCtx, "ctx.theme");
-    return reqCtx._readTheme();
+    return readGuardedTheme(_getRequestContext(), "ctx.theme");
   },
   enumerable: false,
   configurable: true,

package/src/router/navigation-snapshot.ts

@@ -1,3 +1,4 @@
+import { requestHeaders } from "../server/request-headers.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
 
 export interface NavigationSnapshot {
@@ -40,8 +41,8 @@ export interface ResolveNavigationDeps {
  */
 export function getNavigationContextHeader(request: Request): string | null {
   return (
-    request.headers.get("X-RSC-Router-Client-Path") ||
-    request.headers.get("Referer")
+    requestHeaders(request).get("X-RSC-Router-Client-Path") ||
+    requestHeaders(request).get("Referer")
   );
 }
 
@@ -59,7 +60,7 @@ export function prerenderStoreShortCircuits(
   pr: true | undefined,
   request: Request,
 ): boolean {
-  return pr === true && !request.headers.get("X-RSC-HMR");
+  return pr === true && !requestHeaders(request).get("X-RSC-HMR");
 }
 
 /**
@@ -71,7 +72,7 @@ export function prerenderStoreShortCircuits(
  * request would report `prerender-store` for an artifact that cannot serve.
  */
 export function getInterceptSourceHeader(request: Request): string | null {
-  return request.headers.get("X-RSC-Router-Intercept-Source");
+  return requestHeaders(request).get("X-RSC-Router-Intercept-Source");
 }
 
 export async function resolveNavigation(
@@ -85,7 +86,7 @@ export async function resolveNavigation(
   const stale = url.searchParams.get("_rsc_stale") === "true";
   const previousUrl = getNavigationContextHeader(request);
   const interceptSourceUrl = getInterceptSourceHeader(request);
-  const isHmr = !!request.headers.get("X-RSC-HMR");
+  const isHmr = !!requestHeaders(request).get("X-RSC-HMR");
 
   if (!previousUrl) {
     return null;