@rangojs/router 0.1.0 → 0.2.0

package/src/route-map-builder.ts

@@ -12,11 +12,6 @@ let globalRouteMap: Record<string, string> = {};
 
 let cachedManifest: Record<string, string> | null = null;
 
-let cachedPrecomputedEntries: Array<{
-  staticPrefix: string;
-  routes: Record<string, string>;
-}> | null = null;
-
 /**
  * Register routes into the global route map.
  * Routes are merged with any existing registered routes.
@@ -87,43 +82,6 @@ export function clearCachedManifest(): void {
   cachedManifest = null;
 }
 
-/**
- * Set pre-computed route entries from build-time data.
- *
- * Each entry corresponds to a leaf node in the prefix tree (no nested includes).
- * evaluateLazyEntry() checks these before running the handler, avoiding the
- * 5-50ms cost of handler evaluation for route matching on the first request.
- *
- * @param entries - Array of { staticPrefix, routes } from build-time prefix tree leaves
- */
-export function setPrecomputedEntries(
-  entries: Array<{
-    staticPrefix: string;
-    routes: Record<string, string>;
-  }> | null,
-): void {
-  cachedPrecomputedEntries = entries;
-}
-
-/**
- * Get pre-computed route entries (if available)
- */
-export function getPrecomputedEntries(): typeof cachedPrecomputedEntries {
-  return cachedPrecomputedEntries;
-}
-
-// Route trie for O(path_length) matching at runtime.
-// Built at build time from the route manifest and serialized into the virtual module.
-let cachedRouteTrie: import("./build/route-trie.js").TrieNode | null = null;
-
-export function setRouteTrie(trie: typeof cachedRouteTrie): void {
-  cachedRouteTrie = trie;
-}
-
-export function getRouteTrie(): typeof cachedRouteTrie {
-  return cachedRouteTrie;
-}
-
 // Per-router isolated data: each router gets its own manifest, trie, and
 // precomputed entries so multi-router setups (e.g. site + admin via
 // createHostRouter()) don't see each other's routes.
