@rangojs/router 0.32.0 → 0.33.0

package/src/router/match-context.ts

@@ -239,6 +239,11 @@ export interface MatchPipelineState {
   // Whether cache should be revalidated (SWR)
   shouldRevalidate?: boolean;
 
+  // Whether the prerender entry that answered is past its soft staleAt: it
+  // serves while a refresh is due, so it is not what the page will hold once
+  // that lands (MatchResult.fromStorage counts it live)
+  storedStale?: boolean;
+
   // Source of cache hit ("runtime" or "prerender")
   cacheSource?: "runtime" | "prerender";
 

package/src/router/match-handlers.ts

@@ -155,10 +155,11 @@ export interface MatchHandlerDeps<TEnv = any> {
   defaultErrorBoundary: ReactNode | ErrorBoundaryHandler | undefined;
   findMatch: (pathname: string, ms?: any) => any;
   findInterceptForRoute: (
-    routeKey: string,
+    routeKeys: string | readonly string[],
     parentEntry: EntryData | null,
     selectorContext: InterceptSelectorContext | null,
     isAction: boolean,
+    held?: ReadonlySet<string>,
   ) => { intercept: InterceptEntry; entry: EntryData } | null;
   telemetry?: TelemetrySink;
   /**

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

@@ -83,6 +83,7 @@ import {
 import { ShellRecordUnavailableError } from "../../cache/shell-snapshot.js";
 import { prerenderStoreShortCircuits } from "../navigation-snapshot.js";
 import { paramsEqual } from "../params-util.js";
+import { markSourceHeld, readsOfAllParams } from "../source-reads.js";
 import { requestHeaders } from "../../server/request-headers.js";
 import { isInterceptSegment } from "../../browser/intercept-utils.js";
 import {
@@ -144,7 +145,8 @@ async function ensurePrerenderDeps(): Promise<void> {
  * - `prerender-build`: the bundled build manifest (immutable).
  * - `prerender-overlay`: the writable on-demand overlay. Its entry may be
  *   newer than the client's copy: one that a refresh (possibly inside this
- *   very action) replaced.
+ *   very action) replaced. `stale`: it is past its soft `staleAt` (serves
+ *   while a refresh is due).
  */
 type StoredSegmentSource =
   | {
@@ -154,7 +156,8 @@ type StoredSegmentSource =
       scope: CacheScope;
       restoreHandles?: (sentIds: ReadonlySet<string>) => Promise<void>;
     }
-  | { kind: "prerender-build" | "prerender-overlay"; entry: PrerenderEntry };
+  | { kind: "prerender-build"; entry: PrerenderEntry }
+  | { kind: "prerender-overlay"; entry: PrerenderEntry; stale: boolean };
 
 /**
  * Decode a prerender entry's segments and replay its handle data into the
@@ -339,12 +342,15 @@ function storedEntrySends<TEnv>(
     ctx.clientSegmentSet.size > 0
       ? router.buildEntryRevalidateMap?.(ctx.entries)
       : undefined;
-  // A keep that hangs on the source's params is right for this source only:
-  // scope a prefetch of the answer to it, as a predicate that read the
-  // source would (#1331).
+  // A keep that hangs on the source's params is right for the pages with
+  // the same params only: scope a prefetch of the answer to them, as a
+  // predicate that compared every param would (#1331).
   const heldForSource = (): false => {
-    (ctx.handlerContext as InternalHandlerContext<any, TEnv>)._sourceHeld =
-      true;
+    markSourceHeld(
+      ctx.handlerContext as InternalHandlerContext<any, TEnv>,
+      readsOfAllParams(ctx.prevParams),
+      { params: ctx.prevParams, routeName: undefined },
+    );
     return false;
   };
   const decide = (segment: ResolvedSegment): boolean | Promise<boolean> => {
@@ -563,6 +569,11 @@ async function* serveStoredSegments<TEnv>(
   state.cacheHit = true;
   state.cacheSource = fromCache ? "runtime" : "prerender";
   if (fromCache) state.shouldRevalidate = source.shouldRevalidate;
+  // Not shouldRevalidate: that one starts the cache() scope's background
+  // revalidation.
+  if (source.kind === "prerender-overlay" && source.stale) {
+    state.storedStale = true;
+  }
   state.cachedSegments = segments;
   const cachedMatchedIds = [...liveMatchedIds, ...segments.map((s) => s.id)];
   state.cachedMatchedIds = cachedMatchedIds;
@@ -807,11 +818,8 @@ async function readPrerenderSource<TEnv>(
       // A stale "removed" marker is rechecked like a stale page: only a
       // refresh that hit notFound() (or declined) stamps one with a ttl or
       // tags. A prerender.remove() marker has neither and never gets here.
-      if (
-        overlay.config.onRevalidate &&
-        reqCtx &&
-        isStoredEntryStale(stored, Date.now())
-      ) {
+      const stale = isStoredEntryStale(stored, Date.now());
+      if (overlay.config.onRevalidate && reqCtx && stale) {
         scheduleOverlayRevalidation(
           serializePrerenderKey(key),
           overlay.config.onRevalidate,
@@ -833,7 +841,7 @@ async function readPrerenderSource<TEnv>(
         )._prerenderRemoved = true;
         return null;
       }
-      return { kind: "prerender-overlay", entry: stored.entry };
+      return { kind: "prerender-overlay", entry: stored.entry, stale };
     }
   }
 

package/src/router/match-result.ts

@@ -115,7 +115,6 @@ import type {
 import { isPlaceholder } from "../types/segments.js";
 import { interceptMatched } from "../browser/intercept-utils.js";
 import type { MatchContext, MatchPipelineState } from "./match-context.js";
-import { debugLog } from "./logging.js";
 import { appendMetric } from "./metrics.js";
 import {
   collectInterceptTargetNames,
@@ -132,83 +131,11 @@ export async function collectSegments(
   return segments;
 }
 
-/**
- * Deduplicate inherited loader segments by loaderId.
- *
- * When a route has loaders and a child layout has parallel slots, the same
- * loader is resolved twice: once for the route and once inherited into the
- * layout (tagged with `_inherited`). The inherited copy is only needed when
- * the route uses `loading()` — in that case, the loader data is inside a
- * LoaderBoundary/Suspense that parallel slots can't reach through. Without
- * loading(), useLoader() traverses parent contexts and finds the data.
- */
-function deduplicateLoaderSegments(
-  segments: ResolvedSegment[],
-  logPrefix: string,
-): { segments: ResolvedSegment[]; removedIds: Set<string> } {
-  // Single pass: original (non-inherited) loaderIds, all loaderIds grouped by
-  // namespace, and namespaces of segments that declare loading().
-  const originalLoaders = new Set<string>();
-  const loaderIdsByNamespace = new Map<string, string[]>();
-  const namespacesWithLoading = new Set<string>();
-  for (const s of segments) {
-    if (s.type === "loader" && s.loaderId) {
-      if (!s._inherited) originalLoaders.add(s.loaderId);
-      const ids = loaderIdsByNamespace.get(s.namespace);
-      if (ids) ids.push(s.loaderId);
-      else loaderIdsByNamespace.set(s.namespace, [s.loaderId]);
-    } else if (
-      s.type !== "loader" &&
-      s.loading !== undefined &&
-      s.loading !== false
-    ) {
-      namespacesWithLoading.add(s.namespace);
-    }
-  }
-
-  const loadersWithLoading = new Set<string>();
-  for (const ns of namespacesWithLoading) {
-    for (const id of loaderIdsByNamespace.get(ns) ?? []) {
-      loadersWithLoading.add(id);
-    }
-  }
-
-  const result: ResolvedSegment[] = [];
-  const removedIds = new Set<string>();
-
-  for (const s of segments) {
-    if (
-      s.type === "loader" &&
-      s.loaderId &&
-      s._inherited &&
-      originalLoaders.has(s.loaderId) &&
-      !loadersWithLoading.has(s.loaderId)
-    ) {
-      removedIds.add(s.id);
-      continue;
-    }
-    result.push(s);
-  }
-
-  if (removedIds.size > 0) {
-    debugLog(
-      logPrefix,
-      `deduped ${removedIds.size} inherited loader segment(s)`,
-    );
-  }
-
-  return { segments: result, removedIds };
-}
-
 export function buildMatchResult<TEnv>(
   allSegments: ResolvedSegment[],
   ctx: MatchContext<TEnv>,
   state: MatchPipelineState,
 ): MatchResult {
-  const logPrefix = ctx.isFullMatch
-    ? "[Router.match]"
-    : "[Router.matchPartial]";
-
   let allIds: string[];
   let segmentsToRender: ResolvedSegment[];
   let resolvedIds: string[];
@@ -271,19 +198,11 @@ export function buildMatchResult<TEnv>(
     }
   }
 
-  const { segments: dedupedSegments, removedIds } = deduplicateLoaderSegments(
-    segmentsToRender,
-    logPrefix,
-  );
-
-  const matchedIds =
-    removedIds.size > 0 ? allIds.filter((id) => !removedIds.has(id)) : allIds;
-
-  // One pass over dedupedSegments: strip the internal _handlerRan marker and
+  // One pass over segmentsToRender: strip the internal _handlerRan marker and
   // collect the diff ids (id is unchanged by the strip) together.
   const cleanedSegments: ResolvedSegment[] = [];
   const diff: string[] = [];
-  for (const s of dedupedSegments) {
+  for (const s of segmentsToRender) {
     if (s._handlerRan === undefined) {
       cleanedSegments.push(s);
     } else {
@@ -297,10 +216,13 @@ export function buildMatchResult<TEnv>(
   // origin — the browser-local clientUrls matcher declines its optimistic
   // presentation for these (see collectInterceptTargetNames).
   const interceptTargets = collectInterceptTargetNames(ctx.manifestEntry);
+  const sourceHeld = (
+    ctx.handlerContext as InternalHandlerContext<any, TEnv> | undefined
+  )?._sourceHeld;
 
   return {
     segments: cleanedSegments,
-    matched: matchedIds,
+    matched: allIds,
     diff,
     resolvedIds,
     params: ctx.matched.params,
@@ -308,15 +230,45 @@ export function buildMatchResult<TEnv>(
     slots: Object.keys(state.slots).length > 0 ? state.slots : undefined,
     ...(interceptTargets.length > 0 ? { interceptTargets } : {}),
     ...(ctx.interceptTargeted ? { interceptTargeted: true } : {}),
-    ...((ctx.handlerContext as InternalHandlerContext<any, TEnv> | undefined)
-      ?._sourceHeld
-      ? { sourceHeld: true }
+    ...(sourceHeld ? { sourceHeld } : {}),
+    ...(!ctx.isFullMatch && sendsOnlyStored(segmentsToRender, state)
+      ? { fromStorage: true as const }
       : {}),
     routeMiddleware:
       ctx.routeMiddleware.length > 0 ? ctx.routeMiddleware : undefined,
   };
 }
 
+/**
+ * Whether a partial answer sends only what the cache lookup decoded from
+ * storage (MatchResult.fromStorage). By object, not by id: a
+ * segment the live walk resolved under a stored one's id (a live layout above
+ * a cache() boundary, an intercept resolved live) is not the stored copy.
+ * Any loader segment ran in this request, so it is live. Defaults to live:
+ * counted stored by mistake, a segment brings back the cached failures #1170
+ * removed. A stale cache() record (state.shouldRevalidate, refreshed in the
+ * background), a stale on-demand Prerender overlay entry (state.storedStale,
+ * which only the overlay can be: the build manifest never goes stale) and an
+ * answer that sends nothing count as live too: the browser would keep the
+ * first two past their refresh, and the third is a source page's answer.
+ */
+function sendsOnlyStored(
+  sent: readonly ResolvedSegment[],
+  state: MatchPipelineState,
+): boolean {
+  if (
+    !state.cacheHit ||
+    !state.cachedSegments ||
+    state.shouldRevalidate ||
+    state.storedStale ||
+    sent.length === 0
+  ) {
+    return false;
+  }
+  const stored = new Set(state.cachedSegments);
+  return sent.every((s) => s.type !== "loader" && stored.has(s));
+}
+
 export async function collectMatchResult<TEnv>(
   pipeline: AsyncGenerator<ResolvedSegment>,
   ctx: MatchContext<TEnv>,

package/src/router/navigation-snapshot.ts

@@ -117,7 +117,9 @@ function getShownRouteUrl(url: URL): URL | null {
   if (!shown) return null;
   try {
     const parsed = new URL(shown, url.origin);
-    return parsed.origin === url.origin ? formSearch(parsed) : null;
+    return parsed.origin === url.origin
+      ? withoutHash(formSearch(parsed))
+      : null;
   } catch {
     return null;
   }
@@ -134,6 +136,19 @@ function formSearch(url: URL): URL {
   return url;
 }
 
+/**
+ * `url` without its `#fragment`. The browser sends its whole address as the
+ * client path, anchor included, but never a fragment in a request URL, so the
+ * server's `nextUrl` has none. Left on the page-left URLs, `currentUrl` and
+ * `nextUrl` of one address differ (`/t/42#questions` vs `/t/42`) and a
+ * `revalidate()` rule comparing them reads two addresses. A fragment is never
+ * server state: it names no route, param or query.
+ */
+function withoutHash(url: URL): URL {
+  url.hash = "";
+  return url;
+}
+
 export async function resolveNavigation(
   request: Request,
   url: URL,
@@ -155,7 +170,7 @@ export async function resolveNavigation(
 
   let visitor: URL;
   try {
-    visitor = formSearch(new URL(previousUrl, url.origin));
+    visitor = withoutHash(formSearch(new URL(previousUrl, url.origin)));
   } catch {
     return null;
   }
@@ -166,7 +181,7 @@ export async function resolveNavigation(
   let interceptContextUrl: URL;
   try {
     interceptContextUrl = interceptSourceUrl
-      ? new URL(interceptSourceUrl, url.origin)
+      ? withoutHash(new URL(interceptSourceUrl, url.origin))
       : prevUrl;
   } catch {
     interceptContextUrl = prevUrl;

package/src/router/prefetch-cache-ttl.ts

@@ -1,9 +1,10 @@
 /**
  * Resolve the prefetch cache TTL once, at router init, into the values the
  * rest of the router consumes: seconds, and milliseconds for the client-side
- * in-memory prefetch cache (shipped in payload metadata). Prefetch responses
- * carry no Cache-Control: the browser HTTP cache would keep a prefetch whose
- * render failed after its 200 went out (#1170).
+ * in-memory prefetch cache (shipped in payload metadata). A prefetch with a
+ * live part carries no Cache-Control: the browser HTTP cache would keep a
+ * prefetch whose render failed after its 200 went out (#1170). One answered
+ * from storage carries storedPrefetchCacheControl.
  *
  * `false` disables prefetch caching (seconds 0). A non-finite input
  * (NaN/Infinity, e.g. from an env-derived number that failed to parse) is
@@ -41,3 +42,14 @@ export function resolvePrefetchCacheTTL(
 
   return { seconds, ms: seconds * 1000 };
 }
+
+/**
+ * The Cache-Control of a prefetch answer with nothing live in it
+ * (`_servedFromStorage`): the browser HTTP cache keeps it as long
+ * as the in-memory prefetch cache would. Undefined when prefetch caching is
+ * off.
+ */
+export function storedPrefetchCacheControl(ttlMs: number): string | undefined {
+  const seconds = Math.floor(ttlMs / 1000);
+  return seconds > 0 ? `private, max-age=${seconds}` : undefined;
+}

package/src/router/revalidation.ts

@@ -21,6 +21,8 @@ import { _getRequestContext } from "../server/request-context.js";
 import { isAutoGeneratedRouteName } from "../route-name.js";
 import { paramsEqual } from "./params-util.js";
 import { makeIsAction } from "./is-action.js";
+import { createSourceReads, hasSourceReads } from "../prefetch-source-scope.js";
+import { markSourceHeld, recordingParams } from "./source-reads.js";
 
 const REVALIDATE_ALWAYS: ShouldRevalidateFn<any, any> = () => true;
 const REVALIDATE_NEVER: ShouldRevalidateFn<any, any> = () => false;
@@ -155,18 +157,45 @@ export async function evaluateRevalidation<TEnv>(
   // second, contradicting entry would let flushRevalidationTrace count the
   // segment as both revalidated and skipped.
   const floorTrue = defaultOverride?.floor === true && defaultOverride.value;
-  // A predicate read the page navigated away from. A segment it keeps then
-  // stays held for this source only: a prefetch of the answer, adopted on
-  // another page, would keep that page's copy (#1331). A re-render is
-  // source-safe, it sends the segment.
-  let readSource = false;
-  function decide(finalVal: boolean, reason: string): boolean {
+  // The source page the predicates see.
+  let currentParams: Record<string, string> = prevParams;
+  const prevRouteKey = reqCtx?._prevRouteKey;
+  const fromRouteName =
+    prevRouteKey && !isAutoGeneratedRouteName(prevRouteKey)
+      ? prevRouteKey
+      : undefined;
+  // What the predicates read of the page navigated away from. A segment they
+  // keep then stays held for the pages with equal values of those reads only:
+  // a prefetch of the answer, adopted on a page with other values, would keep
+  // that page's copy (#1331). A re-render is source-safe, it sends the
+  // segment. Reads before a throw count: the fallback is decided after them.
+  const reads = createSourceReads();
+  let recordedParams: Record<string, string> | undefined;
+  // A rule read `defaultShouldRevalidate`.
+  let readDefault = false;
+  /** `usedDefault`: the decision is the default's, or a rule read it. */
+  function decide(
+    finalVal: boolean,
+    reason: string,
+    usedDefault: boolean,
+  ): boolean {
     if (floorTrue && !finalVal) {
       pushTrace(defaultShouldRevalidate, true, `${reason}:floored`);
       return true;
     }
-    if (!finalVal && readSource) {
-      (context as InternalHandlerContext<any, TEnv>)._sourceHeld = true;
+    if (!finalVal && hasSourceReads(reads)) {
+      // The navigation default of a route segment, and of a segment the route
+      // owns, compares the target's params and search with the source's, and
+      // no read records that: a page grouped by the rules' reads but with
+      // other params would adopt the keep. Seen from a page whose params
+      // equal a rewritten target's (/en/p/1 prefetching /deals, which renders
+      // /en/p/1): grouped by locale, /en/p/2 adopted the answer and kept
+      // product 2 at /deals.
+      if (usedDefault && defaultComparesSource) reads.url = true;
+      markSourceHeld(context as InternalHandlerContext<any, TEnv>, reads, {
+        params: currentParams,
+        routeName: fromRouteName,
+      });
     }
     pushTrace(defaultShouldRevalidate, finalVal, reason);
     return finalVal;
@@ -174,6 +203,8 @@ export async function evaluateRevalidation<TEnv>(
 
   let defaultShouldRevalidate: boolean;
   let defaultReason: string;
+  // The default hangs on paramsChanged / searchChanged (the nav lane below).
+  let defaultComparesSource = false;
 
   if (defaultOverride) {
     defaultShouldRevalidate = defaultOverride.value;
@@ -197,6 +228,8 @@ export async function evaluateRevalidation<TEnv>(
       defaultReason = reasons.parentChain;
     }
   } else {
+    defaultComparesSource =
+      segment.type === "route" || segment.belongsToRoute === true;
     if (segment.type === "route") {
       const routeChanged = paramsChanged || searchChanged;
       defaultShouldRevalidate = routeChanged;
@@ -245,40 +278,36 @@ export async function evaluateRevalidation<TEnv>(
         segmentId: segment.id,
       });
     }
-    return decide(defaultShouldRevalidate, defaultReason);
+    return decide(defaultShouldRevalidate, defaultReason, true);
   }
 
   const prevSegment = getPrevSegment ? await getPrevSegment() : null;
+  currentParams = prevSegment?.params || prevParams;
 
   let currentSuggestion = defaultShouldRevalidate;
 
   const toRouteName =
     routeKey && !isAutoGeneratedRouteName(routeKey) ? routeKey : undefined;
-  const prevRouteKey = reqCtx?._prevRouteKey;
-  const fromRouteName =
-    prevRouteKey && !isAutoGeneratedRouteName(prevRouteKey)
-      ? prevRouteKey
-      : undefined;
 
   const isActionFn = makeIsAction(actionContext?.actionId);
 
-  const currentParams = prevSegment?.params || prevParams;
-
   for (const { name, fn } of revalidations) {
     let result: any;
     try {
       result = fn({
         get currentParams() {
-          readSource = true;
-          return currentParams;
+          return (recordedParams ??= recordingParams(currentParams, reads));
         },
         get currentUrl() {
-          readSource = true;
+          reads.url = true;
           return prevUrl;
         },
         nextParams,
         nextUrl,
-        defaultShouldRevalidate: currentSuggestion,
+        get defaultShouldRevalidate() {
+          readDefault = true;
+          return currentSuggestion;
+        },
         context,
         // Segment metadata (which segment is being evaluated)
         segmentType: segment.type,
@@ -293,7 +322,7 @@ export async function evaluateRevalidation<TEnv>(
         method: request.method,
         routeName: toRouteName,
         get fromRouteName() {
-          readSource = true;
+          reads.route = true;
           return fromRouteName;
         },
         toRouteName,
@@ -346,7 +375,7 @@ export async function evaluateRevalidation<TEnv>(
         revalidator: name,
         revalidate: result,
       });
-      return decide(result, `hard:${name}`);
+      return decide(result, `hard:${name}`, readDefault);
     } else if (
       result &&
       typeof result === "object" &&
@@ -372,5 +401,6 @@ export async function evaluateRevalidation<TEnv>(
     revalidate: currentSuggestion,
   });
   const softNames = revalidations.map((r) => r.name).join(",");
-  return decide(currentSuggestion, `soft-chain:${softNames}`);
+  // A soft result may carry the default it read on: counted as the default's.
+  return decide(currentSuggestion, `soft-chain:${softNames}`, true);
 }

package/src/router/router-context.ts

@@ -94,10 +94,11 @@ export interface RouterContext<TEnv = any> {
   ) => CacheScope | null;
 
   findInterceptForRoute: (
-    routeKey: string,
+    routeKeys: string | readonly string[],
     parentEntry: EntryData | null,
     selectorContext: InterceptSelectorContext,
     isAction: boolean,
+    held?: ReadonlySet<string>,
   ) => InterceptResult | null;
 
   /** The segment walker; a full match passes freshPassInput (FRESH). */

package/src/router/router-options.ts

@@ -535,9 +535,12 @@ export interface RangoOptions<TEnv = any> {
    * TTL (in seconds) for the client-side in-memory prefetch cache.
    *
    * Controls how long prefetch responses are kept in the client-side
-   * in-memory cache. Prefetch responses carry no `Cache-Control`, so the
-   * browser's HTTP cache does not keep them: a prefetch whose render failed
-   * after its 200 went out would otherwise answer later requests.
+   * in-memory cache. A prefetch with nothing live in it (a document cache
+   * HIT, or every sent segment from a `cache()` record or a Prerender entry,
+   * with no loader) also carries `Cache-Control: private, max-age=<ttl>`,
+   * so the browser's HTTP cache keeps it as long. Any other prefetch carries
+   * none: a prefetch whose render failed after its 200 went out would
+   * otherwise answer later requests.
    *
    * The cache is automatically invalidated on server actions regardless
    * of TTL, so this is primarily a staleness safety net.

package/src/router/segment-resolution/loader-cache.ts

@@ -285,9 +285,10 @@ export function routeLoaderLanes(
  * records. A capture serves none: its bake-lane loaders execute.
  *
  * The one answer to "is this loader served from the shell record on this
- * request", for its value (resolveLoaderData) and for the record's copies of
- * its handle pushes (loaderPins): both look the loader up here and nowhere
- * else. A condition that makes pins, or one loader's pin, not apply belongs
+ * request", for its value (resolveLoaderData), for the record's copies of
+ * its handle pushes (loaderPins) and for whether a prefetch defers it
+ * (servesLoaderPin): all look the loader up here and nowhere else. A
+ * condition that makes pins, or one loader's pin, not apply belongs
  * here or in the seed's decode (shell-snapshot.ts buildShellLoaderSeed),
  * never after a lookup, or the two disagree: issues #1001 and #1003 were the
  * pushes decided from the request's type while the value was decided from
@@ -299,6 +300,23 @@ function servedPins(
   return isShellCaptureActive(reqCtx) ? undefined : reqCtx?._shellLoaderSeed;
 }
 
+/**
+ * This request serves `loaderEntry` from a pin (servedPins), so its body does
+ * not decide the value: resolveLoaderData serves a pin to an `ssr: false`
+ * registration only. A prefetch does not defer such a loader
+ * (prefetch-deferral.ts defersLoader): nothing would run, and the pin is the
+ * value the document shows.
+ */
+export function servesLoaderPin(
+  loaderEntry: LoaderEntry,
+  reqCtx: RequestContext<any> | undefined = _getRequestContext(),
+): boolean {
+  return (
+    loaderEntry.bake === true &&
+    servedPins(reqCtx)?.has(loaderEntry.loader.$$id) === true
+  );
+}
+
 /**
  * What a record restored on a request over the matched chain `entries` is to
  * each loader's handle pushes (HandleStore RecordAuthority), from the pins