@rangojs/router 0.24.4 → 0.26.0

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

@@ -30,12 +30,14 @@ import {
   getParallelSlotEntries,
   isPprEntry,
   type EntryData,
+  type InterceptEntry,
   type LoaderEntry,
 } 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 { FILL_PARAM, PREFETCH_HEADER } from "../../prefetch-markers.js";
+import { isInterceptSegment } from "../../browser/intercept-utils.js";
 
 /**
  * What a request says it is, read once when its context is created
@@ -271,40 +273,64 @@ export function resolveDeferralScope(
   return scope;
 }
 
+const interceptScopes = new WeakMap<InterceptEntry, DeferralScope>();
+
+/**
+ * The deferral scope of a request that resolves `intercept`: its own flagged
+ * loaders, nothing of the target chain. The chain's layouts below the
+ * declaring entry render in that request and its `matched` leaves them out
+ * (match-result.ts), so a hole there would stand for a segment outside the
+ * page. A flagged loading() inside intercept() defers nothing: the slot is
+ * never a unit. Memoized on the entry (replaced with its manifest on HMR).
+ */
+export function resolveInterceptDeferralScope(
+  intercept: InterceptEntry,
+): DeferralScope {
+  const cached = interceptScopes.get(intercept);
+  if (cached) return cached;
+  const flagged = intercept.loader.filter((l) => l.prefetch === false);
+  const scope: DeferralScope =
+    flagged.length === 0
+      ? EMPTY_SCOPE
+      : {
+          loaders: new Map(flagged.map((l) => [l, true as const])),
+          loaderIds: new Set(flagged.map((l) => l.loader.$$id)),
+          units: new Map(),
+        };
+  interceptScopes.set(intercept, scope);
+  return scope;
+}
+
 /**
  * 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
  * 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, an intercept resolves its loaders outside the shared funnel, and a
- * shell capture is never a prefetch whatever the request that scheduled it
- * sent. The four conditions overlap today (an action is a POST, a capture
- * runs the full match): each one states its own reason.
+ * changed, and a shell capture is never a prefetch whatever the request that
+ * scheduled it sent. The conditions overlap today (an action is a POST, a
+ * capture runs the full match): each one states its own reason.
  */
 export function partialDeferralMode(request: {
   fill: boolean;
   prefetch: boolean;
   method: string;
   isAction: boolean;
-  isIntercept: boolean;
   isShellCapture: boolean;
 }): PrefetchDeferral["mode"] {
   if (request.method !== "GET") return undefined;
   if (request.fill) return "fill";
-  return request.prefetch &&
-    !request.isAction &&
-    !request.isIntercept &&
-    !request.isShellCapture
+  return request.prefetch && !request.isAction && !request.isShellCapture
     ? "prefetch"
     : undefined;
 }
 