@@ -146,14 +104,18 @@ const perRouterPrecomputedEntriesMap: Map<
 export function clearAllRouterData(): void {
   globalRouteMap = {};
   cachedManifest = null;
-  cachedPrecomputedEntries = null;
-  cachedRouteTrie = null;
   rootScopeRoutes.clear();
+  perRouterRootScopeRoutes.clear();
   globalSearchSchemas.clear();
+  perRouterSearchSchemas.clear();
   perRouterManifestMap.clear();
   perRouterTrieMap.clear();
   perRouterPrecomputedEntriesMap.clear();
   authoritativeTrieRouters.clear();
+  // Clear the loader registry too: a loader that survives a clear closes over
+  // a module import whose data predates the clear, and re-running it would
+  // re-install that stale trie as authoritative.
+  routerManifestLoaders.clear();
 }
 
 export function setRouterManifest(
@@ -229,9 +191,9 @@ export async function ensureRouterManifest(routerId: string): Promise<void> {
   // name->path map is pre-set by the eager virtual module's
   // setRouterManifest() and never comes from the loader). Gating on the
   // manifest instead would let the loader be skipped while the per-router
-  // trie is missing, and findMatch would fall back to the global merged
-  // trie — which contains routes from ALL routers and breaks multi-router
-  // setups.
+  // trie is missing, and findMatch would fall back to insertion-order regex
+  // matching — which mishandles wildcard priority (catch-alls match before
+  // specific routes).
   if (perRouterTrieMap.has(routerId)) return;
   const loader = routerManifestLoaders.get(routerId);
   if (loader) {
@@ -265,7 +227,16 @@ export function waitForManifestReady(): Promise<void> | null {
 // Tracks whether each route is at root scope (no named include boundary above).
 // Used by dot-local reverse resolution to decide whether bare-name fallback
 // is allowed after scoped lookups are exhausted.
+//
+// Both this and the search-schema registry below are keyed by route NAME and
+// registered by path() at evaluation time. Two routers can legally declare the
+// same route name (per-router manifests keep them apart), so each registry has
+// a per-router tier consulted first; the global tier is the fallback for
+// contexts with no router identity (single-router apps, unit tests, evaluation
+// outside generateManifestFull). Without the per-router tier, the
+// last-evaluated router silently won for BOTH routers.
 const rootScopeRoutes: Map<string, boolean> = new Map();
+const perRouterRootScopeRoutes: Map<string, Map<string, boolean>> = new Map();
 
 /**
  * Register whether a route is at root scope.
@@ -274,29 +245,65 @@ const rootScopeRoutes: Map<string, boolean> = new Map();
 export function registerRouteRootScope(
   routeName: string,
   rootScoped: boolean,
+  routerId?: string,
 ): void {
   rootScopeRoutes.set(routeName, rootScoped);
+  if (routerId) {
+    let perRouter = perRouterRootScopeRoutes.get(routerId);
+    if (!perRouter) {
+      perRouter = new Map();
+      perRouterRootScopeRoutes.set(routerId, perRouter);
+    }
+    perRouter.set(routeName, rootScoped);
+  }
 }
 
 /**
  * Check if a route is at root scope.
  * Returns undefined if the route has not been registered (e.g. in unit tests).
  */
-export function isRouteRootScoped(routeName: string): boolean | undefined {
+export function isRouteRootScoped(
+  routeName: string,
+  routerId?: string,
+): boolean | undefined {
+  if (routerId) {
+    const scoped = perRouterRootScopeRoutes.get(routerId)?.get(routeName);
+    if (scoped !== undefined) return scoped;
+  }
   return rootScopeRoutes.get(routeName);
 }
 
 import type { SearchSchema } from "./search-params.js";
 
 const globalSearchSchemas: Map<string, SearchSchema> = new Map();
+const perRouterSearchSchemas: Map<
+  string,
+  Map<string, SearchSchema>
+> = new Map();
 
 export function registerSearchSchema(
   routeName: string,
   schema: SearchSchema,
+  routerId?: string,
 ): void {
   globalSearchSchemas.set(routeName, schema);
+  if (routerId) {
+    let perRouter = perRouterSearchSchemas.get(routerId);
+    if (!perRouter) {
+      perRouter = new Map();
+      perRouterSearchSchemas.set(routerId, perRouter);
+    }
+    perRouter.set(routeName, schema);
+  }
 }
 
-export function getSearchSchema(routeName: string): SearchSchema | undefined {
+export function getSearchSchema(
+  routeName: string,
+  routerId?: string,
+): SearchSchema | undefined {
+  if (routerId) {
+    const schema = perRouterSearchSchemas.get(routerId)?.get(routeName);
+    if (schema !== undefined) return schema;
+  }
   return globalSearchSchemas.get(routeName);
 }

package/src/router/handler-context.ts

@@ -96,7 +96,7 @@ function resolveRouteName(
     // Resolution order: explicit param > scope registry > heuristic.
     const isRootScoped =
       rootScoped ??
-      isRouteRootScoped(currentRoutePrefix) ??
+      isRouteRootScoped(currentRoutePrefix, _getRequestContext()?._routerId) ??
       !currentRoutePrefix.includes(".");
     if (isRootScoped) {
       if (routeMap[lookupName] !== undefined) {
@@ -208,7 +208,9 @@ export function createHandlerContext<TEnv>(
   const variables: any = requestContext?._variables ?? {};
 
   // If route has a search schema, parse URLSearchParams into typed object
-  const searchSchema = routeName ? getSearchSchema(routeName) : undefined;
+  const searchSchema = routeName
+    ? getSearchSchema(routeName, requestContext?._routerId)
+    : undefined;
   const resolvedSearchParams = searchSchema
     ? parseSearchParams(searchParams, searchSchema)
     : searchParams;
@@ -306,7 +308,9 @@ export function createHandlerContext<TEnv>(
       routeMap,
       routeName,
       params,
-      routeName ? isRouteRootScoped(routeName) : undefined,
+      routeName
+        ? isRouteRootScoped(routeName, requestContext?._routerId)
+        : undefined,
     ),
     passthrough: createPrerenderPassthroughFn(false, isPassthroughRoute),
     _responseType: responseType,
@@ -399,7 +403,9 @@ export function createPrerenderContext<TEnv>(
       routeMap,
       routeName,
       params,
-      routeName ? isRouteRootScoped(routeName) : undefined,
+      routeName
+        ? isRouteRootScoped(routeName, _getRequestContext()?._routerId)
+        : undefined,
     ),
     passthrough: createPrerenderPassthroughFn(
       true,
@@ -496,7 +502,9 @@ export function createStaticContext<TEnv>(
       routeMap,
       routeName,
       undefined,
-      routeName ? isRouteRootScoped(routeName) : undefined,
+      routeName
+        ? isRouteRootScoped(routeName, _getRequestContext()?._routerId)
+        : undefined,
     ),
     _routeName: routeName,
   } as InternalHandlerContext<any, TEnv>;

package/src/router/lazy-includes.ts

@@ -171,6 +171,7 @@ function runExpansion<TEnv = any>(
       counters: lazyCounters,
       cacheProfiles: lazyContext?.cacheProfiles,
       rootScoped: lazyContext?.rootScoped,
+      routerId: lazyContext?.routerId,
       includeScope: lazyContext?.includeScope,
     },
     () => {

package/src/router/match-api.ts

@@ -184,9 +184,8 @@ export async function createMatchContextForFull<TEnv>(
     },
     isSameRouteNavigation: false,
     interceptResult: null,
-    // Shell fast path: a capture or an eligible HIT tail may substitute an
-    // implicit doc-level scope (marker-gated; a route-derived scope wins).
-    // Full matches only — partial navigations never serve a shell.
+    // Shell fast path: a capture or an eligible document/navigation HIT may
+    // substitute an implicit doc-level scope (a route-derived scope wins).
     cacheScope: resolveShellImplicitCacheScope(snapshot.cacheScope),
     isIntercept: false,
     actionContext: undefined,
@@ -426,7 +425,12 @@ export async function createMatchContextForPartial<TEnv>(
     interceptSelectorContext,
     isSameRouteNavigation: nav.isSameRouteNavigation,
     interceptResult,
-    cacheScope: snapshot.cacheScope,
+    // A normal-route navigation may replay a PPR shell's canonical segment
+    // snapshot. Intercepts remain source-dependent and always use their normal
+    // cache path.
+    cacheScope: isIntercept
+      ? snapshot.cacheScope
+      : resolveShellImplicitCacheScope(snapshot.cacheScope),
     isIntercept,
     actionContext,
     isAction,

package/src/router/match-handlers.ts

@@ -1,12 +1,19 @@
 import type { ReactNode } from "react";
 import { INTERNAL_RANGO_DEBUG } from "../internal-debug.js";
 import { sanitizeError } from "../errors";
-import type { ErrorInfo, ErrorPhase, MatchResult } from "../types";
 import type {
-  EntryData,
-  InterceptEntry,
-  InterceptSelectorContext,
-} from "../server/context";
+  ErrorBoundaryHandler,
+  ErrorInfo,
+  ErrorPhase,
+  MatchResult,
+  NotFoundBoundaryHandler,
+} from "../types";
+import {
+  isPprEntry,
+  type EntryData,
+  type InterceptEntry,
+  type InterceptSelectorContext,
+} from "../server/context.js";
 import type { MatchApiDeps } from "./types.js";
 import type { RouterContext } from "./router-context.js";
 import { runWithRouterContext } from "./router-context.js";
@@ -30,7 +37,6 @@ import {
   startRevalidationTrace,
   flushRevalidationTrace,
 } from "./logging.js";
-import type { ErrorBoundaryHandler, NotFoundBoundaryHandler } from "../types";
 import type { MiddlewareFn } from "./middleware.js";
 import {
   type TelemetrySink,
@@ -41,6 +47,7 @@ import {
   buildCacheSignalSegments,
 } from "./telemetry.js";
 import { _getRequestContext } from "../server/request-context.js";
+import { evaluatePprTransitionWhen } from "./transition-when.js";
 
 /**
  * Per-call telemetry lifecycle emitter for match()/matchPartial(). Each method
@@ -227,6 +234,35 @@ export function createMatchHandlers<TEnv = any>(
     if (reqCtx) reqCtx._cacheSignal = segments;
   };
 
+  const evaluatePprTransitionWhenForMatch = (
+    ctx: MatchContext<TEnv>,
+    isPartial: boolean,
+  ): 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,
+        }),
+    );
+  };
+
   async function createMatchContextForFull(
     request: Request,
     env: TEnv,
@@ -313,6 +349,7 @@ export function createMatchHandlers<TEnv = any>(
           }
 
           const ctx = result as MatchContext<TEnv>;
+          evaluatePprTransitionWhenForMatch(ctx, false);
 
           try {
             const state = createPipelineState();
@@ -424,6 +461,7 @@ export function createMatchHandlers<TEnv = any>(
               emitter.end(0, false);
               return null;
             }
+            evaluatePprTransitionWhenForMatch(ctx, true);
 
             if (isRouterDebugEnabled()) {
               startRevalidationTrace({

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

@@ -460,6 +460,8 @@ export function withCacheLookup<TEnv>(
     state.shouldRevalidate = cacheResult.shouldRevalidate;
     state.cachedSegments = cacheResult.segments;
     state.cachedMatchedIds = cacheResult.segments.map((s) => s.id);
+    const pprTransitionDecisions =
+      _getRequestContext()?._pprTransitionDecisions;
 
     const canCheckSegmentRevalidation =
       !ctx.isFullMatch &&
@@ -533,8 +535,13 @@ export function withCacheLookup<TEnv>(
             reason: "cached-no-rules",
           });
         }
-        segment.component = null;
-        segment.loading = undefined;
+        // 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;
+        }
         yield segment;
         continue;
       }
@@ -566,7 +573,7 @@ export function withCacheLookup<TEnv>(
         shouldRevalidate,
       });
 
-      if (!shouldRevalidate) {
+      if (!shouldRevalidate && !pprTransitionDecisions?.has(segment.id)) {
         segment.component = null;
         segment.loading = undefined;
       }

package/src/router/prerender-match.ts

@@ -34,6 +34,9 @@ import type {
 import type { RouteMatchResult } from "./pattern-matching.js";
 
 export interface PrerenderMatchDeps<TEnv = any> {
+  /** Owning router id; scopes bake-time root-scope/search-schema lookups the
+   *  same way reqCtx._routerId does at runtime (issue #762). */
+  routerId?: string;
   findMatch: (
     pathname: string,
   ) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
@@ -244,8 +247,13 @@ export async function matchForPrerender<TEnv = any>(
         deps.mergedRouteMap,
         matched.routeKey,
         matchedParams,
-        matched.routeKey ? isRouteRootScoped(matched.routeKey) : undefined,
+        matched.routeKey
+          ? isRouteRootScoped(matched.routeKey, deps.routerId)
+          : undefined,
       ),
+      // Scope the bake context's own lookups (createPrerenderContext reads it
+      // through the request ALS) per router as well.
+      _routerId: deps.routerId,
     };
 
     return runWithRequestContext(minimalRequestContext, async () => {
@@ -464,6 +472,8 @@ export async function renderStaticSegment<TEnv = any>(
   routeName?: string,
   buildEnv?: TEnv,
   devMode?: boolean,
+  routerId?: string,
+  rootScoped?: boolean,
 ): Promise<{ encoded: string; handles: string } | null> {
   const syntheticUrl = new URL("http://prerender/");
   const syntheticRequest = new Request(syntheticUrl);
@@ -514,8 +524,15 @@ export async function renderStaticSegment<TEnv = any>(
       mergedRouteMap,
       routeName,
       {},
-      routeName ? isRouteRootScoped(routeName) : undefined,
+      // Def-stamped value first: the collector passes the mount-time
+      // root-scope captured on the Static definition (stampStaticDefScope),
+      // which needs no registry lookup and survives name-prefix arguments.
+      rootScoped ??
+        (routeName ? isRouteRootScoped(routeName, routerId) : undefined),
     ),
+    // Scope the bake context's own lookups (createStaticContext reads it
+    // through the request ALS) per router as well.
+    _routerId: routerId,
   };
 
   return runWithRequestContext(minimalRequestContext, async () => {

package/src/router/router-interfaces.ts

@@ -419,6 +419,9 @@ export interface RangoInternal<
   /** @internal basename for runtime manifest generation */
   readonly __basename?: string;
 
+  /** @internal Cloudflare dev worker generation captured at construction. */
+  readonly __devDiscoveryEpoch?: number;
+
   /**
    * @internal Router-level error/notFound fallbacks (`createRouter` options),
    * exposed for the build-time clientChunks discovery so a `"use client"`
@@ -469,6 +472,7 @@ export interface RangoInternal<
     routeName?: string,
     buildEnv?: any,
     devMode?: boolean,
+    rootScoped?: boolean,
   ): Promise<{ encoded: string; handles: string } | null>;
 
   /**

package/src/router/segment-resolution/static-store.ts

@@ -11,14 +11,19 @@ import type { StaticStore } from "../../prerender/store.js";
 import type { SegmentHandleData } from "../../cache/types.js";
 
 // Lazy-initialized static store for production Static handler interception.
-// Remains undefined until first check; null means checked but no manifest.
-// When no __STATIC_MANIFEST exists (dev mode), set to null eagerly to avoid
-// the dynamic import() in ensureStaticDeps() which disrupts AsyncLocalStorage
-// in workerd/Cloudflare runtime.
-let _staticStore: StaticStore | null | undefined =
-  typeof globalThis !== "undefined" && globalThis.__STATIC_MANIFEST
-    ? undefined
-    : null;
+// undefined = not yet checked; null = checked, no manifest (dev mode, or an
+// app without Static handlers) — a permanent SYNCHRONOUS fast path: no await
+// may ever run on that path (an await per lookup disrupts AsyncLocalStorage
+// in workerd/Cloudflare runtime).
+//
+// The check happens on the FIRST LOOKUP, not at module eval: the manifest
+// loader global (__loadStaticManifestModule, bundle-postprocess.ts) is
+// assigned by the RSC entry's BODY, which runs after hoisted module imports
+// evaluate this file — an eval-time read here could never see it. The
+// pre-#760 eager `import "./__static-manifest.js"` existed precisely to beat
+// that hoisting; deferring the manifest module keeps its O(#Static handlers)
+// thunk table off the worker's cold-start path.
+let _staticStore: StaticStore | null | undefined = undefined;
 let _deserializeComponent: ((encoded: string) => Promise<unknown>) | undefined;
 let _decodeHandleValue:
   | typeof import("../../cache/handle-snapshot.js").decodeHandleValue
@@ -26,6 +31,18 @@ let _decodeHandleValue:
 
 async function ensureStaticDeps(): Promise<void> {
   if (_staticStore === undefined) {
+    // Evaluate the deferred manifest module (it assigns __STATIC_MANIFEST);
+    // support a pre-set __STATIC_MANIFEST too (tests, non-postprocess embeds).
+    if (
+      !globalThis.__STATIC_MANIFEST &&
+      globalThis.__loadStaticManifestModule
+    ) {
+      await globalThis.__loadStaticManifestModule();
+    }
+    if (!globalThis.__STATIC_MANIFEST) {
+      _staticStore = null;
+      return;
+    }
     const { createStaticStore } = await import("../../prerender/store.js");
     _staticStore = createStaticStore();
   }
@@ -52,8 +69,17 @@ export async function tryStaticLookup(
   handlerId: string,
   segmentId: string,
 ): Promise<ReactNode | undefined> {
-  // Fast path: already checked and no manifest available (dev mode or no Static handlers).
-  // Avoids await which can disrupt AsyncLocalStorage in workerd/Cloudflare runtime.
+  // Fast path: no manifest available (dev mode or no Static handlers).
+  // Latched SYNCHRONOUSLY — including on the very first call — so this path
+  // never awaits (an await here disrupts AsyncLocalStorage in
+  // workerd/Cloudflare runtime).
+  if (
+    _staticStore === undefined &&
+    !globalThis.__STATIC_MANIFEST &&
+    !globalThis.__loadStaticManifestModule
+  ) {
+    _staticStore = null;
+  }
   if (_staticStore === null) return undefined;
   await ensureStaticDeps();
   if (!_staticStore || !_deserializeComponent) return undefined;

package/src/router/segment-resolution/view-transition-default.ts

@@ -23,10 +23,9 @@ import { getRequestContext } from "../../server/request-context.js";
  * gate, which also avoids needless object allocation and payload growth.
  *
  * `when`: a server-only predicate. It is STRIPPED from the returned config (a
- * function cannot cross Flight or the segment cache) and recorded on the request
- * context keyed by `segmentId`, so rsc-rendering can evaluate it post-handler —
- * outside any cache scope — and drop this segment's transition when it returns
- * false. Used by both the fresh and revalidation resolution paths.
+ * function cannot cross Flight or the segment cache). PPR routes evaluate it
+ * from the manifest before the pipeline; other routes record it here for the
+ * existing post-handler gate. Used by both fresh and revalidation resolution.
  */
 export function applyViewTransitionDefault(
   transition: EntryData["transition"],
@@ -39,7 +38,12 @@ export function applyViewTransitionDefault(
     if (segmentId !== undefined) {
       try {
         const ctx = getRequestContext();
-        (ctx._transitionWhen ??= []).push({ id: segmentId, when: result.when });
+        if (!ctx._pprTransitionDecisions?.has(segmentId)) {
+          (ctx._transitionWhen ??= []).push({
+            id: segmentId,
+            when: result.when,
+          });
+        }
       } catch {
         // No active request context (e.g. a unit test calling this util
         // directly). Skip collection; the strip below still applies so the

package/src/router/transition-when.ts

@@ -0,0 +1,76 @@
+import { getParallelSlotEntries, type EntryData } from "../server/context.js";
+import type { RequestContext } from "../server/request-context.js";
+import type { TransitionWhenContext } from "../types/segments.js";
+
+export type TransitionWhenErrorReporter = (
+  error: unknown,
+  segmentId: string,
+) => void;
+
+export function createTransitionWhenContext<TEnv>(
+  ctx: RequestContext<TEnv>,
+  target?: {
+    params: Record<string, string>;
+    routeName?: string;
+  },
+): TransitionWhenContext<Record<string, string>, TEnv> {
+  return {
+    currentUrl: ctx._gateCurrentUrl,
+    currentParams: ctx._gateCurrentParams,
+    fromRouteName: ctx._prevRouteKey as TransitionWhenContext["fromRouteName"],
+    nextUrl: ctx.url,
+    nextParams: target?.params ?? ctx.params,
+    toRouteName: (target?.routeName ??
+      ctx.routeName) as TransitionWhenContext["toRouteName"],
+    actionId: ctx._gateActionId,
+    actionUrl: ctx._gateActionUrl,
+    actionResult: ctx._gateActionResult,
+    formData: ctx._gateFormData,
+    method: ctx.request.method,
+    get: ctx.get,
+    env: ctx.env,
+  };
+}
+
+/** Evaluate server-only transition gates before handlers on a PPR route. */
+export function evaluatePprTransitionWhen<TEnv>(
+  entries: EntryData[],
+  ctx: RequestContext<TEnv>,
+  target: {
+    params: Record<string, string>;
+    routeName?: string;
+  },
+  reportError: TransitionWhenErrorReporter,
+): void {
+  const decisions = new Map<string, boolean>();
+  const whenContext = createTransitionWhenContext(ctx, target);
+  const visited = new Set<EntryData>();
+
+  const evaluate = (entry: EntryData, segmentId: string): void => {
+    const when = entry.transition?.when;
+    if (!when) return;
+    try {
+      decisions.set(segmentId, when(whenContext) !== false);
+    } catch (error) {
+      decisions.set(segmentId, false);
+      reportError(error, segmentId);
+    }
+  };
+
+  const visitEntryAndOrphanLayouts = (entry: EntryData): void => {
+    if (visited.has(entry)) return;
+    visited.add(entry);
+    evaluate(entry, entry.shortCode);
+
+    for (const orphan of entry.layout) visitEntryAndOrphanLayouts(orphan);
+    // Rendered parallel slots are leaves identified by their owning segment.
+    for (const { slot, entry: parallelEntry } of getParallelSlotEntries(
+      entry.parallel,
+    )) {
+      evaluate(parallelEntry, `${entry.shortCode}.${slot}`);
+    }
+  };
+
+  for (const entry of entries) visitEntryAndOrphanLayouts(entry);
+  ctx._pprTransitionDecisions = decisions.size > 0 ? decisions : undefined;
+}