@rangojs/router 0.27.0 → 0.28.0

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

@@ -114,6 +114,7 @@ import { createShellImplicitDocScope } from "../../cache/cache-scope.js";
 import { recordSegmentTags } from "../../cache/cache-tag.js";
 import { executionStart } from "../../cache/tag-invalidation.js";
 import { getRouterContext } from "../router-context.js";
+import { interceptRecordKey } from "../intercept-resolution.js";
 import { debugLog, debugWarn, getOrCreateRequestId } from "../logging.js";
 import { INTERNAL_RANGO_DEBUG } from "../../internal-debug.js";
 import type { GeneratorMiddleware } from "./cache-lookup.js";
@@ -284,7 +285,7 @@ export function withCacheStore<TEnv>(
             ctx.pathname,
             ctx.matched.params,
             allSegmentsToCache,
-            ctx.isIntercept,
+            interceptRecordKey(ctx.interceptResult),
             // A capture's doc record lives only in the shell entry, which
             // putShell gates by the capture start; skipping it here would
             // read as a render that produced no record.
@@ -354,7 +355,7 @@ function recordShellCaptureDocRecord<TEnv>(
   segments: ResolvedSegment[],
 ): void {
   const requestCtx = getRequestContext();
-  if (!requestCtx?._shellCaptureRun) return;
+  if (!requestCtx?._shellCaptureState?.run) return;
   const marker = requestCtx._shellImplicitCache;
   if (!marker?.store) return;
   const scope = ctx.cacheScope;
@@ -381,12 +382,7 @@ function recordShellCaptureDocRecord<TEnv>(
   // pushes settled, so the record's handle encode never races them.
   requestCtx.onResponse((response) => {
     requestCtx.waitUntil(() =>
-      docScope.cacheRoute(
-        ctx.pathname,
-        ctx.matched.params,
-        segments,
-        ctx.isIntercept,
-      ),
+      docScope.cacheRoute(ctx.pathname, ctx.matched.params, segments),
     );
     return response;
   });

package/src/router/match-middleware/intercept-resolution.ts

@@ -103,6 +103,7 @@
  */
 import type { ResolvedSegment } from "../../types.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
+import { resolutionPassInput } from "../match-context.js";
 import { getRouterContext } from "../router-context.js";
 import type { GeneratorMiddleware } from "./cache-lookup.js";
 import { debugLog } from "../logging.js";
@@ -175,21 +176,10 @@ export function withInterceptResolution<TEnv>(
     const Store = ctx.Store;
     const interceptSegments = await Store.run(() =>
       resolveInterceptEntry(
+        resolutionPassInput(ctx),
         ctx.interceptResult!.intercept,
         ctx.interceptResult!.entry,
-        ctx.matched.params,
-        ctx.handlerContext,
         true, // belongsToRoute
-        {
-          clientSegmentIds: ctx.clientSegmentSet,
-          prevParams: ctx.prevParams,
-          request: ctx.request,
-          prevUrl: ctx.prevUrl,
-          nextUrl: ctx.url,
-          routeKey: ctx.routeKey,
-          actionContext: ctx.actionContext,
-          stale: ctx.stale,
-        },
       ),
     );
 
@@ -242,20 +232,10 @@ async function handleCacheHitIntercept<TEnv>(
   const loaderSegments = resolveInterceptLoadersOnly
     ? await ctx.Store.run(() =>
         resolveInterceptLoadersOnly(
+          resolutionPassInput(ctx),
           ctx.interceptResult!.intercept,
           ctx.interceptResult!.entry,
-          ctx.handlerContext,
           true, // belongsToRoute
-          {
-            clientSegmentIds: ctx.clientSegmentSet,
-            prevParams: ctx.prevParams,
-            request: ctx.request,
-            prevUrl: ctx.prevUrl,
-            nextUrl: ctx.url,
-            routeKey: ctx.routeKey,
-            actionContext: ctx.actionContext,
-            stale: ctx.stale,
-          },
         ),
       )
     : [];

package/src/router/match-middleware/segment-resolution.ts

@@ -29,15 +29,16 @@
  *  yes          no
  *   |           |
  *   v           v
- * resolveAll  resolveAllWithRevalidation
- * Segments    Segments
- *   |           |
+ * FRESH pass  partial pass
  *   |           | (compares with prev state)
  *   |           | (handles null components)
  *   |           |
  *   +-----------+
  *         |
  *         v
+ *   resolveAllSegments()
+ *         |
+ *         v
  *   +---------------------------+
  *   | Update state:             |
  *   |  - state.segments         |
@@ -54,13 +55,14 @@
  * RESOLUTION MODES
  * ================
  *
+ * Both use resolveAllSegments().
+ *
  * Full Match (document request):
- *   - Uses resolveAllSegments()
- *   - No revalidation logic (nothing to compare against)
+ *   - A FRESH pass (freshPassInput): no revalidation logic (nothing to
+ *     compare against)
  *   - Simple resolution of all route entries
  *
  * Partial Match (navigation):
- *   - Uses resolveAllSegmentsWithRevalidation()
  *   - Compares current vs previous params/URL
  *   - Sets component = null for segments client already has
  *   - Respects custom revalidation rules
@@ -90,6 +92,8 @@ import type { ResolvedSegment } from "../../types.js";
 import type { EntryData } from "../../server/context.js";
 import { _getRequestContext } from "../../server/request-context.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
+import { resolutionPassInput } from "../match-context.js";
+import { freshPassInput } from "../segment-resolution/resolution-pass.js";
 import { getRouterContext } from "../router-context.js";
 import type { GeneratorMiddleware } from "./cache-lookup.js";
 
@@ -155,64 +159,33 @@ export function withSegmentResolution<TEnv>(
       reqCtx._treeHasStreaming = treeHasStreaming(ctx.entries);
     }
 
-    const { resolveAllSegmentsWithRevalidation, resolveAllSegments } =
-      getRouterContext<TEnv>();
-
-    const Store = ctx.Store;
-
-    if (ctx.isFullMatch) {
-      const segments = await Store.run(() =>
-        resolveAllSegments(
-          ctx.entries,
-          ctx.routeKey,
-          ctx.matched.params,
-          ctx.handlerContext,
-          ctx.loaderPromises,
-        ),
-      );
-
-      state.segments = segments;
-      state.matchedIds = segments.map((s: { id: string }) => s.id);
+    const { resolveAllSegments } = getRouterContext<TEnv>();
 
-      if (reqCtx) {
-        reqCtx._resolveRenderBarrier(segments);
-      }
-      for (const segment of segments) {
-        yield segment;
-      }
-    } else {
-      // Partial match (navigation) - resolution with revalidation logic
-      const result = await Store.run(() =>
-        resolveAllSegmentsWithRevalidation(
-          ctx.entries,
-          ctx.routeKey,
-          ctx.matched.params,
-          ctx.handlerContext,
-          ctx.clientSegmentSet,
-          ctx.prevParams,
-          ctx.request,
-          ctx.prevUrl,
-          ctx.url,
-          ctx.actionContext,
-          ctx.interceptResult,
-          ctx.localRouteName,
-          ctx.pathname,
-          ctx.stale,
-        ),
-      );
+    // A full match (interceptResult null) is a FRESH pass.
+    const result = await ctx.Store.run(() =>
+      resolveAllSegments(
+        ctx.isFullMatch
+          ? freshPassInput(ctx.handlerContext, ctx.routeKey, ctx.matched.params)
+          : resolutionPassInput(ctx),
+        ctx.entries,
+        {
+          interceptResult: ctx.interceptResult,
+          localRouteName: ctx.localRouteName,
+          pathname: ctx.pathname,
+        },
+      ),
+    );
 
-      // Update state with resolved segments
-      state.segments = result.segments;
-      state.matchedIds = result.matchedIds;
-
-      if (reqCtx) {
-        reqCtx._resolveRenderBarrier(result.segments);
-      }
+    state.segments = result.segments;
+    state.matchedIds = ctx.isFullMatch
+      ? result.segments.map((s: { id: string }) => s.id)
+      : result.matchedIds;
 
-      // Yield all resolved segments
-      for (const segment of result.segments) {
-        yield segment;
-      }
+    if (reqCtx) {
+      reqCtx._resolveRenderBarrier(result.segments);
+    }
+    for (const segment of result.segments) {
+      yield segment;
     }
 
     if (ms) {

package/src/router/middleware.ts

@@ -542,6 +542,51 @@ function mergeResponse(
   return merged;
 }
 
+/**
+ * The response holder past one middleware. Attached, it reads and writes its
+ * middleware's holder, so a chain shares one response. A middleware that
+ * settles without that run's response while it runs (it returns or throws
+ * its own Response, throws, or rewrites: a timeout fallback, a stale
+ * document cache entry's background re-run, cache/document-cache.ts), or
+ * that calls next() after it returned, detaches that run: the rest of the
+ * chain builds its own response, and the middleware ahead keep what the
+ * middleware settled with. With one holder, a
+ * forgiving middleware ahead of the cache returned the re-run's response,
+ * whose body the cache had drained into the store.
+ */
+class DownstreamHolder implements ResponseHolder {
+  private own: Response | null = null;
+  private attached = true;
+
+  constructor(private readonly parent: ResponseHolder) {}
+
+  get response(): Response | null {
+    return this.attached ? this.parent.response : this.own;
+  }
+
+  set response(response: Response | null) {
+    if (this.attached) this.parent.response = response;
+    else this.own = response;
+  }
+
+  /** From `from`: what the run has seen so far, or a late run's stub. */
+  detach(from: Response | null = this.parent.response): void {
+    this.own = from;
+    this.attached = false;
+  }
+}
+
+/**
+ * A middleware settled without the response of the run its next() started
+ * (its own Response, a throw, a rewrite error) while that run still goes.
+ */
+function detachIfRunning(
+  holder: DownstreamHolder | undefined,
+  nextResolvedAt: number | undefined,
+): void {
+  if (holder && nextResolvedAt === undefined) holder.detach();
+}
+
 /**
  * Execute middleware chain
  *
@@ -575,23 +620,23 @@ export async function executeMiddleware<TEnv>(
   const stubResponse = new Response(null, { status: 200 });
   const responseHolder: ResponseHolder = { response: stubResponse };
 
-  const next = async (): Promise<Response> => {
+  const next = async (holder: ResponseHolder): Promise<Response> => {
     if (index >= middlewares.length) {
       // End of chain - call actual RSC handler
       const response = await finalHandler();
 
       if (isWebSocketUpgradeResponse(response)) {
-        responseHolder.response = response;
+        holder.response = response;
         return response;
       }
 
       // Chain ran to completion: stub headers overwrite (stubOverridesNonCookie)
       // and reqCtx stub headers are merged in.
-      responseHolder.response = mergeResponse(response, stubResponse.headers, {
+      holder.response = mergeResponse(response, stubResponse.headers, {
         stubOverridesNonCookie: true,
       });
 
-      return responseHolder.response;
+      return holder.response;
     }
 
     const middlewareOrdinal = index;
@@ -601,7 +646,7 @@ export async function executeMiddleware<TEnv>(
       env,
       params,
       variables,
-      responseHolder,
+      holder,
       reverse,
     );
     const metricStart = performance.now();
@@ -631,6 +676,8 @@ export async function executeMiddleware<TEnv>(
     // throws after its next(), the render's own error), so a rewrite thrown
     // after it would re-dispatch onto the used handle store.
     let nextRejectedWithRewrite = false;
+    let downstreamHolder: DownstreamHolder | undefined;
+    let settled = false;
     const wrappedNext = (): Promise<Response> => {
       if (nextPromise) {
         throw new Error(
@@ -638,7 +685,9 @@ export async function executeMiddleware<TEnv>(
         );
       }
       finishMiddleware();
-      const downstream = next();
+      downstreamHolder = new DownstreamHolder(holder);
+      if (settled) downstreamHolder.detach(stubResponse);
+      const downstream = next(downstreamHolder);
       nextPromise = downstream.then(
         (res) => {
           nextResolvedAt = performance.now();
@@ -687,10 +736,14 @@ export async function executeMiddleware<TEnv>(
           throw error;
         }
       });
+    } catch (error) {
+      detachIfRunning(downstreamHolder, nextResolvedAt);
+      throw error;
     } finally {
       // Settle the middleware own-time metric once on both the success and
       // error paths (idempotent guard in finishMiddleware).
       finishMiddleware();
+      settled = true;
     }
     // A rewrite after this middleware's next() started the downstream chain
     // (resolved, still running, or failed) would leave that render running
@@ -698,10 +751,14 @@ export async function executeMiddleware<TEnv>(
     // already pushed, and drop the response it built. Only a rewrite after
     // next() rejected with a Rewrite (nothing rendered) unwinds.
     if (rewrite && nextPromise && !nextRejectedWithRewrite) {
+      detachIfRunning(downstreamHolder, nextResolvedAt);
       throw rewriteAfterNextError(entry.handler, rewrite);
     }
     if (rewrite) throw rewrite;
-    if (isRewrite(result)) throw returnedRewriteError(entry.handler);
+    if (isRewrite(result)) {
+      detachIfRunning(downstreamHolder, nextResolvedAt);
+      throw returnedRewriteError(entry.handler);
+    }
 
     // Record post-next() processing time when middleware did work after
     // the downstream chain resolved (e.g. adding headers, logging).
@@ -723,8 +780,9 @@ export async function executeMiddleware<TEnv>(
     // RequestContext stub headers (from cookies().set()) into the
     // returned Response so they are not lost.
     if (result instanceof Response) {
+      detachIfRunning(downstreamHolder, nextResolvedAt);
       if (isWebSocketUpgradeResponse(result)) {
-        responseHolder.response = result;
+        holder.response = result;
         return result;
       }
       // Explicit short-circuit: the returned Response's own headers win
@@ -732,7 +790,7 @@ export async function executeMiddleware<TEnv>(
       const merged = mergeResponse(result, stubResponse.headers, {
         stubOverridesNonCookie: false,
       });
-      responseHolder.response = merged;
+      holder.response = merged;
       return merged;
     }
 
@@ -749,7 +807,7 @@ export async function executeMiddleware<TEnv>(
     // If middleware called next(), await it and return the response
     if (nextPromise) {
       await nextPromise;
-      return responseHolder.response!;
+      return holder.response!;
     }
 
     // Middleware didn't call next() and didn't return a Response - that's an error
@@ -763,7 +821,7 @@ export async function executeMiddleware<TEnv>(
     );
   };
 
-  await next();
+  await next(responseHolder);
 
   // Use the final response from responseHolder (may have been modified by middleware)
   const finalResponse = responseHolder.response;

package/src/router/navigation-snapshot.ts

@@ -1,7 +1,7 @@
 import { isLoaderSegmentId } from "../browser/react/filter-segment-order.js";
 import { requestHeaders } from "../server/request-headers.js";
-import { STALE_PARAM } from "../prefetch-markers.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
+import { WIRE } from "../wire-params.js";
 
 export interface NavigationSnapshot {
   prevUrl: URL;
@@ -106,7 +106,7 @@ export function getInterceptSourceHeader(request: Request): string | null {
  * left, never what renders, so a forged value runs or skips no middleware.
  */
 function getShownRouteUrl(url: URL): URL | null {
-  const shown = url.searchParams.get("_rsc_rt");
+  const shown = url.searchParams.get(WIRE.rewriteTarget);
   if (!shown) return null;
   try {
     const parsed = new URL(shown, url.origin);
@@ -134,8 +134,8 @@ export async function resolveNavigation(
   deps: ResolveNavigationDeps,
 ): Promise<NavigationSnapshot | null> {
   const clientSegmentIds =
-    url.searchParams.get("_rsc_segments")?.split(",").filter(Boolean) || [];
-  const stale = url.searchParams.get(STALE_PARAM) === "true";
+    url.searchParams.get(WIRE.segments)?.split(",").filter(Boolean) || [];
+  const stale = url.searchParams.get(WIRE.stale) === "true";
   const previousUrl = getNavigationContextHeader(request, url.origin);
   const interceptSourceUrl = getInterceptSourceHeader(request);
   const isHmr = !!requestHeaders(request).get("X-RSC-HMR");