-const NOTHING_HELD: ReadonlySet<string> = new Set();
+export const NOTHING_HELD: ReadonlySet<string> = new Set();
 
 /**
  * The plan for one match, or undefined when the tree declares no flag and the
  * request is not a fill (the common case: nothing to carry). `held` is the
- * client's segment ids as the request listed them.
+ * client's segment ids as the request listed them. `scope` is the chain's
+ * unless the request resolves an intercept (resolveInterceptDeferralScope).
  */
 export function planPrefetchDeferral(
   entries: readonly EntryData[],
@@ -312,8 +338,8 @@ export function planPrefetchDeferral(
   matched: { pr?: boolean; od?: boolean },
   cacheScope: CacheScope | null | undefined,
   held: ReadonlySet<string> = NOTHING_HELD,
+  scope: DeferralScope = resolveDeferralScope(entries),
 ): PrefetchDeferral | undefined {
-  const scope = resolveDeferralScope(entries);
   if (scope === EMPTY_SCOPE && mode !== "fill") return undefined;
 
   const leaf = entries[entries.length - 1];
@@ -386,6 +412,30 @@ export function fillSends(
   return isFillRequest(ctx) ? !held.has(segmentId) : undefined;
 }
 
+/**
+ * A fill that resolves an intercept sends only what the client lacks of the
+ * intercept: a target-chain entry (by id) or stored segment it does not hold
+ * lies outside the intercept's `matched` (match-result.ts), so the fill skips
+ * it. The intercept's own segments are never skipped.
+ */
+export function interceptFillSkips(
+  match: {
+    handlerContext: HandlerContext<any, any>;
+    isIntercept: boolean;
+    clientSegmentSet: ReadonlySet<string>;
+  },
+  segment: string | { id: string; namespace?: string },
+): boolean {
+  if (!match.isIntercept) return false;
+  if (typeof segment !== "string") {
+    if (isInterceptSegment(segment)) return false;
+    segment = segment.id;
+  }
+  return (
+    fillSends(match.handlerContext, segment, match.clientSegmentSet) === true
+  );
+}
+
 const RECORD_OPEN: RecordUse = { read: true, write: true, refresh: true };
 
 /** PrefetchDeferral.record, or all of it open when the match has no plan. */

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

@@ -43,6 +43,7 @@ import {
   deferUnit,
   fillSends,
   getPrefetchDeferral,
+  interceptFillSkips,
   registerDeferredLoader,
 } from "./prefetch-deferral.js";
 import {
@@ -58,6 +59,7 @@ import { applyViewTransitionDefault } from "./view-transition-default.js";
 import { isLayoutLoaderCopy } from "../../client-urls/layout-loader-copies.js";
 import { getRouterContext } from "../router-context.js";
 import { observeEvent, observeSegmentHandler } from "../instrument.js";
+import { withReverseScope } from "../handler-context.js";
 import { runInSegmentTagScope } from "../../cache/cache-tag.js";
 import { trackStreamedHandler } from "./streamed-handler-boundary.js";
 import {
@@ -156,7 +158,7 @@ const deferredLoaderRuns = new WeakMap<ResolvedSegment, () => unknown>();
  * awaits; a streamed handler that reads the loader later is not seen, and
  * that loader runs again in the fill.
  */
-function deliverStartedLoaders<TEnv>(
+export function deliverStartedLoaders<TEnv>(
   ctx: HandlerContext<any, TEnv>,
   segments: ResolvedSegment[],
 ): void {
@@ -180,14 +182,51 @@ function deliverStartedLoaders<TEnv>(
 // ---------------------------------------------------------------------------
 
 /**
- * Resolve loaders with revalidation awareness (for partial rendering).
- * Returns both segments to render AND all matched segment IDs.
+ * Whose loaders a resolveOwnerLoaders call resolves: a route entry's (or the
+ * entry its loaders are inherited into), or an intercept's, whose loaders are
+ * loader segments of its slot (`${parent}.${slot}D${i}.${$$id}`).
  */
-export async function resolveLoadersWithRevalidation<TEnv>(
+export interface LoaderOwner {
+  readonly loaders: readonly LoaderEntry[];
+  /** The segments' namespace: the entry id, or `intercept:${routeName}`. */
+  readonly namespace: string;
+  /** The segment id the loader ids extend and the handle pushes file under. */
+  readonly segmentPrefix: string;
+  /** Where a loader error renders (wrapLoaderPromise). */
+  readonly boundary: EntryData;
+  /**
+   * resolveLoaderData's PPR bake/seed key for every loader (loader-cache.ts).
+   * False for an intercept: never a document.
+   */
+  readonly bakeLane: boolean;
+  readonly traceSource: "loader" | "intercept-loader";
+}
+
+/** A route entry as a LoaderOwner, under `shortCodeOverride` when inherited. */
+export function ownerOf(
   entry: EntryData,
+  shortCodeOverride?: string,
+): LoaderOwner {
+  return {
+    loaders: entry.loader ?? [],
+    namespace: entry.id,
+    segmentPrefix: shortCodeOverride ?? entry.shortCode,
+    boundary: entry,
+    bakeLane: !entryLoadingMasksLoaders(entry.loading),
+    traceSource: "loader",
+  };
+}
+
+/**
+ * The partial lane's one loader funnel: each loader is a segment, run when
+ * the client lacks it, asked its revalidate() when held, kept outright in a
+ * fill (fillSends), deferred in a prefetch that defers it (defersLoader).
+ */
+export async function resolveOwnerLoaders<TEnv>(
+  owner: LoaderOwner,
   ctx: HandlerContext<any, TEnv>,
   belongsToRoute: boolean,
-  clientSegmentIds: Set<string>,
+  clientSegmentIds: ReadonlySet<string>,
   prevParams: Record<string, string>,
   request: Request,
   prevUrl: URL,
@@ -195,13 +234,12 @@ export async function resolveLoadersWithRevalidation<TEnv>(
   routeKey: string,
   deps: SegmentResolutionDeps<TEnv>,
   actionContext?: ActionContext,
-  shortCodeOverride?: string,
   stale?: boolean,
 ): Promise<{ segments: ResolvedSegment[]; matchedIds: string[] }> {
-  const loaderEntries = entry.loader ?? [];
+  const loaderEntries = owner.loaders;
   if (loaderEntries.length === 0) return { segments: [], matchedIds: [] };
 
-  const shortCode = shortCodeOverride ?? entry.shortCode;
+  const shortCode = owner.segmentPrefix;
 
   // Pin `_currentSegmentId` to the OWNING entry before the kickoffs below —
   // createLoaderExecutor captures it synchronously for ctx.use(Handle) push
@@ -238,7 +276,7 @@ export async function resolveLoadersWithRevalidation<TEnv>(
                   segmentId,
                   segmentType: "loader",
                   belongsToRoute,
-                  source: "loader",
+                  source: owner.traceSource,
                   defaultShouldRevalidate: true,
                   finalShouldRevalidate: true,
                   reason: "new-segment",
@@ -249,7 +287,7 @@ export async function resolveLoadersWithRevalidation<TEnv>(
 
             const dummySegment: ResolvedSegment = {
               id: segmentId,
-              namespace: entry.id,
+              namespace: owner.namespace,
               type: "loader",
               index,
               component: null,
@@ -268,14 +306,14 @@ export async function resolveLoadersWithRevalidation<TEnv>(
               prevUrl,
               nextUrl,
               revalidations: loaderRevalidateFns.map((fn, j) => ({
-                name: `loader-revalidate${j}`,
+                name: `${owner.traceSource}-revalidate${j}`,
                 fn,
               })),
               routeKey,
               context: ctx,
               actionContext,
               stale,
-              traceSource: "loader",
+              traceSource: owner.traceSource,
               held: clientSegmentIds,
             });
           },
@@ -300,7 +338,7 @@ export async function resolveLoadersWithRevalidation<TEnv>(
   // Outside capture the key only activates the _shellLoaderSeed overlay,
   // which serveShellHit seeds for a document HIT and the PPR partial replay
   // (matchPartialWithPprReplay) seeds once its doc record hits.
-  const bakeLane = !entryLoadingMasksLoaders(entry.loading);
+  const bakeLane = owner.bakeLane;
 
   const kickoff = (
     loaderEntry: LoaderEntry,
@@ -319,6 +357,7 @@ export async function resolveLoadersWithRevalidation<TEnv>(
           bakeLane || loaderEntry.bake === true ? segmentId : null,
         ),
       loaderId,
+      loaderEntry.reverseScope,
     );
   const start = (
     loaderEntry: LoaderEntry,
@@ -327,7 +366,7 @@ export async function resolveLoadersWithRevalidation<TEnv>(
   ) =>
     deps.wrapLoaderPromise(
       kickoff(loaderEntry, segmentId, loaderId),
-      entry,
+      owner.boundary,
       segmentId,
       ctx.pathname,
       errorContext,
@@ -338,7 +377,7 @@ export async function resolveLoadersWithRevalidation<TEnv>(
     ({ loaderEntry, loader, segmentId, index }) => {
       const base = {
         id: segmentId,
-        namespace: entry.id,
+        namespace: owner.namespace,
         type: "loader" as const,
         index,
         component: null,
@@ -411,8 +450,8 @@ export async function resolveLoadersOnlyWithRevalidation<TEnv>(
         seenIds.has(`${sc}D${i}.${le.loader.$$id}`),
       );
     if (!allAlreadySeen) {
-      const { segments, matchedIds } = await resolveLoadersWithRevalidation(
-        entry,
+      const { segments, matchedIds } = await resolveOwnerLoaders(
+        ownerOf(entry, shortCodeOverride),
         context,
         belongsToRoute,
         clientSegmentIds,
@@ -423,7 +462,6 @@ export async function resolveLoadersOnlyWithRevalidation<TEnv>(
         routeKey,
         deps,
         actionContext,
-        shortCodeOverride,
         stale,
       );
       for (const seg of segments) {
@@ -454,8 +492,8 @@ export async function resolveLoadersOnlyWithRevalidation<TEnv>(
         entry.loader.length > 0 &&
         Object.keys(layoutEntry.parallel).length > 0
       ) {
-        const inherited = await resolveLoadersWithRevalidation(
-          entry,
+        const inherited = await resolveOwnerLoaders(
+          ownerOf(entry, layoutEntry.shortCode),
           context,
           childBelongsToRoute,
           clientSegmentIds,
@@ -466,7 +504,6 @@ export async function resolveLoadersOnlyWithRevalidation<TEnv>(
           routeKey,
           deps,
           actionContext,
-          layoutEntry.shortCode,
           stale,
         );
         for (const seg of inherited.segments) {
@@ -594,10 +631,11 @@ async function resolveParallelSlotComponent<TEnv>(args: {
       (context as InternalHandlerContext<any, TEnv>)._currentSegmentId =
         parallelId;
       handlerRan = true;
+      const slotContext = withReverseScope(context, parallelEntry.reverseScope);
       if (hasLoadingFallback) {
         const result =
           typeof handler === "function"
-            ? runInSegmentTagScope(parallelId, handler, context)
+            ? runInSegmentTagScope(parallelId, handler, slotContext)
             : handler;
         if (result instanceof Promise) {
           warnOnStreamedResponse(result, parallelId);
@@ -616,7 +654,7 @@ async function resolveParallelSlotComponent<TEnv>(args: {
       } else {
         component =
           typeof handler === "function"
-            ? await runInSegmentTagScope(parallelId, handler, context)
+            ? await runInSegmentTagScope(parallelId, handler, slotContext)
             : handler;
       }
     }
@@ -697,8 +735,8 @@ export async function resolveParallelSegmentsWithRevalidation<TEnv>(
     // emitted either before or after the slot segment per loaderOrder.
     const resolveSlotLoaders = async () => {
       if (resolvedParallelEntries.has(parallelEntry.id)) return;
-      const loaderResult = await resolveLoadersWithRevalidation(
-        parallelEntry,
+      const loaderResult = await resolveOwnerLoaders(
+        ownerOf(parallelEntry, entry.shortCode),
         context,
         belongsToRoute,
         clientSegmentIds,
@@ -709,7 +747,6 @@ export async function resolveParallelSegmentsWithRevalidation<TEnv>(
         routeKey,
         deps,
         actionContext,
-        entry.shortCode,
         stale,
       );
       segments.push(...loaderResult.segments);
@@ -1095,8 +1132,8 @@ export async function resolveSegmentWithRevalidation<TEnv>(
 
   const belongsToRoute = entry.type === "route";
 
-  const loaderResult = await resolveLoadersWithRevalidation(
-    entry,
+  const loaderResult = await resolveOwnerLoaders(
+    ownerOf(entry),
     context,
     belongsToRoute,
     clientSegmentIds,
@@ -1107,7 +1144,6 @@ export async function resolveSegmentWithRevalidation<TEnv>(
     routeKey,
     deps,
     actionContext,
-    undefined,
     stale,
   );
   segments.push(...loaderResult.segments);
@@ -1266,8 +1302,8 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
   const segments: ResolvedSegment[] = [];
   const matchedIds: string[] = [];
 
-  const loaderResult = await resolveLoadersWithRevalidation(
-    orphan,
+  const loaderResult = await resolveOwnerLoaders(
+    ownerOf(orphan),
     context,
     belongsToRoute,
     clientSegmentIds,
@@ -1278,7 +1314,6 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
     routeKey,
     deps,
     actionContext,
-    undefined,
     stale,
   );
   segments.push(...loaderResult.segments);
@@ -1292,8 +1327,8 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
     parentRouteEntry.loader.length > 0 &&
     Object.keys(orphan.parallel).length > 0
   ) {
-    const inheritedResult = await resolveLoadersWithRevalidation(
-      parentRouteEntry,
+    const inheritedResult = await resolveOwnerLoaders(
+      ownerOf(parentRouteEntry, orphan.shortCode),
       context,
       belongsToRoute,
       clientSegmentIds,
@@ -1304,7 +1339,6 @@ export async function resolveOrphanLayoutWithRevalidation<TEnv>(
       routeKey,
       deps,
       actionContext,
-      orphan.shortCode,
       stale,
     );
     // Tag as inherited so buildMatchResult can deduplicate when safe
@@ -1491,6 +1525,11 @@ export async function resolveAllSegmentsWithRevalidation<TEnv>(
   latchPprHeaderScopeForEntries(entries, routeKey);
 
   const telemetry = getRouterContext()?.telemetry;
+  const fillMatch = {
+    handlerContext: context,
+    isIntercept: !!interceptResult,
+    clientSegmentSet,
+  };
 
   for (const entry of entries) {
     if (entry.type === "route" && interceptResult) {
@@ -1508,6 +1547,7 @@ export async function resolveAllSegmentsWithRevalidation<TEnv>(
       }
       continue;
     }
+    if (interceptFillSkips(fillMatch, entry.shortCode)) continue;
 
     const nonParallelEntry = entry as Exclude<EntryData, { type: "parallel" }>;
     // Same latch as resolveAllSegments (fresh.ts), route-level cache() included.

package/src/router/segment-resolution.ts

@@ -14,7 +14,6 @@ export {
   resolveLoadersOnly,
 } from "./segment-resolution/fresh.js";
 export {
-  resolveLoadersWithRevalidation,
   resolveLoadersOnlyWithRevalidation,
   buildEntryRevalidateMap,
   resolveParallelSegmentsWithRevalidation,

package/src/router/segment-wrappers.ts

@@ -6,6 +6,7 @@ import type {
 } from "../types";
 import type { SegmentResolutionDeps } from "./types.js";
 import type { ResolveSegmentOptions } from "./segment-resolution.js";
+import type { RevalidationContext } from "./router-context.js";
 
 import {
   resolveAllSegments as _resolveAllSegments,
@@ -96,19 +97,15 @@ export interface SegmentWrappers<TEnv = any> {
     context: HandlerContext<any, TEnv>,
     belongsToRoute?: boolean,
     revalidationContext?: any,
-    options?: { skipMiddleware?: boolean },
+    options?: { background?: boolean },
   ) => Promise<ResolvedSegment[]>;
   resolveInterceptLoadersOnly: (
     interceptEntry: InterceptEntry,
     parentEntry: EntryData,
-    params: Record<string, string>,
     context: HandlerContext<any, TEnv>,
-    belongsToRoute?: boolean,
-    revalidationContext?: any,
-  ) => Promise<{
-    loaderDataPromise: Promise<any[]> | any[];
-    loaderIds: string[];
-  } | null>;
+    belongsToRoute: boolean,
+    revalidationContext: RevalidationContext,
+  ) => Promise<ResolvedSegment[]>;
 }
 
 /**
@@ -250,7 +247,7 @@ export function createSegmentWrappers<TEnv = any>(
     context: HandlerContext<any, TEnv>,
     belongsToRoute: boolean = true,
     revalidationContext?: any,
-    options?: { skipMiddleware?: boolean },
+    options?: { background?: boolean },
   ): ReturnType<typeof _resolveInterceptEntry> {
     return _resolveInterceptEntry(
       interceptEntry,
@@ -267,15 +264,13 @@ export function createSegmentWrappers<TEnv = any>(
   function resolveInterceptLoadersOnly(
     interceptEntry: InterceptEntry,
     parentEntry: EntryData,
-    params: Record<string, string>,
     context: HandlerContext<any, TEnv>,
-    belongsToRoute: boolean = true,
-    revalidationContext: any,
+    belongsToRoute: boolean,
+    revalidationContext: RevalidationContext,
   ): ReturnType<typeof _resolveInterceptLoadersOnly> {
     return _resolveInterceptLoadersOnly(
       interceptEntry,
       parentEntry,
-      params,
       context,
       belongsToRoute,
       segmentDeps,

package/src/router/substitute-pattern-params.ts

@@ -20,8 +20,9 @@ import { parsePattern } from "./parse-pattern.js";
  *                         omit when absent.
  *
  * Shared by `ctx.reverse()` (server), `createReverse()` (typed runtime
- * helper), and `useReverse()` (client hook). The behavior must stay
- * identical across all three call sites.
+ * helper), `useReverse()` (client hook), and the include() mount fill of
+ * `useHref()` and relative `useRouter().push`. The behavior must stay
+ * identical across all of them.
  */
 export function substitutePatternParams(
   pattern: string,

package/src/router/tracing.ts

@@ -24,8 +24,8 @@
  * registry; do not call traceSpan directly from new code.
  *
  * Phase coverage (all via observePhase): rango.request (span-only; handler:total
- * metered directly), rango.middleware (span-only incl. intercept middleware;
- * pre/post metered directly), rango.action (action:<id>; server-action
+ * metered directly), rango.middleware (span-only; pre/post metered directly),
+ * rango.action (action:<id>; server-action
  * execution, JS + no-JS/PE), rango.loader (loader:<id>; single metering site at
  * useLoader, plus the fetchable path), rango.handler (span-only, one per segment
  * route/layout handler execution; the handler:<id> perf metric is owned by the

package/src/router-versions.ts

@@ -33,24 +33,24 @@ export type RouterVersionsTable = Readonly<
 /** Table key of the whole-build versions. Not a legal `$$id` (8 hex chars). */
 export const DEFAULT_ROUTER_VERSIONS_KEY = "*";
 
-/** One value for both versions: a consumer-set `version`, or the dev stamp. */
+/**
+ * One value for both versions: the dev stamp, the version a build-time shell
+ * capture is asked for, or a test's seed.
+ */
 export function uniformVersions(version: string): RouterVersions {
   return { data: version, document: version };
 }
 
 /**
- * The versions a router serves with under `table`: a consumer-set `version`
- * for both; else the router's own entry; else the whole-build pair, for a
- * router the table does not list. `undefined` when there is no table (dev,
- * tests) or it has neither entry. One function for the request handler and
+ * The versions a router serves with under `table`: the router's own entry,
+ * else the whole-build pair, for a router the table does not list.
+ * `undefined` when there is no table (dev, tests) or it has neither entry. One function for the request handler and
  * the build's shell capture, which must stamp what the handler will check.
  */
 export function resolveVersionsFrom(
   table: RouterVersionsTable | undefined,
   routerId: string | undefined,
-  override: string | undefined,
 ): RouterVersions | undefined {
-  if (override !== undefined) return uniformVersions(override);
   if (!table) return undefined;
   const pair =
     (routerId !== undefined && Object.hasOwn(table, routerId)

package/src/router.ts

@@ -170,7 +170,6 @@ export function createRouter<TEnv = any>(
     $$routeNames: staticRouteNames,
     $$sourceFile: injectedSourceFile,
     nonce,
-    version,
     prefetchCacheTTL: prefetchCacheTTLOption,
     prefetchCacheSize: prefetchCacheSizeOption,
     prefetchConcurrency: prefetchConcurrencyOption,
@@ -276,14 +275,8 @@ export function createRouter<TEnv = any>(
   );
 
   // Resolve prefetch cache TTL (default: 300 seconds / 5 minutes). Clamps to a
-  // non-negative integer and guards non-finite (NaN/Infinity) inputs so a
-  // malformed `Cache-Control: max-age=NaN` can never reach the wire.
-  const resolvedPrefetchCacheTTL = resolvePrefetchCacheTTL(
-    prefetchCacheTTLOption,
-  );
-  const prefetchCacheTTL = resolvedPrefetchCacheTTL.ms;
-  const prefetchCacheControl: string | false =
-    resolvedPrefetchCacheTTL.cacheControl;
+  // non-negative integer and guards non-finite (NaN/Infinity) inputs.
+  const prefetchCacheTTL = resolvePrefetchCacheTTL(prefetchCacheTTLOption).ms;
 
   // Resolve client-side prefetch limits (in-memory cache size and queue
   // concurrency). Both are positive-integer counts; sub-1/non-finite inputs
@@ -777,7 +770,7 @@ export function createRouter<TEnv = any>(
   // handler's overlay read makes (resolvePrerenderVersion), so the keys agree.
   const prerenderTrigger = createPrerenderTrigger<TEnv, {}>({
     routerId,
-    resolveVersion: () => resolvePrerenderVersion(routerId, version),
+    resolveVersion: () => resolvePrerenderVersion(routerId),
     isDev: isDevEnvironment,
     isViteDevServer,
     ensureManifest: () => ensureRouterManifest(routerId),
@@ -809,7 +802,7 @@ export function createRouter<TEnv = any>(
         {},
         {
           ...prerenderDeps,
-          versions: resolveRouterVersions(routerId, version),
+          versions: resolveRouterVersions(routerId),
         },
         undefined,
         isPassthrough,
@@ -818,7 +811,7 @@ export function createRouter<TEnv = any>(
         true,
       ),
     // A warm goes through router.fetch's handler: the one createRouter's own
-    // cache, nonce and version configure. An entry that passes them to
+    // cache and nonce configure. An entry that passes them to
     // createRSCHandler itself is not what a warm runs.
     resolveCacheConfig: (env, ctx) =>
       typeof cache === "function" ? cache(env, ctx) : cache,
@@ -1153,7 +1146,6 @@ export function createRouter<TEnv = any>(
     cacheProfiles: resolvedCacheProfiles,
 
     // Expose prefetch cache settings
-    prefetchCacheControl,
     prefetchCacheTTL,
     prefetchCacheSize,
     prefetchConcurrency,
@@ -1229,9 +1221,6 @@ export function createRouter<TEnv = any>(
     // Expose nonce provider for fetch
     nonce,
 
-    // Expose version for fetch
-    version,
-
     // Expose urlpatterns for runtime manifest generation
     get urlpatterns() {
       return storedUrlPatterns ?? undefined;
@@ -1299,7 +1288,6 @@ export function createRouter<TEnv = any>(
             router: router as any,
             cache,
             nonce,
-            version,
           }) as (
             request: Request,
             input: RouterRequestInput<TEnv>,