@rangojs/router 0.17.0 → 0.19.0

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,
@@ -107,6 +109,7 @@ import {
   createShellImplicitDocScope,
   type CacheScope,
 } from "../../cache/cache-scope.js";
+import { ShellRecordUnavailableError } from "../../cache/shell-snapshot.js";
 import { prerenderStoreShortCircuits } from "../navigation-snapshot.js";
 import { paramsEqual } from "../params-util.js";
 
@@ -296,8 +299,7 @@ async function* yieldFromStore<TEnv>(
       !paramsChanged &&
       ctx.clientSegmentSet.has(segment.id)
     ) {
-      segment.component = null;
-      segment.loading = undefined;
+      keepClientSegment(segment);
     }
     yield segment;
   }
@@ -404,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
  */
@@ -508,6 +525,15 @@ export function withCacheLookup<TEnv>(
       }
     }
 
+    // A document HIT tail replays the handler layer through the implicit doc
+    // scope and never runs a handler: without that scope (a context that lost
+    // the marker before the scope resolved), fail like a lookup miss instead
+    // of falling through to the handlers below.
+    const tailMarker = pipelineReqCtx?._shellImplicitCache;
+    if (tailMarker?.docTail && !ctx.cacheScope?.isShellImplicitDocScope) {
+      throw new ShellRecordUnavailableError(tailMarker.fixedDocKey);
+    }
+
     if (ctx.isAction || !ctx.cacheScope?.enabled) {
       yield* source;
       if (ms) {
@@ -521,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;
@@ -572,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
@@ -585,6 +621,13 @@ export function withCacheLookup<TEnv>(
     }
 
     if (!cacheResult) {
+      // A document shell HIT tail replays the handler layer from the entry's
+      // doc record and must never run a handler behind the committed prelude:
+      // a record that did not hit (it failed to decode, or the entry lost it)
+      // ends the tail here; serveShellHit degrades the response.
+      if (replayMarker?.docTail) {
+        throw new ShellRecordUnavailableError(replayMarker.fixedDocKey);
+      }
       yield* source;
       if (ms) {
         ms.metrics.push({
@@ -658,7 +701,6 @@ export function withCacheLookup<TEnv>(
       ...liveMatchedIds,
       ...cacheResult.segments.map((s) => s.id),
     ];
-    const pprTransitionDecisions = pipelineReqCtx?._pprTransitionDecisions;
 
     const canCheckSegmentRevalidation =
       !ctx.isFullMatch &&
@@ -734,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;
       }
@@ -772,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

@@ -107,6 +107,8 @@ import {
 } from "../../server/request-context.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.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";
@@ -127,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) {
@@ -262,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;
@@ -316,9 +325,10 @@ export function withCacheStore<TEnv>(
  * store) on the no-eligible-snapshot path, so the lookup's own refusal is
  * still surfaced while the fallback has nothing to serve.
  *
- * Wrapped in requestCtx.waitUntil — during a capture that is the tracked-write
- * override, so captureAndStoreShell's settleWrites awaits the record before
- * draining the snapshot.
+ * Registered through requestCtx.onResponse, which a capture fires only after
+ * the handler pushes settle (settleCaptureRecord), and wrapped in
+ * requestCtx.waitUntil — during a capture that is the tracked-write override,
+ * so settleWrites awaits the record before the capture reads it.
  */
 function recordShellCaptureDocRecord<TEnv>(
   ctx: MatchContext<TEnv>,
@@ -336,12 +346,28 @@ function recordShellCaptureDocRecord<TEnv>(
   if (!scope.allowsCache("write")) return;
 
   const docScope = createShellImplicitDocScope(marker);
-  requestCtx.waitUntil(() =>
-    docScope.cacheRoute(
-      ctx.pathname,
-      ctx.matched.params,
-      segments,
-      ctx.isIntercept,
-    ),
+  // 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),
+    scope.resolveTags(requestCtx),
+    requestCtx,
   );
+  // Through onResponse, like the implicit scope's own write: the capture
+  // fires these callbacks (settleCaptureRecord) only after the handler
+  // pushes settled, so the record's handle encode never races them.
+  requestCtx.onResponse((response) => {
+    requestCtx.waitUntil(() =>
+      docScope.cacheRoute(
+        ctx.pathname,
+        ctx.matched.params,
+        segments,
+        ctx.isIntercept,
+      ),
+    );
+    return response;
+  });
 }

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-types.ts

@@ -68,7 +68,12 @@ export interface MiddlewareContext<
 
   debugPerformance(): void;
 
-  theme?: Theme;
+  /**
+   * The visitor's theme (cookie or default); undefined without theme config.
+   * Guarded like `cookies()`: a read inside a `"use cache"` function throws
+   * (#971).
+   */
+  readonly theme?: Theme;
 
   setTheme?: (theme: Theme) => void;
 

package/src/router/middleware.ts

@@ -31,6 +31,8 @@ import {
 } from "../cache/taint.js";
 import { getCacheExecScope } from "../cache/cache-exec-scope.js";
 import { assertNonCacheableReadAllowed } from "../server/context.js";
+import { readGuardedTheme } from "../server/cookie-store.js";
+import type { Theme } from "../theme/types.js";
 
 // Re-export types consumed through this module's path.
 export type {
@@ -40,6 +42,22 @@ export type {
   MiddlewareFn,
 } from "./middleware-types.js";
 
+/**
+ * Middleware ctx.theme: the visitor's theme cookie, guarded like the handler
+ * ctx.theme and cookies() (#971, #946), so a read inside a "use cache"
+ * function the middleware calls throws. Non-enumerable like the handler and
+ * request-context getters: a spread of the ctx (inside a "use cache"
+ * function, say) does not read it. One shared descriptor, so every ctx keeps
+ * the same property shape.
+ */
+const MIDDLEWARE_THEME_DESCRIPTOR: PropertyDescriptor = {
+  get(): Theme | undefined {
+    return readGuardedTheme(_getRequestContext(), "ctx.theme");
+  },
+  enumerable: false,
+  configurable: true,
+};
+
 const MIDDLEWARE_METRIC_DEPTH = 1;
 const POST_METRIC_MIN_DURATION_MS = 0.01;
 
@@ -320,10 +338,7 @@ export function createMiddlewareContext<TEnv>(
       responseHolder.response.headers.set(name, value);
     },
 
-    get theme(): MiddlewareContext<TEnv>["theme"] {
-      return _getRequestContext()?.theme;
-    },
-
+    // theme: MIDDLEWARE_THEME_DESCRIPTOR, defined after this literal.
     get setTheme(): MiddlewareContext<TEnv>["setTheme"] {
       return _getRequestContext()?.setTheme;
     },
@@ -361,6 +376,7 @@ export function createMiddlewareContext<TEnv>(
       }
     },
   };
+  Object.defineProperty(ctx, "theme", MIDDLEWARE_THEME_DESCRIPTOR);
   (ctx as any)[NOCACHE_SYMBOL] = true;
   return ctx;
 }

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;

package/src/router/prerender-match.ts

@@ -223,6 +223,8 @@ export async function matchForPrerender<TEnv = any>(
       res: stubRes,
       cookie: () => undefined,
       cookies: () => ({}),
+      _readCookie: () => undefined,
+      _readCookies: () => ({}),
       setCookie: () => {},
       deleteCookie: () => {},
       header: () => {},
@@ -230,6 +232,7 @@ export async function matchForPrerender<TEnv = any>(
       _setStatus: () => {},
       _rotateStateCookie: () => {},
       _setKeepCacheDirective: () => {},
+      _setFreshReadsCookie: () => {},
       use: (() => {
         throw new Error("use() not available during pre-rendering");
       }) as any,
@@ -239,6 +242,8 @@ export async function matchForPrerender<TEnv = any>(
       waitUntil: () => {},
       onResponse: () => {},
       _onResponseCallbacks: [],
+      // No theme at build time: no request cookie.
+      _readTheme: () => undefined,
       setLocationState() {},
       _locationState: undefined,
       _renderBarrier: Promise.resolve(),
@@ -523,6 +528,8 @@ export async function renderStaticSegment<TEnv = any>(
     res: stubRes,
     cookie: () => undefined,
     cookies: () => ({}),
+    _readCookie: () => undefined,
+    _readCookies: () => ({}),
     setCookie: () => {},
     deleteCookie: () => {},
     header: () => {},
@@ -530,6 +537,7 @@ export async function renderStaticSegment<TEnv = any>(
     _setStatus: () => {},
     _rotateStateCookie: () => {},
     _setKeepCacheDirective: () => {},
+    _setFreshReadsCookie: () => {},
     use: (() => {
       throw new Error("use() not available during static pre-rendering");
     }) as any,
@@ -539,6 +547,8 @@ export async function renderStaticSegment<TEnv = any>(
     waitUntil: () => {},
     onResponse: () => {},
     _onResponseCallbacks: [],
+    // No theme at build time: no request cookie.
+    _readTheme: () => undefined,
     setLocationState() {},
     _locationState: undefined,
     _renderBarrier: Promise.resolve(),

package/src/router/request-classification.ts

@@ -15,6 +15,7 @@
  * Builds on RouteSnapshot from route-snapshot.ts.
  */
 
+import { requestHeaders } from "../server/request-headers.js";
 import { RouteNotFoundError } from "../errors.js";
 import type { EntryData } from "../server/context.js";
 import type { CollectedMiddleware } from "./middleware-types.js";
@@ -149,10 +150,11 @@ export async function classifyRequest<TEnv = any>(
 ): Promise<RequestPlan<TEnv>> {
   const pathname = url.pathname;
   const isAction =
-    request.headers.has("rsc-action") || url.searchParams.has("_rsc_action");
+    requestHeaders(request).has("rsc-action") ||
+    url.searchParams.has("_rsc_action");
   const isLoaderFetch = url.searchParams.has("_rsc_loader");
   const isPartialReq = url.searchParams.has("_rsc_partial");
-  const contentType = request.headers.get("content-type") || "";
+  const contentType = requestHeaders(request).get("content-type") || "";
   const isFormSubmission =
     contentType.includes("multipart/form-data") ||
     contentType.includes("application/x-www-form-urlencoded");
@@ -176,7 +178,7 @@ export async function classifyRequest<TEnv = any>(
   ) {
     let reloadUrl = stripInternalParams(url).toString();
     if (isAction) {
-      const referer = request.headers.get("referer");
+      const referer = requestHeaders(request).get("referer");
       if (referer) {
         try {
           const refererUrl = new URL(referer);
@@ -248,7 +250,8 @@ export async function classifyRequest<TEnv = any>(
   }
 
   const actionId =
-    request.headers.get("rsc-action") || url.searchParams.get("_rsc_action");
+    requestHeaders(request).get("rsc-action") ||
+    url.searchParams.get("_rsc_action");
 
   const hasVariants =
     snapshot.matched.negotiateVariants &&

package/src/router/router-options.ts

@@ -518,7 +518,10 @@ export interface RangoOptions<TEnv = any> {
    *
    * Controls how long prefetch responses are kept in the client-side
    * in-memory cache and sets `Cache-Control: private, max-age=<ttl>`
-   * on server responses for CDN/edge caching.
+   * on prefetch responses, so the browser's HTTP cache may reuse them
+   * (`private`: shared caches such as a CDN do not store them). A route an
+   * intercept targets gets no prefetch `Cache-Control`: whether its
+   * response is the modal or the full page depends on the source page.
    *
    * The cache is automatically invalidated on server actions regardless
    * of TTL, so this is primarily a staleness safety net.

package/src/router/segment-resolution/fresh.ts

@@ -37,7 +37,7 @@ import { applyViewTransitionDefault } from "./view-transition-default.js";
 import { _getRequestContext } from "../../server/request-context.js";
 import { getRouterContext } from "../router-context.js";
 import { observeStreamedHandler } from "./streamed-handler-telemetry.js";
-import { observeHandler } from "../instrument.js";
+import { observeSegmentHandler } from "../instrument.js";
 import {
   track,
   RangoContext,
@@ -173,9 +173,7 @@ export async function resolveLoaders<TEnv>(
               // bakes at capture regardless of the entry's loading() lane
               // (loader-cache.ts capture branch) and its HIT-tail seed
               // overlay needs the same key.
-              bakeLane || loaderEntry.awaitBeforeFlush === true
-                ? segmentId
-                : null,
+              bakeLane || loaderEntry.bake === true ? segmentId : null,
             ),
           ),
           entry,
@@ -223,7 +221,7 @@ export async function resolveLoaders<TEnv>(
           loaderEntry,
           ctx,
           ctx.pathname,
-          bakeLane || loaderEntry.awaitBeforeFlush === true ? segmentId : null,
+          bakeLane || loaderEntry.bake === true ? segmentId : null,
         ),
       ),
       entry,
@@ -326,7 +324,6 @@ export async function resolveSegment<TEnv>(
       transition: applyViewTransitionDefault(
         entry.transition,
         deps.viewTransitionDefault,
-        entry.shortCode,
       ),
       params,
       belongsToRoute: false,
@@ -396,7 +393,7 @@ export async function resolveSegment<TEnv>(
       const doneRouteHandler = track(`handler:${entry.id}`, 2);
       if (entry.loading) {
         const result = handleHandlerResult(
-          observeHandler(entry.id, handler, context),
+          observeSegmentHandler(entry.shortCode, entry.id, handler, context),
         );
         if (result instanceof Promise) {
           warnOnStreamedResponse(result, entry.id);
@@ -420,7 +417,12 @@ export async function resolveSegment<TEnv>(
         }
       } else {
         component = handleHandlerResult(
-          await observeHandler(entry.id, handler, context),
+          await observeSegmentHandler(
+            entry.shortCode,
+            entry.id,
+            handler,
+            context,
+          ),
         );
         doneRouteHandler();
       }
@@ -471,7 +473,6 @@ export async function resolveSegment<TEnv>(
       transition: applyViewTransitionDefault(
         entry.transition,
         deps.viewTransitionDefault,
-        entry.shortCode,
       ),
       params,
       belongsToRoute: true,
@@ -560,7 +561,6 @@ export async function resolveOrphanLayout<TEnv>(
     transition: applyViewTransitionDefault(
       orphan.transition,
       deps.viewTransitionDefault,
-      orphan.shortCode,
     ),
     ...(orphan.mountPath ? { mountPath: orphan.mountPath } : {}),
   });
@@ -670,7 +670,12 @@ export async function resolveParallelEntry<TEnv>(
       if (hasLoadingFallback) {
         const result =
           typeof handler === "function"
-            ? observeHandler(`${parallelEntry.id}.${slot}`, handler, context)
+            ? observeSegmentHandler(
+                `${parentShortCode}.${slot}`,
+                `${parallelEntry.id}.${slot}`,
+                handler,
+                context,
+              )
             : handler;
         if (result instanceof Promise) {
           result.finally(doneParallelHandler).catch(() => {});
@@ -694,7 +699,8 @@ export async function resolveParallelEntry<TEnv>(
       } else {
         component =
           typeof handler === "function"
-            ? await observeHandler(
+            ? await observeSegmentHandler(
+                `${parentShortCode}.${slot}`,
                 `${parallelEntry.id}.${slot}`,
                 handler,
                 context,
@@ -714,7 +720,6 @@ export async function resolveParallelEntry<TEnv>(
       transition: applyViewTransitionDefault(
         parallelEntry.transition,
         deps.viewTransitionDefault,
-        `${parentShortCode}.${slot}`,
       ),
       params,
       slot,

package/src/router/segment-resolution/helpers.ts

@@ -29,7 +29,7 @@ import type {
 import type { SegmentResolutionDeps } from "../types.js";
 import { debugLog } from "../logging.js";
 import { tryStaticLookup } from "./static-store.js";
-import { observeHandler } from "../instrument.js";
+import { observeSegmentHandler } from "../instrument.js";
 import type { TelemetrySink } from "../telemetry.js";
 import { resolveSink, safeEmit, getRequestId } from "../telemetry.js";
 
@@ -175,7 +175,9 @@ export async function resolveLayoutComponent<TEnv>(
   // by track("handler:<id>") at the call site). handleHandlerResult stays OUTSIDE
   // the span so a handler that returns a Response (redirect control flow, which it
   // rethrows) is not recorded as a span error — mirrors the route-handler sites.
-  return handleHandlerResult(await observeHandler(entry.id, handler, context));
+  return handleHandlerResult(
+    await observeSegmentHandler(entry.shortCode, entry.id, handler, context),
+  );
 }
 
 // ---------------------------------------------------------------------------