@rangojs/router 0.31.0 → 0.33.0

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

@@ -7,6 +7,7 @@
 import type {
   ResolvedSegment,
   HandlerContext,
+  InternalHandlerContext,
   ShouldRevalidateFn,
 } from "../types";
 import type { ActionContext } from "./types";
@@ -20,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;
@@ -154,17 +157,54 @@ 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;
-  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 && 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;
   }
 
   let defaultShouldRevalidate: boolean;
   let defaultReason: string;
+  // The default hangs on paramsChanged / searchChanged (the nav lane below).
+  let defaultComparesSource = false;
 
   if (defaultOverride) {
     defaultShouldRevalidate = defaultOverride.value;
@@ -188,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;
@@ -236,20 +278,16 @@ 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);
 
@@ -257,11 +295,19 @@ export async function evaluateRevalidation<TEnv>(
     let result: any;
     try {
       result = fn({
-        currentParams: prevSegment?.params || prevParams, // Use segment params if available, else route params
-        currentUrl: prevUrl,
+        get currentParams() {
+          return (recordedParams ??= recordingParams(currentParams, reads));
+        },
+        get currentUrl() {
+          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,
@@ -275,7 +321,10 @@ export async function evaluateRevalidation<TEnv>(
         formData: actionContext?.formData,
         method: request.method,
         routeName: toRouteName,
-        fromRouteName,
+        get fromRouteName() {
+          reads.route = true;
+          return fromRouteName;
+        },
         toRouteName,
         stale: cacheStale ? true : stale,
       });
@@ -326,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" &&
@@ -352,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

package/src/router/segment-resolution/prefetch-deferral.ts

@@ -32,27 +32,41 @@ import {
   type EntryData,
   type InterceptEntry,
   type LoaderEntry,
+  segmentPinOf,
 } from "../../server/context.js";
 import { requestHeaders } from "../../server/request-headers.js";
 import type { HandlerContext, InternalHandlerContext } from "../../types.js";
 import type { CacheScope } from "../../cache/cache-scope.js";
-import { PREFETCH_HEADER } from "../../prefetch-markers.js";
+import { PREFETCH_HEADER, PREFETCH_INTENT } from "../../prefetch-markers.js";
 import { WIRE } from "../../wire-params.js";
 import { isInterceptSegment } from "../../browser/intercept-utils.js";
 
 /**
  * What a request says it is, read once when its context is created
  * (RequestContext._requestKind). A fill is marked on the raw URL and wins
- * over the prefetch header. Whether a prefetch defers anything is decided per
- * match, by partialDeferralMode: a shell capture inherits the context of the
- * request that scheduled it and is never a prefetch.
+ * over the prefetch header. `"prefetch"` is a speculative prefetch (viewport,
+ * render) and `"intent"` a hover or an explicit `prefetch()` call
+ * (PREFETCH_INTENT): both are prefetches, and only the first defers. Whether
+ * a prefetch defers anything is decided per match, by partialDeferralMode: a
+ * shell capture inherits the context of the request that scheduled it and is
+ * never a prefetch.
  */
 export function requestKind(
   request: Request,
   rawUrl: URL,
-): "prefetch" | "fill" | undefined {
+): RequestKind | undefined {
   if (rawUrl.searchParams.has(WIRE.fill)) return "fill";
-  return requestHeaders(request).has(PREFETCH_HEADER) ? "prefetch" : undefined;
+  const prefetch = requestHeaders(request).get(PREFETCH_HEADER);
+  if (prefetch === null) return undefined;
+  return prefetch === PREFETCH_INTENT ? "intent" : "prefetch";
+}
+
+/** requestKind's answer for a marked request. */
+export type RequestKind = "prefetch" | "intent" | "fill";
+
+/** A prefetch of either kind: speculative or intent. */
+export function isPrefetchKind(kind: RequestKind | undefined): boolean {
+  return kind === "prefetch" || kind === "intent";
 }
 
 /** Static, per matched chain. */
@@ -173,7 +187,6 @@ const EMPTY_SCOPE: DeferralScope = {
 };
 
 const scopes = new WeakMap<EntryData, DeferralScope>();
-const warnedBakeLoaders = new Set<string>();
 
 /**
  * The deferral scope of a matched chain, memoized on its leaf entry (entries
@@ -192,9 +205,6 @@ export function resolveDeferralScope(
   const loaderIds = new Set<string>();
   const units = new Map<EntryData, DeferralUnit>();
   const chain = new Set(entries);
-  // ssr: false on a ppr route is the bake lane (loader-cache.ts
-  // resolveLoaderData): shell material, served from the record.
-  const pprRoute = isPprEntry(leaf);
   // A clientUrls() group route renders loading() itself and its handler is
   // ClientUrlsRoot (segment-system.tsx keys it by group): a unit would hand
   // React a promise in place of the optimistic destination on screen. So
@@ -214,20 +224,8 @@ export function resolveDeferralScope(
     for (const loaderEntry of entry.loader ?? []) {
       const own = loaderEntry.prefetch === false;
       if (!own && behind.length === 0) continue;
-      if (pprRoute && loaderEntry.bake) {
-        if (
-          process.env.NODE_ENV !== "production" &&
-          loaderEntry.prefetch === false &&
-          !warnedBakeLoaders.has(loaderEntry.loader.$$id)
-        ) {
-          warnedBakeLoaders.add(loaderEntry.loader.$$id);
-          console.warn(
-            `[rango] loader "${loaderEntry.loader.$$id}" is registered with ssr: false and prefetch: false on a ppr route ("${leaf.id}"). ` +
-              `Under ppr an ssr: false loader is baked into the shell and served from it, so prefetch: false is ignored there. Drop one of the two options.`,
-          );
-        }
-        continue;
-      }
+      // An ssr: false loader on a ppr route is in scope too: whether this
+      // request serves it from a shell pin is per request (defersLoader).
       loaders.set(loaderEntry, own ? true : behind);
       loaderIds.add(loaderEntry.loader.$$id);
     }
@@ -303,7 +301,9 @@ export function resolveInterceptDeferralScope(
 
 /**
  * Which half of the feature a partial request is, if either (`fill` and
- * `prefetch` are requestKind's answer). Both halves are GETs: a request of
+ * `prefetch` are requestKind's answer). `prefetch` is a speculative prefetch
+ * only: an intent prefetch defers nothing, like the navigation it starts
+ * early (R16). Both halves are GETs: a request of
  * another method that carries either marker is a normal request. A prefetch
  * defers only on a plain GET navigation: an action re-renders what it
  * changed, and a shell capture is never a prefetch whatever the request that
@@ -496,7 +496,7 @@ export function startDeferredLoader(
 /**
  * The segment a run of `loaderId` files its handle pushes under: the one
  * that registers it when it is registered (registerDeferredLoader), else the
- * segment being resolved.
+ * segment whose code starts it (segmentPinOf).
  */
 export function loaderOwner(
   ctx: HandlerContext<any, any>,
@@ -504,8 +504,7 @@ export function loaderOwner(
 ): string | undefined {
   const internal = ctx as InternalHandlerContext<any, any>;
   return (
-    internal._deferredLoaders?.get(loaderId)?.owner ??
-    internal._currentSegmentId
+    internal._deferredLoaders?.get(loaderId)?.owner ?? segmentPinOf(internal)
   );
 }
 
@@ -514,18 +513,26 @@ export function loaderOwner(
  * does not hold that segment, and the loader is flagged itself or sits behind
  * the fallback of a flagged entry the client does not hold either. Under a
  * flagged layout the client holds, a new route's loaders run.
+ *
+ * `servesPin` (loader-cache.ts servesLoaderPin) answers whether this request
+ * serves the loader from a pin of a document-captured shell. Such a loader
+ * is not deferred: its body does not decide the value, and the pin is what
+ * the document shows. On every other request it would run, so it is
+ * deferred as on a route without ppr. Asked when loaders resolve, after a
+ * replay HIT has armed the pins (rsc-rendering.ts matchPartialWithPprReplay).
  */
 export function defersLoader(
   ctx: HandlerContext<any, any>,
   loaderEntry: LoaderEntry,
   segmentId: string,
+  servesPin: (loaderEntry: LoaderEntry) => boolean,
 ): boolean {
   const plan = getPrefetchDeferral(ctx);
   if (plan?.mode !== "prefetch" || plan.held.has(segmentId)) return false;
   const by = plan.scope.loaders.get(loaderEntry);
-  return (
-    by === true || (by !== undefined && by.some((id) => !plan.held.has(id)))
-  );
+  const deferrable =
+    by === true || (by !== undefined && by.some((id) => !plan.held.has(id)));
+  return deferrable && !servesPin(loaderEntry);
 }
 
 /** A unit whose handler output is not stored: a prefetch can skip it. */

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

@@ -40,7 +40,7 @@ import {
   pushRevalidationTraceEntry,
   isTraceActive,
 } from "../logging.js";
-import { resolveLoaderData } from "./loader-cache.js";
+import { resolveLoaderData, servesLoaderPin } from "./loader-cache.js";
 import {
   entryLoadingMasksLoaders,
   isShellCaptureActive,
@@ -65,6 +65,7 @@ import {
   noteThrower,
 } from "./helpers.js";
 import { applyViewTransitionDefault } from "./view-transition-default.js";
+import { isRenderableLoading } from "../../types/boundaries.js";
 import { isLayoutLoaderCopy } from "../../client-urls/layout-loader-copies.js";
 import { getRouterContext } from "../router-context.js";
 import { observeEvent, observeSegmentHandler } from "../instrument.js";
@@ -74,6 +75,7 @@ import {
   track,
   RangoContext,
   runInsideLoaderScope,
+  runAsSegment,
   latchCachedHeaderScope,
   latchPprHeaderScopeForEntries,
 } from "../../server/context.js";
@@ -267,6 +269,28 @@ export function ownerOf(
   };
 }
 
+/**
+ * A route's loader copies inherited into a child layout with parallel slots
+ * are redundant beside the route's own loader segments: true when the route
+ * renders no loading() fallback on any request, so nothing hides the route's
+ * copy from useLoader() in the slots. A redundant copy is never resolved, on
+ * any request: the walkers check this before they inherit.
+ *
+ * Decided from the entry, never from the route segment's `loading`, which
+ * differs between requests: `loading(fallback, { ssr: false })` is `null` on
+ * a document (applyDocumentModeLoading) and the fallback on partials, and the
+ * walkers emit `loading(false)` as `null` too. A copy sent on one request and
+ * not on the next gives the layout a loader entry it did not have, so
+ * renderSegments wraps it in StreamedLoaderErrorBoundary and React remounts
+ * it with its Outlet (docs/tree-structure.md). Resolving a redundant copy and
+ * dropping it from the payload later is not enough: when the route's own
+ * loader is held (its revalidate() declines), the copy is new to the client,
+ * so it re-runs and is sent without the route's copy beside it.
+ */
+export function inheritedCopyRedundant(route: EntryData): boolean {
+  return !isRenderableLoading(route.loading) && route.loadingSsr !== false;
+}
+
 /**
  * resolveOwnerLoaders has something to resolve for `entry`'s loaders. The
  * walker checks before the call: most entries own none, and the async call
@@ -526,10 +550,14 @@ export async function resolveOwnerLoaders<TEnv>(
     // Only a loader on a segment the client lacks (defersLoader). It
     // would have run. Registered, not started: it runs, and reads its
     // cache(), only if a reader starts it (startDeferredLoader).
-    if (defersLoader(ctx, loaderEntry, segmentId)) {
+    if (defersLoader(ctx, loaderEntry, segmentId, servesLoaderPin)) {
       registerDeferredLoader(ctx, loader.$$id, shortCode, () =>
         kickoff(loaderEntry, segmentId),
       );
+      // A ppr shell record this request restored keeps an ssr: false
+      // loader's pushes as copies that wait for its run (loaderPins "hole").
+      // No run is made here: drop them, the fill sends the run's pushes.
+      _getRequestContext()?._handleStore?.settleLoaderRun(loader.$$id);
       const deferred: ResolvedSegment = {
         id: segmentId,
         namespace: owner.namespace,
@@ -656,7 +684,8 @@ export async function resolveLoadersOnly<TEnv>(
         entry.type === "route" &&
         entry.loader &&
         entry.loader.length > 0 &&
-        Object.keys(layoutEntry.parallel).length > 0
+        Object.keys(layoutEntry.parallel).length > 0 &&
+        !inheritedCopyRedundant(entry)
       ) {
         const inherited = await resolveOwnerLoaders(
           pass,
@@ -666,7 +695,6 @@ export async function resolveLoadersOnly<TEnv>(
         for (const seg of inherited.segments) {
           if (!seenIds.has(seg.id)) {
             seenIds.add(seg.id);
-            seg._inherited = true;
             allLoaderSegments.push(seg);
           }
         }
@@ -805,7 +833,7 @@ async function resolveParallelSlotComponent<TEnv>(
       // A throw before the slot streams reaches the owning entry's boundary.
       try {
         if (hasLoadingFallback) {
-          const result = run();
+          const result = runAsSegment(parallelId, run);
           if (result instanceof Promise) {
             warnOnStreamedResponse(result, parallelId);
             result.finally(doneHandler).catch(() => {});
@@ -1174,7 +1202,9 @@ async function resolveRouteComponent<TEnv>(
   }
   if (!actionContext) {
     const result = handleHandlerResult(
-      observeSegmentHandler(entry.shortCode, entry.id, handler, context),
+      runAsSegment(entry.shortCode, () =>
+        observeSegmentHandler(entry.shortCode, entry.id, handler, context),
+      ),
     );
     if (result instanceof Promise) {
       warnOnStreamedResponse(result, entry.id);
@@ -1475,17 +1505,14 @@ export async function resolveOrphanLayout<TEnv>(
     parentRouteEntry &&
     parentRouteEntry.loader &&
     parentRouteEntry.loader.length > 0 &&
-    Object.keys(orphan.parallel).length > 0
+    Object.keys(orphan.parallel).length > 0 &&
+    !inheritedCopyRedundant(parentRouteEntry)
   ) {
     const inheritedResult = await resolveOwnerLoaders(
       pass,
       ownerOf(parentRouteEntry, orphan.shortCode),
       belongsToRoute,
     );
-    // Tag as inherited so buildMatchResult can deduplicate when safe
-    for (const s of inheritedResult.segments) {
-      s._inherited = true;
-    }
     segments.push(...inheritedResult.segments);
     matchedIds.push(...inheritedResult.matchedIds);
   }
@@ -1505,7 +1532,8 @@ export async function resolveOrphanLayout<TEnv>(
       handlerRan = true;
       // Its handler's pushes are its own. Pinned only while it runs: a route
       // under loading() streams its handler, whose pushes after an await
-      // read the pin after this returns.
+      // read the pin after this returns where a runtime lost its
+      // runAsSegment scope (segmentPinOf).
       const internal = context as InternalHandlerContext<any, TEnv>;
       const pinned = internal._currentSegmentId;
       internal._currentSegmentId = orphan.shortCode;