@rangojs/router 0.16.0 → 0.17.0

package/src/server/context.ts

@@ -12,6 +12,11 @@ import type {
 } from "../types";
 import { invariant, DslContextError } from "../errors";
 import type { DefaultRouteName } from "../types/global-namespace.js";
+import type { ContextVar } from "../context-var.js";
+import {
+  getCacheExecScope,
+  type CacheExecScope,
+} from "../cache/cache-exec-scope.js";
 
 // ============================================================================
 //  Performance Metrics Types
@@ -65,6 +70,17 @@ export type EntryPropCommon = {
   id: string;
   shortCode: string; // Short identifier for network efficiency (e.g., "L0", "P1", "R2")
   parent: EntryData | null;
+  /**
+   * Orphan siblings only (attachOrphanSibling in
+   * route-definition/dsl-helpers.ts): the entry whose `layout[]` holds this
+   * one. `parent` stays null on an orphan (matchError's matched-id stack in
+   * router/match-api.ts starts at the boundary-holding entry, possibly an
+   * orphan, and must stop there), so the boundary walkers in
+   * router/error-handling.ts follow this instead. A lookup that starts at an
+   * orphan (its loaders, an intercept it declares) then reaches the owner's
+   * boundaries and the owner's ancestors.
+   */
+  orphanOwner?: EntryData;
   /** Cache configuration for this entry (set by cache() DSL) */
   cache?: EntryCacheConfig;
   /** URL prefix from include() scope, used for MountContext on client */
@@ -187,9 +203,6 @@ export type InterceptEntry = {
   routeName: string; // e.g., "card"
   handler: ReactNode | Handler<any, any, any>;
   middleware: MiddlewareFn<any, any>[];
-  revalidate: ShouldRevalidateFn<any, any>[];
-  errorBoundary: (ReactNode | ErrorBoundaryHandler)[];
-  notFoundBoundary: (ReactNode | NotFoundBoundaryHandler)[];
   loader: LoaderEntry[];
   loading?: ReactNode | false;
   transition?: TransitionConfig;
@@ -839,16 +852,19 @@ const loaderScopeALS: AsyncLocalStorage<{ active: true }> = ((
 // does NOT affect isInsideLoaderScope(), so rendered()/barrier/deadlock
 // gating (which must distinguish DSL from handler-invoked loaders) is
 // unchanged.
-const LOADER_BODY_SCOPE_KEY = Symbol.for("rangojs-router:loader-body-scope");
-const loaderBodyScopeALS: AsyncLocalStorage<{
+interface LoaderBodyScope {
   active: true;
   loaderId?: string;
   handlerInvoked?: boolean;
-}> = ((globalThis as any)[LOADER_BODY_SCOPE_KEY] ??= new AsyncLocalStorage<{
-  active: true;
-  loaderId?: string;
-  handlerInvoked?: boolean;
-}>());
+  /** The body scope this one was entered from (a ctx.use(Loader) chain). */
+  parent?: LoaderBodyScope;
+  /** The "use cache" scope the body was entered in (assertNonCacheableReadAllowed). */
+  execScope?: CacheExecScope;
+}
+const LOADER_BODY_SCOPE_KEY = Symbol.for("rangojs-router:loader-body-scope");
+const loaderBodyScopeALS: AsyncLocalStorage<LoaderBodyScope> = ((
+  globalThis as any
+)[LOADER_BODY_SCOPE_KEY] ??= new AsyncLocalStorage<LoaderBodyScope>());
 
 /**
  * Check if the current execution is inside a cache() DSL boundary.
@@ -869,6 +885,45 @@ export function isInsideCacheScope(): boolean {
   return true;
 }
 
+/**
+ * Read guard for a non-cacheable variable (`createVar({ cache: false })` or a
+ * `ctx.set(..., { cache: false })` write). Callers check isNonCacheable() first
+ * so ordinary reads never reach the scope lookups.
+ *
+ * Throws inside a "use cache" body: the key does not include the value, so the
+ * first caller's value would be stored and served to later callers (#925). A
+ * loader body entered INSIDE the cached function is exempt, the same baked-copy
+ * trade isInsideCacheScope() makes for cache(). A cached function called FROM a
+ * loader is not: the loader re-runs, the cached body does not. The body scope
+ * records the exec scope it was entered in, so the exemption holds only while
+ * that is still the innermost one.
+ */
+export function assertNonCacheableReadAllowed(
+  keyOrVar: string | ContextVar<unknown>,
+): void {
+  const execScope = getCacheExecScope();
+  if (
+    execScope !== undefined &&
+    loaderBodyScopeALS.getStore()?.execScope !== execScope
+  ) {
+    const name = typeof keyOrVar === "string" ? ` "${keyOrVar}"` : "";
+    throw new Error(
+      `ctx.get() for a non-cacheable variable${name} cannot be called inside a "use cache" function. ` +
+        `The variable was created with { cache: false } or set with { cache: false }, ` +
+        `and the cache key does not include its value, so the first caller's value ` +
+        `would be served to later callers. Read it before calling the cached function ` +
+        `and pass the value in as an argument so it becomes part of the cache key.`,
+    );
+  }
+  if (isInsideCacheScope()) {
+    throw new Error(
+      `ctx.get() for a non-cacheable variable cannot be called inside a cache() boundary. ` +
+        `The variable was created with { cache: false } or set with { cache: false }, ` +
+        `and its value would be stale on cache hit. Move the read outside the cached scope.`,
+    );
+  }
+}
+
 /**
  * Check if the current execution is inside a DSL loader scope
  * (wrapped by runInsideLoaderScope). Used by rendered() barrier
@@ -1052,7 +1107,16 @@ export function runInsideLoaderBodyScope<T>(
   loaderId?: string,
   handlerInvoked?: boolean,
 ): T {
-  return loaderBodyScopeALS.run({ active: true, loaderId, handlerInvoked }, fn);
+  return loaderBodyScopeALS.run(
+    {
+      active: true,
+      loaderId,
+      handlerInvoked,
+      parent: loaderBodyScopeALS.getStore(),
+      execScope: getCacheExecScope(),
+    },
+    fn,
+  );
 }
 
 /**
@@ -1067,6 +1131,19 @@ export function getCurrentLoaderBodyId(): string | undefined {
   return loaderBodyScopeALS.getStore()?.loaderId;
 }
 
+/**
+ * True while `loaderId`'s body, or a loader it awaits via ctx.use at any
+ * depth, is executing. The loader-level cache records these pushes
+ * (loader-cache.ts): a HIT skips the cached body, so a dep that no other
+ * reader runs in that request only reaches the page through the replay.
+ */
+export function isInsideLoaderBody(loaderId: string): boolean {
+  for (let s = loaderBodyScopeALS.getStore(); s; s = s.parent) {
+    if (s.loaderId === loaderId) return true;
+  }
+  return false;
+}
+
 /**
  * True while a HANDLER-invoked loader body (`await ctx.use(Loader)` from a
  * handler, not the DSL segment funnel) is executing. The consumption-lane

package/src/server/cookie-store.ts

@@ -15,6 +15,7 @@ import {
   isInsideHandlerInvokedLoaderBody,
 } from "./context.js";
 import { isInsideCacheExecScope } from "../cache/cache-exec-scope.js";
+import { PPR_LANE_HINT } from "../rsc/shell-capture-constants.js";
 
 /**
  * A single cookie entry returned by get() and getAll().
@@ -193,12 +194,12 @@ function assertNotInsideShellCapture(ctx: unknown, fnName: string): void {
     )._shellCaptureGuardTrippedLoaderId = getCurrentLoaderBodyId();
     throw new Error(
       `${fnName}() cannot be called while capturing a shared shell ` +
-        `(shell-cache middleware). The captured shell is served to every user ` +
+        `(ppr shell capture). The captured shell is served to every user ` +
         `of this URL, so request-scoped data read here would leak one user's ` +
         `${fnName === "cookies" ? "cookies" : "headers"} to others. Read it ` +
-        `inside a loader instead — loaders are never captured and always run ` +
-        `fresh per request:\n\n` +
-        `  loader("user", () => getUser(cookies().get("session")?.value));`,
+        `inside a loader without ssr: false and consume it with useLoader, e.g. ` +
+        `createLoader(async () => getUser(cookies().get("session")?.value)). ` +
+        PPR_LANE_HINT,
     );
   }
 }

package/src/server/handle-store.ts

@@ -1,3 +1,5 @@
+import { getCurrentLoaderBodyId, isInsideLoaderScope } from "./context.js";
+
 /**
  * Handle data structure: handleName -> segmentId -> entries[]
  *
@@ -45,6 +47,24 @@ function createLateHandlePushError(
   return error;
 }
 
+/**
+ * Per-slot flags, parallel to one handle/segment values array. Allocated on
+ * the array's first flagged slot; positions past its length are unflagged.
+ */
+interface SlotTag {
+  /** Pushed inside a DSL loader scope; captureHandles drops it. */
+  loader?: boolean;
+  /** A loader-cache replay of this loader's recorded push (pushReplayed). */
+  replayOf?: string;
+  /** Pushed by this loader's live run after it replaced its replayed slots. */
+  liveOf?: string;
+  /** Pushed by this loader's body and kept in records (push `owner`). */
+  owner?: string;
+}
+
+// Shared by every plain DSL-loader push; tags are never mutated in place.
+const LOADER_SLOT: SlotTag = Object.freeze({ loader: true });
+
 function cloneHandleData(data: HandleData): HandleData {
   const clone: HandleData = {};
   for (const handleName in data) {
@@ -116,8 +136,35 @@ export interface HandleStore {
    * Push handle data for a specific handle and segment.
    * Multiple pushes to the same handle/segment accumulate in an array.
    * Each push triggers an emission on the stream.
+   *
+   * `loaderPush` overrides the push-time DSL-loader tag
+   * (isInsideLoaderScope()) that getDataForSegment(id, true) excludes. The
+   * PPR shell capture passes false for the bake-lane pushes its record keeps
+   * (shell-capture.ts deriveShellCaptureContext), with `owner` set to the
+   * pushing loader's id so the record can restore them through pushReplayed
+   * (getRecordOwners).
    */
-  push(handleName: string, segmentId: string, data: unknown): void;
+  push(
+    handleName: string,
+    segmentId: string,
+    data: unknown,
+    loaderPush?: boolean,
+    owner?: string,
+  ): void;
+
+  /**
+   * push() a loader-cache HIT's replayed value, recorded from `loaderId`'s
+   * body (loader-cache.ts replayLoaderHandles). If that loader then runs live
+   * in this request, its first push removes every value replayed for it and
+   * takes the first one's position (later live pushes follow it), so the
+   * handle output stays live without a duplicate.
+   */
+  pushReplayed(
+    handleName: string,
+    segmentId: string,
+    data: unknown,
+    loaderId: string,
+  ): void;
 
   /**
    * Get all collected handle data after all handlers have settled.
@@ -151,8 +198,23 @@ export interface HandleStore {
   /**
    * Get handle data for a specific segment (for caching).
    * Returns data in format: { handleName: [values...] }
+   *
+   * `excludeLoaderPushes` drops values tagged as DSL-loader pushes at push
+   * time (see push); see captureHandles.
+   */
+  getDataForSegment(
+    segmentId: string,
+    excludeLoaderPushes?: boolean,
+  ): Record<string, unknown[]>;
+
+  /**
+   * The push `owner` of each value in getDataForSegment(segmentId, true),
+   * index-aligned per handle (null: no owner). Handles without an owned
+   * value are omitted; undefined when none has one.
    */
-  getDataForSegment(segmentId: string): Record<string, unknown[]>;
+  getRecordOwners(
+    segmentId: string,
+  ): Record<string, (string | null)[]> | undefined;
 
   /**
    * Replay cached handle data back into the store (for cache hits).
@@ -186,6 +248,88 @@ export interface HandleStore {
  */
 export function createHandleStore(): HandleStore {
   const data: HandleData = {};
+  // SlotTag arrays, keyed by the per-handle/segment values array. Positional
+  // (not value identity) so primitive values are covered too.
+  // replaySegmentData installs fresh arrays, so restored values are untagged.
+  const slotTags = new WeakMap<unknown[], (SlotTag | undefined)[]>();
+  // Replayed loaders that have not pushed live yet: loaderId -> the arrays
+  // holding their replayed slots.
+  const pendingReplays = new Map<string, Set<unknown[]>>();
+  // Replayed loaders whose live run already replaced those slots.
+  const replacedReplays = new Set<string>();
+
+  // Aligned to `values` so a mid-array insert or removal keeps positions.
+  function tagsFor(values: unknown[]): (SlotTag | undefined)[] {
+    let tags = slotTags.get(values);
+    if (!tags) slotTags.set(values, (tags = []));
+    if (tags.length < values.length) tags.length = values.length;
+    return tags;
+  }
+
+  function insertSlot(
+    values: unknown[],
+    at: number | undefined,
+    value: unknown,
+    tag: SlotTag | undefined,
+  ): void {
+    if (at === undefined || at >= values.length) {
+      values.push(value);
+      if (tag) tagsFor(values)[values.length - 1] = tag;
+      return;
+    }
+    const tags = tagsFor(values);
+    values.splice(at, 0, value);
+    tags.splice(at, 0, tag);
+  }
+
+  // Remove `loaderId`'s replayed slots; returns the first one's position.
+  function removeReplayedSlots(
+    values: unknown[],
+    loaderId: string,
+  ): number | undefined {
+    const tags = slotTags.get(values);
+    if (!tags) return undefined;
+    let first: number | undefined;
+    let kept = 0;
+    for (let i = 0; i < values.length; i++) {
+      if (tags[i]?.replayOf === loaderId) {
+        first ??= kept;
+        continue;
+      }
+      values[kept] = values[i];
+      tags[kept] = tags[i];
+      kept++;
+    }
+    values.length = kept;
+    tags.length = kept;
+    return first;
+  }
+
+  // Where a live push by a replayed loader lands in `values`: its first push
+  // removes all of its replayed slots and takes the first one's position in
+  // this array; later pushes follow its previous live push. undefined appends.
+  function liveReplacementIndex(
+    loaderId: string,
+    values: unknown[],
+  ): number | undefined {
+    const pending = pendingReplays.get(loaderId);
+    if (pending) {
+      pendingReplays.delete(loaderId);
+      replacedReplays.add(loaderId);
+      let at: number | undefined;
+      for (const replayed of pending) {
+        const first = removeReplayedSlots(replayed, loaderId);
+        if (replayed === values) at = first;
+      }
+      return at;
+    }
+    const tags = slotTags.get(values);
+    if (!tags) return undefined;
+    for (let i = tags.length - 1; i >= 0; i--) {
+      if (tags[i]?.liveOf === loaderId) return i + 1;
+    }
+    return undefined;
+  }
 
   // Settlement barriers: `settled` (handler lane) resolves when sealed AND
   // handler inflight === 0. `fullySettled` additionally waits for the
@@ -320,7 +464,13 @@ export function createHandleStore(): HandleStore {
       });
     },
 
-    push(handleName: string, segmentId: string, value: unknown): void {
+    push(
+      handleName: string,
+      segmentId: string,
+      value: unknown,
+      loaderPush?: boolean,
+      owner?: string,
+    ): void {
       if (completed) {
         const error = createLateHandlePushError(handleName, segmentId);
         if (this.onError) this.onError(error);
@@ -333,13 +483,58 @@ export function createHandleStore(): HandleStore {
       if (!data[handleName][segmentId]) {
         data[handleName][segmentId] = [];
       }
-      data[handleName][segmentId].push(value);
+      const values = data[handleName][segmentId];
+      const loader = (loaderPush ?? isInsideLoaderScope()) || undefined;
+      let at: number | undefined;
+      let liveOf: string | undefined;
+      if (pendingReplays.size > 0 || replacedReplays.size > 0) {
+        const bodyId = getCurrentLoaderBodyId();
+        if (
+          bodyId !== undefined &&
+          (pendingReplays.has(bodyId) || replacedReplays.has(bodyId))
+        ) {
+          at = liveReplacementIndex(bodyId, values);
+          liveOf = bodyId;
+        }
+      }
+      insertSlot(
+        values,
+        at,
+        value,
+        liveOf || owner
+          ? { loader, liveOf, owner }
+          : loader
+            ? LOADER_SLOT
+            : undefined,
+      );
 
       // Bump the version; each consumer's cursor decides when to clone+yield.
       version++;
       signalEmission();
     },
 
+    pushReplayed(
+      handleName: string,
+      segmentId: string,
+      value: unknown,
+      loaderId: string,
+    ): void {
+      const before = data[handleName]?.[segmentId]?.length ?? 0;
+      // Through this.push: active captures see the replay like a live push.
+      this.push(handleName, segmentId, value);
+      const values = data[handleName]?.[segmentId];
+      // A diverting capture kept it out of the store.
+      if (!values || values.length !== before + 1) return;
+      const tags = tagsFor(values);
+      tags[values.length - 1] = {
+        ...tags[values.length - 1],
+        replayOf: loaderId,
+      };
+      let arrays = pendingReplays.get(loaderId);
+      if (!arrays) pendingReplays.set(loaderId, (arrays = new Set()));
+      arrays.add(values);
+    },
+
     getData(): Promise<HandleData> {
       sealInternal();
       return this.settled.then(() => cloneHandleData(data));
@@ -417,12 +612,42 @@ export function createHandleStore(): HandleStore {
       }
     },
 
-    getDataForSegment(segmentId: string): Record<string, unknown[]> {
+    getDataForSegment(
+      segmentId: string,
+      excludeLoaderPushes?: boolean,
+    ): Record<string, unknown[]> {
       const result: Record<string, unknown[]> = {};
       for (const handleName in data) {
-        if (data[handleName][segmentId]) {
-          result[handleName] = [...data[handleName][segmentId]];
+        const values = data[handleName][segmentId];
+        if (!values) continue;
+        const tags = excludeLoaderPushes ? slotTags.get(values) : undefined;
+        if (!tags) {
+          result[handleName] = [...values];
+          continue;
+        }
+        const kept = values.filter((_, i) => !tags[i]?.loader);
+        if (kept.length > 0) result[handleName] = kept;
+      }
+      return result;
+    },
+
+    getRecordOwners(
+      segmentId: string,
+    ): Record<string, (string | null)[]> | undefined {
+      let result: Record<string, (string | null)[]> | undefined;
+      for (const handleName in data) {
+        const values = data[handleName][segmentId];
+        const tags = values && slotTags.get(values);
+        if (!tags) continue;
+        const owners: (string | null)[] = [];
+        let owned = false;
+        for (let i = 0; i < values.length; i++) {
+          if (tags[i]?.loader) continue;
+          const owner = tags[i]?.owner ?? null;
+          if (owner) owned = true;
+          owners.push(owner);
         }
+        if (owned) (result ??= {})[handleName] = owners;
       }
       return result;
     },

package/src/server/request-context.ts

@@ -61,8 +61,8 @@ import type { RoutineTrace } from "../rsc/routine-plan.js";
 import { NOCACHE_SYMBOL, assertNotInsideCacheExec } from "../cache/taint.js";
 import {
   assertCachedHeaderWriteAllowed,
+  assertNonCacheableReadAllowed,
   clearPprHeaderScope,
-  isInsideCacheScope,
 } from "./context.js";
 import {
   createReverseFunction,
@@ -197,8 +197,13 @@ export interface RequestContext<
   /** HTTP method (GET, POST, PUT, PATCH, DELETE, etc.) */
   method: string;
 
-  /** @internal Handle store for tracking handle data across segments */
-  _handleStore: HandleStore;
+  /**
+   * @internal Handle store for tracking handle data across segments.
+   * Readonly: a background render that needs its own store derives a context
+   * (rerenderAndCacheRoute, shell-capture.ts) instead of swapping this field,
+   * which the foreground still reads while it produces the page.
+   */
+  readonly _handleStore: HandleStore;
 
   /**
    * @internal transition({ when }) predicates for segments matched this request,
@@ -250,13 +255,12 @@ export interface RequestContext<
   /**
    * @internal Bake-lane loader containers collected DURING a shell capture:
    * segment-key -> the loader's (pre-wrap) result promise. Populated by
-   * resolveLoaderData for loaders on entries with no renderable loading() (the
-   * bake lane — they execute at capture instead of being masked; see
-   * docs/design/loader-container-bake.md). Drained by captureAndStoreShell
-   * after the shell quiesces: settled containers are promise-elided,
-   * Flight-serialized, and pinned into the snapshot's loader family; a
-   * REJECTED container refuses the capture (error UI must never bake into the
-   * shared shell). Own property of the capture's derived context only.
+   * resolveLoaderData for bake-lane loaders (lane rule: see its JSDoc in
+   * loader-cache.ts). Drained by captureAndStoreShell after the shell
+   * quiesces: settled containers are promise-elided, Flight-serialized, and
+   * pinned into the snapshot's loader family; a REJECTED container refuses
+   * the capture (error UI must never bake into the shared shell). Own
+   * property of the capture's derived context only.
    */
   _shellCaptureLoaderRecords?: Map<string, Promise<unknown>>;
 
@@ -377,18 +381,6 @@ export interface RequestContext<
     handlerInvokedLoader: boolean;
   };
 
-  /**
-   * @internal Handle values pushed from a DSL loader scope DURING a shell
-   * capture (identity set; populated by the capture push wrapper in
-   * shell-capture.ts). cacheRoute threads it into captureHandles so those
-   * values stay out of cache-write handle records — loaders re-run fresh on
-   * every HIT, so replaying their captured (masked) values would duplicate
-   * the fresh push and stall the Flight handle encode. Own property of the
-   * capture's derived context only; render-time handle consumers are
-   * unaffected (the exclusion applies only at the captureHandles call site).
-   */
-  _shellCaptureLoaderHandleValues?: WeakSet<object>;
-
   /**
    * @internal Set (to the offending fn name) by the cookies()/headers()
    * capture guard when it throws DURING a capture render. Load-bearing for the
@@ -650,6 +642,17 @@ export interface RequestContext<
   /** @internal Per-request error dedup set for onError reporting */
   _reportedErrors: WeakSet<object>;
 
+  /**
+   * @internal Errors this response's Flight or Fizz render reported through
+   * onError: a component that threw does not fail the stream, which completes
+   * with an error row or an errored Suspense boundary. Whole-response captures
+   * (document-cache.ts, captureAndStoreShell) store nothing while it is
+   * non-empty (issue #915). An array so a render under a derived context (the
+   * shell HIT tail) pushes into the request's own list through the prototype;
+   * deriveShellCaptureContext gives the capture its own.
+   */
+  _renderErrors?: unknown[];
+
   /**
    * @internal Report a non-fatal background error through the router's
    * onError callback. Wired by the RSC handler / router during request
@@ -749,7 +752,6 @@ export type PublicRequestContext<
   | "_shellLoaderSeed"
   | "_shellCaptureLoaderRecords"
   | "_shellCaptureHandleLiveness"
-  | "_shellCaptureLoaderHandleValues"
   | "_shellFragmentPayload"
   | "_shellCaptureGuardTripped"
   | "_shellCaptureGuardTrippedLoaderId"
@@ -770,6 +772,7 @@ export type PublicRequestContext<
   | "_gateFormData"
   | "_inActionRevalidation"
   | "_reportedErrors"
+  | "_renderErrors"
   | "_renderBarrier"
   | "_resolveRenderBarrier"
   | "_renderBarrierSegmentOrder"
@@ -1140,12 +1143,8 @@ export function createRequestContext<TEnv>(
     },
     _dynamic: false,
     get: ((keyOrVar: any) => {
-      if (isNonCacheable(variables, keyOrVar) && isInsideCacheScope()) {
-        throw new Error(
-          `ctx.get() for a non-cacheable variable cannot be called inside a cache() boundary. ` +
-            `The variable was created with { cache: false } or set with { cache: false }, ` +
-            `and its value would be stale on cache hit. Move the read outside the cached scope.`,
-        );
+      if (isNonCacheable(variables, keyOrVar)) {
+        assertNonCacheableReadAllowed(keyOrVar);
       }
       return contextGet(variables, keyOrVar);
     }) as RequestContext<TEnv>["get"],
@@ -1338,6 +1337,7 @@ export function createRequestContext<TEnv>(
     _locationState: undefined,
 
     _reportedErrors: new WeakSet<object>(),
+    _renderErrors: [],
     _metricsStore: undefined,
     _renderForeground: undefined,
     _activeRoutine: undefined,
@@ -1627,7 +1627,9 @@ export function createUseFunction<TEnv>(
       ? parseSearchParams(ctx.searchParams, searchSchema)
       : {};
 
-    const loaderCtx: LoaderContext<Record<string, string | undefined>, TEnv> = {
+    const loaderCtx: LoaderContext<Record<string, string | undefined>, TEnv> & {
+      _routeName?: string;
+    } = {
       params: ctx.params,
       routeParams: (ctx.params ?? {}) as Record<string, string>,
       request: ctx.request,
@@ -1666,6 +1668,7 @@ export function createUseFunction<TEnv>(
           ? isRouteRootScoped(ctx._routeName, ctx._routerId)
           : undefined,
       ),
+      _routeName: ctx._routeName,
       rendered: () => {
         throw new Error(
           `ctx.rendered() is only available in DSL loaders (registered via loader() in urls()). ` +
@@ -1673,6 +1676,8 @@ export function createUseFunction<TEnv>(
         );
       },
     };
+    // "use cache" keys it by route, like the request ctx it reads (#940).
+    (loaderCtx as any)[NOCACHE_SYMBOL] = true;
 
     // Meter through the same unified phase API as the loader-resolution funnel
     // (observePhase), so a loader resolved via this base request-context ctx.use