@rangojs/router 0.24.4 → 0.26.0

package/src/rsc/full-payload.ts

@@ -15,6 +15,7 @@ import type { RequestContext } from "../server/request-context.js";
 import type { HandleStore } from "../server/handle-store.js";
 import type { Theme } from "../theme/types.js";
 import {
+  pathKey,
   rendersForSharedAudience,
   rewriteTrail,
   visitorUrl,
@@ -42,7 +43,7 @@ export function buildFullPayload(
 ): RscPayload {
   return {
     metadata: {
-      pathname: renderedLocation(reqCtx, url).pathname,
+      ...payloadLocation(reqCtx, url),
       routerId: ctx.router.id,
       basename: ctx.router.basename,
       segments: attachTransitionWhen(m.segments, reqCtx),
@@ -95,7 +96,8 @@ export function buildFullPayload(
  * bar) agree on `usePathname()` and `useSearchParams()`. A render other
  * visitors may be served shows `url`, the target, as a direct visit does: a
  * shell capture, and a render the document cache stores (its key is the
- * target). A render that shows the visitor's URL marks
+ * target), except a visitor-keyed shell capture, whose key covers the
+ * visitor's URL. Any other render that shows the visitor's URL marks
  * `_payloadVisitorLocation`, and the document cache does not store it.
  */
 export function renderedLocation(
@@ -104,6 +106,7 @@ export function renderedLocation(
         RequestContext<any>,
         | "_variables"
         | "_shellCaptureRun"
+        | "_shellCaptureForVisitor"
         | "_documentCacheRender"
         | "_payloadVisitorLocation"
         | "res"
@@ -111,13 +114,32 @@ export function renderedLocation(
     | undefined,
   url: URL,
 ): URL {
-  if (!reqCtx || !rewriteTrail(reqCtx) || rendersForSharedAudience(reqCtx)) {
-    return url;
+  if (!reqCtx || !rewriteTrail(reqCtx)) return url;
+  if (rendersForSharedAudience(reqCtx)) {
+    return reqCtx._shellCaptureForVisitor ? visitorUrl(reqCtx, url) : url;
   }
   reqCtx._payloadVisitorLocation = true;
   return visitorUrl(reqCtx, url);
 }
 
+/**
+ * A payload's `pathname` (renderedLocation) and, when middleware rewrote the
+ * request, `rewriteTarget`: the path and search the route rendered (the
+ * trail's last URL). The browser keeps it per history entry and sends it
+ * back as `_rsc_rt`, so the next request from the page diffs against the
+ * route that rendered it (navigation-snapshot.ts resolveNavigation, #1144).
+ */
+export function payloadLocation(
+  reqCtx: Parameters<typeof renderedLocation>[0],
+  url: URL,
+): { pathname: string; rewriteTarget?: string } {
+  const pathname = renderedLocation(reqCtx, url).pathname;
+  const trail = rewriteTrail(reqCtx);
+  return trail
+    ? { pathname, rewriteTarget: pathKey(new URL(trail[trail.length - 1]!)) }
+    : { pathname };
+}
+
 /**
  * The theme a document payload carries as `metadata.initialTheme` (the
  * ThemeProvider's first state), read with no identity guard: it is the

package/src/rsc/handler.ts

@@ -18,7 +18,8 @@ import {
   captureRequestEntryContext,
 } from "../server/request-context.js";
 import { REWRITE_HEADER, runRewritePasses } from "./rewrite-passes.js";
-import { renderedLocation } from "./full-payload.js";
+import { rewriteTrail } from "../server/rewrite-trail.js";
+import { payloadLocation } from "./full-payload.js";
 import * as rscDeps from "@vitejs/plugin-rsc/rsc/server";
 import type {
   RscPayload,
@@ -27,6 +28,7 @@ import type {
   SSRModule,
 } from "./types.js";
 import {
+  actionRenderRequest,
   createReloadResponse,
   createResponseWithMergedHeaders,
   finalizeResponse,
@@ -79,6 +81,7 @@ import type { SegmentCacheStore } from "../cache/types.js";
 import { buildRouterTrieFromUrlpatterns } from "./manifest-init.js";
 import { handleProgressiveEnhancement } from "./progressive-enhancement.js";
 import {
+  continuationForRewritePass,
   executeServerAction,
   revalidateAfterAction,
   type ActionContinuation,
@@ -162,12 +165,8 @@ export function createRSCHandler<
   TRoutes extends Record<string, string> = Record<string, string>,
 >(options: CreateRSCHandlerOptions<TEnv, TRoutes>) {
   const { router, nonce: nonceProvider } = options;
-  // A consumer-set version (this option, else createRouter({ version })) is
-  // used for both; otherwise the router's own pair from the build.
-  const versions = resolveRouterVersions(
-    router.id,
-    options.version ?? router.version,
-  );
+  // The router's own pair from the build.
+  const versions = resolveRouterVersions(router.id);
   // Everything the handler itself versions is tied to the HTML a tab holds:
   // payload metadata (what the browser echoes as `_rsc_v`), the reload check,
   // shell stamping and gating, the rango state value. The data version is only
@@ -545,7 +544,7 @@ export function createRSCHandler<
         resolvedPrerender = {
           config: prerenderConfig,
           routerId: router.id,
-          version: resolvePrerenderVersion(router.id, router.version),
+          version: resolvePrerenderVersion(router.id),
         };
       }
     }
@@ -973,6 +972,32 @@ export function createRSCHandler<
     // "middleware-short-circuit").
     getRequestContext()._requestMode = plan.mode;
 
+    // A rewritten pass of an action must reach the branch that runs it: the
+    // one that ran it re-renders from its outcome, and a JS action a global
+    // rewrite moved before it ran runs only on the action branch. Any other
+    // plan would serve the POST as a fresh request or drop the action; a
+    // reload (version mismatch, app switch) does neither.
+    const passCtx = getRequestContext();
+    const actionRan = passCtx._actionRan;
+    const actionMode = actionRan
+      ? actionRan.kind === "action"
+        ? "action"
+        : "pe-render"
+      : url.searchParams.has("_rsc_action") && rewriteTrail(passCtx)
+        ? "action"
+        : undefined;
+    if (
+      actionMode &&
+      plan.mode !== actionMode &&
+      plan.mode !== "version-mismatch" &&
+      plan.mode !== "app-switch"
+    ) {
+      throw new Error(
+        `A rewrite of a server action or form post must target a page ` +
+          `route; ${url.pathname} ${plan.mode === "response" ? "is a response route" : plan.mode === "redirect" ? "redirects" : "is not one"}.`,
+      );
+    }
+
     // ---- 2. Terminal plans (no execution needed) ----
     if (plan.mode === "redirect") {
       // Redirects are handled by the pipeline (match/matchPartial),
@@ -1224,51 +1249,64 @@ export function createRSCHandler<
 
     // ---- Action: execute action, then revalidate wrapped in route middleware ----
     if (plan.mode === "action") {
-      let actionContinuation: ActionContinuation | undefined;
-      try {
-        // Instrument the action execution as its own phase (action:<actionId> +
-        // rango.action), so a POST shows the mutation time AND which action ran,
-        // not just the downstream revalidation render. The action's own
-        // loaders/fetches nest under rango.action.
-        const actionOutcome = await withTimeout(
-          observePhase(PHASES.action(plan.actionId), () =>
-            executeServerAction(
-              handlerCtx,
+      const reqCtx = getRequestContext();
+      const ran = reqCtx._actionRan;
+      let actionContinuation: ActionContinuation;
+      if (ran?.kind === "action") {
+        // A rewrite pass after the action ran: never run it again.
+        actionContinuation = await continuationForRewritePass(
+          handlerCtx,
+          request,
+          env,
+          ran.continuation,
+        );
+      } else {
+        try {
+          // Instrument the action execution as its own phase (action:<actionId> +
+          // rango.action), so a POST shows the mutation time AND which action ran,
+          // not just the downstream revalidation render. The action's own
+          // loaders/fetches nest under rango.action.
+          const actionOutcome = await withTimeout(
+            observePhase(PHASES.action(plan.actionId), () =>
+              executeServerAction(
+                handlerCtx,
+                request,
+                env,
+                url,
+                plan.actionId,
+                handleStore,
+              ),
+            ),
+            router.timeouts.actionMs,
+            "action",
+          );
+          if (actionOutcome.timedOut) {
+            return handleTimeoutResponse(
               request,
               env,
               url,
+              "action",
+              actionOutcome.durationMs,
+              plan.route.routeKey,
               plan.actionId,
-              handleStore,
-            ),
-          ),
-          router.timeouts.actionMs,
-          "action",
-        );
-        if (actionOutcome.timedOut) {
-          return handleTimeoutResponse(
+            );
+          }
+          const result = actionOutcome.result;
+          // Response means redirect or error boundary — done.
+          if (result instanceof Response) return result;
+          actionContinuation = result;
+          reqCtx._actionRan = { kind: "action", continuation: result };
+        } catch (error) {
+          callOnError(error, "action", {
             request,
-            env,
             url,
-            "action",
-            actionOutcome.durationMs,
-            plan.route.routeKey,
-            plan.actionId,
-          );
+            env,
+            actionId: plan.actionId,
+            handledByBoundary: false,
+          });
+          console.error(`[RSC] Action error:`, error);
+          throw error;
         }
-        const result = actionOutcome.result;
-        // Response means redirect or error boundary — done.
-        if (result instanceof Response) return result;
-        actionContinuation = result;
-      } catch (error) {
-        callOnError(error, "action", {
-          request,
-          url,
-          env,
-          actionId: plan.actionId,
-          handledByBoundary: false,
-        });
-        console.error(`[RSC] Action error:`, error);
-        throw error;
       }
 
       // Revalidation render wrapped in route middleware.
@@ -1423,7 +1461,7 @@ export function createRSCHandler<
 
           const payload: RscPayload = {
             metadata: {
-              pathname: renderedLocation(getRequestContext(), url).pathname,
+              ...payloadLocation(getRequestContext(), url),
               routerId: router.id,
               basename: router.basename,
               segments: [notFoundSegment],
@@ -1527,7 +1565,7 @@ export function createRSCHandler<
       if (routeMiddleware.length > 0) {
         const mwResponse = await executeMiddleware(
           buildRouteMiddlewareEntries<TEnv>(routeMiddleware),
-          request,
+          actionContinuation ? actionRenderRequest(request) : request,
           env,
           variables,
           renderHandler,

package/src/rsc/helpers.ts

@@ -25,6 +25,8 @@ import type { MiddlewareEntry, MiddlewareFn } from "../router/middleware.js";
 import { formatCacheSignalHeader } from "../router/telemetry.js";
 import type { RscPayload } from "./types.js";
 import { rewriteTrail, visitorUrl } from "../server/rewrite-trail.js";
+import { guardRequestHeaders } from "../server/cookie-store.js";
+import { bodylessRequest } from "../server/request-headers.js";
 import type { HandlerContext } from "./handler-context.js";
 
 /**
@@ -380,6 +382,17 @@ export function buildRouteMiddlewareEntries<TEnv>(
   }));
 }
 
+/**
+ * The request route middleware sees around the render after a server action
+ * or a no-JS form post: the page's GET (URL, headers without body framing or
+ * content-type, signal, workerd `cf`; no body). Route middleware never wraps the action,
+ * only that render, so it decides as for a GET of the page: a rewrite it
+ * skips for mutations still moves the render to its target (#1145).
+ */
+export function actionRenderRequest(request: Request): Request {
+  return guardRequestHeaders(bodylessRequest(request.url, request, "GET"));
+}
+
 /**
  * Merge stub headers from the request context onto an existing Response in
  * place, then drain onResponse callbacks. Used when a Response cannot flow

package/src/rsc/manifest-init.ts

@@ -6,8 +6,12 @@
  */
 
 import {
+  ensureRouterManifest,
   getGlobalRouteMap,
+  getRouterManifest,
+  getRouterTrie,
   hasCachedManifest,
+  isRouterTrieAuthoritative,
   setCachedManifest,
   setRouterManifest,
   setRouterTrie,
@@ -15,6 +19,55 @@ import {
 } from "../route-map-builder.js";
 import { mergeFullManifests } from "../build/merge-full-manifests.js";
 import { isTransitionWhenValidationEnabled } from "../transition-when-ref.js";
+import type { TrieNode } from "../router/route-trie-builder.js";
+
+// A zero-route router builds no trie; recording that keeps it from rebuilding.
+const NO_TRIE: unique symbol = Symbol("rango.noTrie");
+
+// The trie each router object last installed. Router ids need not be unique
+// across instances (a test helper calling createRouter({ id }) per test), and
+// the per-id trie map cannot tell which instance a trie came from.
+const installedTries = new WeakMap<object, TrieNode | typeof NO_TRIE>();
+
+/** True when the trie installed for `router.id` was built from this router. */
+export function isRouterTrieBuiltFrom(router: { id?: string }): boolean {
+  if (router.id === undefined) return false;
+  const installed = installedTries.get(router);
+  return (
+    installed !== undefined &&
+    installed === (getRouterTrie(router.id) ?? NO_TRIE)
+  );
+}
+
+/** The router fields ensureRouterTrie reads. */
+export interface TrieSource {
+  id?: string;
+  urlpatterns?: unknown;
+  routeMap: Record<string, unknown>;
+}
+
+/**
+ * Install the trie `router` matches through, as a request finds it: the build
+ * manifest's trie when one is registered for its id, otherwise one built from
+ * its routes the way the dev handler builds it (rsc/handler.ts). Ids can repeat
+ * across router objects (tests), and another object's trie names other routes,
+ * so a trie this object did not build is rebuilt. Seeds the per-router manifest
+ * from `router.routeMap` when neither source set one, for reverse(). testing's
+ * dispatch matches through it, never the regex fallback alone (#1104, #1107).
+ */
+export async function ensureRouterTrie(router: TrieSource): Promise<void> {
+  const id = router.id;
+  if (!id) return;
+  if (!isRouterTrieAuthoritative(id) && !isRouterTrieBuiltFrom(router)) {
+    await ensureRouterManifest(id);
+    if (router.urlpatterns && !isRouterTrieAuthoritative(id)) {
+      await buildRouterTrieFromUrlpatterns(router);
+    }
+  }
+  if (!getRouterManifest(id)) {
+    setRouterManifest(id, router.routeMap as Record<string, string>);
+  }
+}
 
 /**
  * Build a fresh route trie from the router's URL-pattern mounts and store it in
@@ -63,9 +116,9 @@ export async function buildRouterTrieFromUrlpatterns(
   // are no routes.
   const { buildPerRouterTrie } = await import("../build/route-trie.js");
   const trie = buildPerRouterTrie(generated);
-  if (trie) {
-    setRouterTrie(router.id, trie);
-  }
+  if (trie) setRouterTrie(router.id, trie);
+  // Re-read: setRouterTrie stores a copy (nullPrototypeStaticChildren).
+  installedTries.set(router, trie ? getRouterTrie(router.id)! : NO_TRIE);
   setRouterManifest(router.id, generated.routeManifest);
 
   // Match the production discovery path: precompute leaf-include entries so the

package/src/rsc/prefetch-render-error.ts

@@ -0,0 +1,38 @@
+/**
+ * A prefetch whose render reported an error is not kept (#1170).
+ *
+ * WHY: its 200 left with the headers before a streamed part failed, so the
+ * client stored the error boundary as a healthy prefetch, served it to a
+ * click and respawned it. The status cannot change any more, and the body
+ * cannot end with an error: workerd delivers an errored body as a clean end,
+ * and in Chromium the error drops the rows a click that adopted the prefetch
+ * has not decoded yet (a Flight "network error" in place of the page).
+ *
+ * So the body ends cleanly with one more row, PREFETCH_FAILED_ROW, which the
+ * Flight decoder skips and teeWithCompletion (browser/response-adapter.ts)
+ * reads as a stream that did not end cleanly: the client evicts the prefetch
+ * and never respawns it. Prefetch responses carry no Cache-Control, so the
+ * browser HTTP cache keeps none of it either.
+ *
+ * The errors are the render's `_renderErrors`: a Flight error row, a streamed
+ * handler recovered into its boundary, a loader that threw (redirect() and
+ * notFound() are not errors). Each is recorded before Flight writes the row
+ * that carries it, so the list is complete once Flight closes the stream.
+ */
+
+import { PREFETCH_FAILED_ROW } from "../prefetch-markers.js";
+
+export function markPrefetchOnRenderError(
+  response: Response,
+  renderErrors: readonly unknown[],
+): Response {
+  if (!response.body) return response;
+  const marked = new TransformStream<Uint8Array, Uint8Array>({
+    flush(controller) {
+      if (renderErrors.length > 0) {
+        controller.enqueue(new TextEncoder().encode(PREFETCH_FAILED_ROW));
+      }
+    },
+  });
+  return new Response(response.body.pipeThrough(marked), response);
+}