@rangojs/router 0.24.4 → 0.26.0

package/dist/types/rsc/prefetch-render-error.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+export declare function markPrefetchOnRenderError(response: Response, renderErrors: readonly unknown[]): Response;

package/dist/types/rsc/progressive-enhancement.d.ts

@@ -7,6 +7,8 @@
  */
 import { getRequestContext } from "../server/request-context.js";
 import type { MiddlewareFn } from "../router/middleware.js";
+import type { ReactFormState } from "./types.js";
+import type { MatchResult } from "../types.js";
 import type { HandlerContext } from "./handler-context.js";
 export interface PeRouteMiddlewareInfo {
     routeMiddleware?: Array<{
@@ -17,3 +19,21 @@ export interface PeRouteMiddlewareInfo {
     routeReverse?: (name: string, params?: Record<string, string>, search?: Record<string, unknown>) => string;
 }
 export declare function handleProgressiveEnhancement<TEnv>(ctx: HandlerContext<TEnv>, request: Request, env: TEnv, url: URL, isAction: boolean, handleStore: ReturnType<typeof getRequestContext>["_handleStore"], nonce: string | undefined, routeMwInfo?: PeRouteMiddlewareInfo): Promise<Response | null>;
+/** What a no-JS form post's action left for the re-render (`_actionRan`). */
+export interface FormActionOutcome {
+    reactFormState: ReactFormState | null;
+    directActionId: string | null;
+    /** The action threw, or the form body did not parse. */
+    failure?: PeFailure;
+}
+/**
+ * A failed no-JS form post and the error boundary matched for it. The boundary
+ * renders in place of the page, inside route middleware as the JS path renders
+ * its own (server-action.ts `errorBoundary`). With none, the page re-renders
+ * with 500, the JS path's status for the same boundaryless error.
+ */
+export interface PeFailure {
+    error: unknown;
+    actionId: string | null | undefined;
+    boundary: MatchResult | null;
+}

package/dist/types/rsc/rewrite-passes.d.ts

@@ -32,8 +32,18 @@ export interface RewritePass {
 /**
  * Move the request context to `rewrite`'s target for the next pass: check
  * that this request can be rewritten, resolve the target, count the hop,
- * then rebase the context. Throws the site error for a mutation or a loader
- * fetch, a resolution error, and RewriteLoopError.
+ * then rebase the context. Throws the site error for a loader fetch, a
+ * refused mutation or one whose body middleware read before its action ran,
+ * a resolution error, and RewriteLoopError.
+ *
+ * A mutation moves too (#1145). Before its action ran (a rewrite from global
+ * middleware) it moves with its body, and the target's pass runs the action
+ * after the target's global middleware, as a direct post there would. After
+ * it ran (route middleware wraps only the re-render), the target's pass
+ * re-renders from `reqCtx._actionRan`. `disallowMutations()` refuses the
+ * first, so a lock never runs a mutation; the second is already committed,
+ * and refusing it reports an error for a write that happened, so the caller
+ * retries it.
  */
 export declare function applyRewrite(rewrite: Rewrite, passRequest: Request, reqCtx: RequestContext<any>, routeMap: Record<string, string>, basename: string | undefined): RewritePass;
 /** The response to a rewrite loop. */

package/dist/types/rsc/server-action.d.ts

@@ -53,6 +53,12 @@ export interface ActionContinuation {
  * or an ActionContinuation for the revalidation phase.
  */
 export declare function executeServerAction<TEnv>(ctx: HandlerContext<TEnv>, request: Request, env: TEnv, url: URL, actionId: string, handleStore: ReturnType<typeof getRequestContext>["_handleStore"]): Promise<Response | ActionContinuation>;
+/**
+ * The continuation for a rewrite pass after the action ran (#1145): a failed
+ * action's error boundary is re-matched on the target, since the one pass 1
+ * matched (or missed) is the rewriting route's.
+ */
+export declare function continuationForRewritePass<TEnv>(ctx: HandlerContext<TEnv>, request: Request, env: TEnv, continuation: ActionContinuation): Promise<ActionContinuation>;
 /**
  * Phase 2: Revalidate after action.
  *

package/dist/types/rsc/shell-capture-constants.d.ts

@@ -41,7 +41,7 @@ export declare const PPR_REPLAY_STATUS_HEADER: string;
  * producer (rsc-rendering.ts) and the parser (testing/shell-status.ts): a
  * reason the parser does not list parses as null.
  */
-export declare const PPR_REPLAY_BYPASS_REASONS: readonly ["method", "dynamic", "nonce", "store-unavailable", "passive-read-unsupported", "no-navigation-context", "prerender-store", "intercept", "cache-disabled", "read-error", "no-entry", "invalid-version", "corrupt-entry", "no-segment-snapshot", "snapshot-miss", "explicit-cache-hit"];
+export declare const PPR_REPLAY_BYPASS_REASONS: readonly ["method", "dynamic", "nonce", "store-unavailable", "passive-read-unsupported", "no-navigation-context", "prerender-store", "intercept", "cache-disabled", "read-error", "no-entry", "invalid-version", "corrupt-entry", "no-segment-snapshot", "snapshot-miss", "explicit-cache-hit", "rewritten"];
 /** One of {@link PPR_REPLAY_BYPASS_REASONS}. */
 export type PprReplayBypassReason = (typeof PPR_REPLAY_BYPASS_REASONS)[number];
 /**
@@ -84,6 +84,15 @@ export declare function buildShellKey(routerId: string, url: URL, filter?: Searc
  * replayed to gold's navigations. Encoded, it holds no `:` or `|`.
  */
 export declare function partitionShellKey(key: string, partition: string): string;
+/**
+ * The shell key of a `rewrite(...).shell("visitor")` request: the visitor's
+ * URL, partitioned by `rw:` + the target's path and search (both searches
+ * filtered and sorted, shellSearchSeed). The visitor's URL keeps two public
+ * URLs of one target apart; the target keeps a conditional rewrite (an A/B
+ * arm, a lock) apart from the URL's own shell. The route's own partition
+ * composes after it.
+ */
+export declare function visitorShellKey(routerId: string, visitor: URL, target: URL, filter?: SearchParamsFilter): string;
 /**
  * The navigation-only entry beside a document shell key (a cold partial
  * request's capture, rsc-rendering.ts). A suffix after the (encoded)
@@ -139,9 +148,10 @@ export declare const SHELL_CAPTURE_TASK_HARD_CAP_MS = 25000;
  * (ShellCaptureDebugEvent.refusal, `caches.refusal` on a `router.prerender()`
  * result): `identity` (a request-scoped read: cookies(), headers(), the
  * theme, a `{ cache: false }` variable), `dynamic` (`ctx.dynamic()`),
- * `loader` (a `{ ssr: false }` loader rejected, or settled with
- * redirect()/notFound()), `no-record` (no doc record: the route's cache()
- * refused the write, or the handler output failed), `handles` (a pushed
+ * `loader` (a `{ ssr: false }` loader rejected, settled with
+ * redirect()/notFound(), or a promise it pushed rejected),
+ * `no-record` (no doc record: the route's cache() refused the write, or the
+ * handler output failed), `handles` (a pushed
  * handle value did not finish encoding), `size` (over the store's value
  * limit), `record-expired` (the route cache() record the capture wrote ran
  * out first), `invalidated` (a tag of the shell was invalidated after the

package/dist/types/rsc/shell-capture.d.ts

@@ -330,6 +330,13 @@ export interface ShellCaptureDescriptor {
     debugSink?: (event: ShellCaptureDebugEvent) => void;
     /** Store the snapshot for navigation replay, never the captured HTML prelude. */
     navigationOnly?: true;
+    /**
+     * Set for a shell keyed by the visitor's URL (`rewrite(...).shell("visitor")`,
+     * visitorShellKey): the capture renders the visitor's location
+     * (`RequestContext._shellCaptureForVisitor`) and stores it as
+     * ShellCacheEntry.pathname.
+     */
+    pathname?: string;
     /**
      * lastStoredCaptureSeq(key) when a document request read the store and
      * missed. The request schedules its capture only after rendering the MISS,
@@ -495,8 +502,9 @@ export type CaptureRecordOutcome = {
  * component showed one value in the prelude and another on every HIT.
  *
  * Order, all bounded by the one capture deadline (`ppr.captureTimeout`):
- * top-level handle promises, the handler pushes' nested promises, and the
- * bake-lane loader containers settle first (the record encodes the handles
+ * top-level handle promises (a bake-lane loader's pushed promises among
+ * them, #1182), the handler pushes' nested promises, and the bake-lane
+ * loader containers settle first (the record encodes the handles
  * a HIT restores, and its handle encode has its own 5s timeout that must
  * never be the one that fires); then the capture's onResponse callbacks fire
  * with a synthetic 200 (the implicit doc scope's cacheRoute, an explicit
@@ -522,6 +530,19 @@ export interface CaptureContextDerivation {
      * record encodes its handles, so that encode never races a pending value.
      */
     handlerPushesSettled: () => Promise<void>;
+    /**
+     * Every promise a bake-lane loader body pushed (#1182), in push order.
+     * The record-first step waits for them (they are in the recorded cut) and
+     * names the loader and the handle of one that rejects or misses the
+     * deadline.
+     */
+    loaderPromisePushes: readonly LoaderPromisePush[];
+}
+/** A promise a bake-lane loader pushed at capture, owned by that loader. */
+export interface LoaderPromisePush {
+    loaderId: string;
+    handleName: string;
+    state: "pending" | "fulfilled" | "rejected";
 }
 /**
  * Derive the capture request context from a base context. Producer A passes

package/dist/types/rsc/types.d.ts

@@ -16,6 +16,11 @@ import type { ResolvedThemeConfig, Theme } from "../theme/types.js";
 export interface RscPayload {
     metadata?: {
         pathname: string;
+        /**
+         * Path and search of the URL the route rendered for, when middleware
+         * rewrote the request there (full-payload.ts payloadLocation).
+         */
+        rewriteTarget?: string;
         segments: ResolvedSegment[];
         /** Router instance ID. When this changes between navigations, the client
          *  discards cached segments and does a full tree replacement (app switch). */
@@ -328,14 +333,6 @@ export interface CreateRSCHandlerOptions<TEnv = unknown, TRoutes extends Record<
      * ```
      */
     cache?: HandlerCacheConfig | ((env: TEnv) => HandlerCacheConfig);
-    /**
-     * Version override for this handler. Same meaning as
-     * `createRouter({ version })`, which it takes precedence over: this exact
-     * value is used for both of the router's versions.
-     *
-     * @default createRouter({ version }), else the router's build versions
-     */
-    version?: string;
     /**
      * Nonce provider for Content Security Policy (CSP).
      *

package/dist/types/segment-system.d.ts

@@ -1,6 +1,21 @@
 import { type ReactNode, type ComponentType } from "react";
 import type { ResolvedSegment, RootLayoutProps } from "./types.js";
 export declare function restoreParallelLoaderMarkers(segments: ResolvedSegment[]): ResolvedSegment[];
+/**
+ * An intercept's loaders arrive as loader segments of its slot
+ * (`${slot.id}D${i}.${$$id}`, router/intercept-resolution.ts). Folded back
+ * onto the slot before the tree walk, as one aggregate the slot's
+ * LoaderBoundary reads (client.tsx renderSlotContent): walked as loaders they
+ * would attach to the slot's parent, whose subtree (the page under the modal)
+ * would change shape and remount. Any other loader segment passes through; a
+ * list with nothing to fold is returned as it is, synchronously.
+ * The slot is a new object (rule 6, suspense-contract.md); its aggregate is
+ * memoized on the loaders' data (rule 1). Settled before the commit when
+ * nothing in it is deferred and the slot has no loading() or the lane settles
+ * loaders (forceAwait, action): a modal with no loading() commits whole, as
+ * when the server awaited its loaders.
+ */
+export declare function foldInterceptLoaders(segments: ResolvedSegment[], settleLoaders: boolean): ResolvedSegment[] | Promise<ResolvedSegment[]>;
 /**
  * Options for renderSegments
  */

package/dist/types/server/build-version-table.d.ts

@@ -2,21 +2,18 @@ import { type RouterVersions, type RouterVersionsTable } from "../router-version
 /**
  * The versions a router serves with, in order:
  *
- * 1. `override`, a consumer-set `version` (createRouter or createRSCHandler):
- *    that exact value for both.
- * 2. The router's entry in the build table, else the whole-build entry.
- * 3. `VERSION` for both: the dev stamp, bumped on every RSC module edit.
+ * 1. The router's entry in the build table, else the whole-build entry.
+ * 2. `VERSION` for both: the dev stamp, bumped on every RSC module edit.
  */
-export declare function resolveRouterVersions(routerId: string | undefined, override?: string): RouterVersions;
+export declare function resolveRouterVersions(routerId: string | undefined): RouterVersions;
 /**
  * The version an on-demand prerender overlay key carries: the router's data
  * version, because the overlay stores segment data, as the segment cache does
  * (a client-only deploy keeps both). The write side (`router.prerender`,
- * router.ts) and the read side (rsc/handler.ts) both call this with
- * `createRouter({ version })`, the only override the trigger can see, so they
- * cannot disagree; a `createRSCHandler({ version })` does not move it.
+ * router.ts) and the read side (rsc/handler.ts) both call this, so they
+ * cannot disagree.
  */
-export declare function resolvePrerenderVersion(routerId: string | undefined, routerVersion: string | undefined): string;
+export declare function resolvePrerenderVersion(routerId: string | undefined): string;
 /**
  * The versions of the router serving the current request, for a cache store
  * building a key. A store operation with no request context (a detached task
@@ -40,11 +37,11 @@ export declare function getCacheVersions(): RouterVersions;
 export type KeyVersion = keyof RouterVersions | null;
 /**
  * The `v/{version}/` prefix of a persistent store key, or "" for an
- * unversioned one. A store-level `version` is used for every versioned kind;
- * otherwise the version is the serving router's, read per operation because
- * the cache factory builds the store before the request context exists.
+ * unversioned one. The version is the serving router's, read per operation
+ * because the cache factory builds the store before the request context
+ * exists.
  */
-export declare function versionKeyPrefix(storeVersion: string | undefined, kind: KeyVersion): string;
+export declare function versionKeyPrefix(kind: KeyVersion): string;
 /**
  * @internal Install a table, or restore the build's with `undefined`. A
  * request handler resolves its router's versions once, when it is created, so

package/dist/types/server/context.d.ts

@@ -61,6 +61,12 @@ export type EntryPropCommon = {
     cache?: EntryCacheConfig;
     /** URL prefix from include() scope, used for MountContext on client */
     mountPath?: string;
+    /**
+     * Include scope the entry's handler and loaders resolve `ctx.reverse(".name")`
+     * in. Structural entries only (layout, cache, parallel, wrapping
+     * middleware); a route resolves from its own name. See ReverseScope.
+     */
+    reverseScope?: ReverseScope;
     /** clientUrls() group key (PathOptions.clientGroup); route entries only. */
     clientGroup?: string;
 };
@@ -91,6 +97,11 @@ export type EntryPropRender = {
      * on both DSL evaluations, whatever `ssr` did to `loading`.
      */
     loadingPrefetch?: false;
+    /**
+     * loading(fallback, { ssr: false }), on both DSL evaluations; a document
+     * then sets `loading` to false (applyDocumentModeLoading).
+     */
+    loadingSsr?: false;
     transition?: TransitionConfig;
 };
 /**
@@ -111,7 +122,8 @@ export type LoaderEntry = {
      * Resolved at DSL-evaluation time from ctx.isSSR — entries are cached
      * per-isSSR (router/manifest.ts cache key), so the flag is already
      * request-mode-correct when resolveLoaders (fresh.ts) reads it and never
-     * appears on navigation-lane entries.
+     * appears on navigation-lane entries. Set by documentModeLoader, which
+     * getDocumentModeEntry also applies to a lazy include's captured ancestors.
      */
     awaitBeforeFlush?: true;
     /**
@@ -129,6 +141,13 @@ export type LoaderEntry = {
      * (router/segment-resolution/prefetch-deferral.ts).
      */
     prefetch?: false;
+    /**
+     * The declaring layout's / parallel's / cache()'s include scope, for the
+     * loader body's `ctx.reverse(".name")` (its DSL kickoff carries it,
+     * runInsideLoaderScope). Unset on a route's loaders: they resolve from the
+     * route's name.
+     */
+    reverseScope?: ReverseScope;
 };
 /**
  * Segments state for intercept context
@@ -192,7 +211,6 @@ export type InterceptEntry = {
     slotName: `@${string}`;
     routeName: string;
     handler: ReactNode | Handler<any, any, any>;
-    middleware: MiddlewareFn<any, any>[];
     loader: LoaderEntry[];
     loading?: ReactNode | false;
     transition?: TransitionConfig;
@@ -267,10 +285,21 @@ export type EntryData = ({
     /** Cache entries create cache boundaries and render like layouts (with Outlet) */
     handler: ReactNode | Handler<any, any, any>;
 } & EntryPropCommon & EntryPropDatas & EntryPropSegments & EntryPropRender);
+/**
+ * Where an include()'s handler runs in the route tree. Hidden include-scope
+ * names (`$prefix_*`) derive from it, never from counter state, so build
+ * discovery and runtime expansion name every include the same (#1104).
+ */
+export interface IncludeScopePosition {
+    /** Sibling indexes of the enclosing includes, "_"-joined ("" at a mount root). */
+    scopePath?: string;
+    /** The scopePath tail since the nearest include that added a name segment. */
+    hiddenScopePath?: string;
+}
 /**
  * Tracked include info for build-time manifest generation
  */
-export interface TrackedInclude {
+export interface TrackedInclude extends IncludeScopePosition {
     prefix: string;
     fullPrefix: string;
     namePrefix?: string;
@@ -290,7 +319,7 @@ export type CachedHeaderScope = {
 /**
  * Context stored in AsyncLocalStorage
  */
-interface HelperContext {
+interface HelperContext extends IncludeScopePosition {
     manifest: Map<string, EntryData>;
     namespace: string;
     parent: EntryData | null;
@@ -302,7 +331,8 @@ interface HelperContext {
      *  different routers don't clobber each other (route-map-builder.ts). */
     routerId?: string;
     metrics?: MetricsStore;
-    /** True when rendering for SSR (document requests) */
+    /** True when rendering for SSR (document requests). DSL decisions on it
+     *  go through the document-mode helpers (documentModeLoader). */
     isSSR?: boolean;
     /** URL patterns map for path() routes (route name -> pattern) */
     patterns?: Map<string, string>;
@@ -399,6 +429,37 @@ export declare function getNamePrefix(): string | undefined;
  * Returns true at root or inside { name: "" } includes, false inside named includes.
  */
 export declare function getRootScoped(): boolean;
+/**
+ * The include scope a segment's dot-local `ctx.reverse(".name")` resolves in.
+ *
+ * One handler ctx serves every segment of a request and is built from the
+ * matched route's name (match-api.ts), so a parent module's layout resolved
+ * `.settings` from the matched CHILD module's prefix first: on
+ * `/acme/web/issues` the account layout's `.settings` hit the project
+ * module's route. Structural entries (layout, cache, parallel, wrapping
+ * middleware) and the loaders they declare capture the scope where the DSL
+ * defined them. Their handler gets a ctx whose `reverse` carries it
+ * (withReverseScope, router/handler-context.ts), and their loaders' DSL
+ * kickoff carries it in the loader scope (runInsideLoaderScope) for the
+ * loader ctx the executor builds. Global names and mount-param autofill do
+ * not change.
+ */
+export interface ReverseScope {
+    /** Include name prefix ("account.project"); undefined outside named includes. */
+    readonly prefix: string | undefined;
+    /** getRootScoped() where the segment was defined: bare-name fallback allowed. */
+    readonly rootScoped: boolean;
+}
+/** The ReverseScope of the DSL position being evaluated. */
+export declare function getReverseScope(): ReverseScope;
+/**
+ * A createReverseFunction result (router/handler-context.ts). The internal
+ * 4th argument resolves dot names in a segment's ReverseScope instead of the
+ * route's name.
+ */
+export type ScopableReverse = (name: string, hrefParams?: Record<string, string>, search?: Record<string, unknown>, segmentScope?: ReverseScope) => string;
+/** `reverse` with dot names resolved in `scope`, if any. */
+export declare function scopeReverse(reverse: ScopableReverse, scope: ReverseScope | undefined): ScopableReverse;
 /**
  * Stamp build-time scope identity onto a Static() definition at mount time.
  * The bake collector (prerender-collection.ts) renders defs OUTSIDE any
@@ -425,6 +486,23 @@ export type { HelperContext };
  * parent pointer, handler) stays shared, which is correct and cheap.
  */
 export declare function getIsolatedLazyParent(captured: EntryData | null | undefined): EntryData | null;
+/** loader(Def, { ssr: false }): a document awaits it before the first flush. */
+export declare function documentModeLoader(entry: LoaderEntry): LoaderEntry;
+/** loading(fallback, { ssr: false }): a document renders no fallback. */
+export declare function applyDocumentModeLoading(entry: EntryPropRender): void;
+/**
+ * `entry`, its ancestors, orphan layouts and parallels as a document (isSSR)
+ * DSL evaluation builds them, from an evaluation without isSSR.
+ *
+ * include() captures its parent chain on router.ts routes() or
+ * lazy-includes.ts runExpansion, neither of which has isSSR, and loadManifest
+ * reuses it for every request. Handed to a document as is, every ancestor
+ * outside the include kept its navigation-mode decisions (#1179). Intercepts
+ * stay as they are: a document never resolves one.
+ *
+ * Memoized per entry, so an ancestor several includes share maps to one copy.
+ */
+export declare function getDocumentModeEntry(entry: EntryData): EntryData;
 export declare function getParallelEntries(parallels: ParallelEntries | EntryData[] | undefined): ParallelEntryData[];
 export declare function getParallelSlotEntries(parallels: ParallelEntries | EntryData[] | undefined): Array<{
     slot: `@${string}`;
@@ -689,7 +767,13 @@ export declare function assertCachedHeaderWriteAllowed(surface: string, surfaceP
  * are bypassed because loaders are always fresh (never cached) and
  * their side effects (setCookie, header, etc.) are safe.
  */
-export declare function runInsideLoaderScope<T>(fn: () => T, loaderId?: string): T;
+export declare function runInsideLoaderScope<T>(fn: () => T, loaderId?: string, reverseScope?: ReverseScope): T;
+/**
+ * The ReverseScope of the DSL loader kickoff around this call: a loader the
+ * kickoff starts, and one its body starts with ctx.use(), resolve dot names
+ * in it. A handler's ctx.use(Loader) runs outside any kickoff: none.
+ */
+export declare function getLoaderReverseScope(): ReverseScope | undefined;
 /**
  * The loader whose run a handle push here belongs to, for the browser's
  * merge of a partial response (handles/pushed-by.ts): the DSL loader

package/dist/types/server/handle-store.d.ts

@@ -123,12 +123,14 @@ export interface HandleStore {
      */
     pushPlaceholder(handleName: string, segmentId: string, data: unknown, loaderId: string): void;
     /**
-     * push() a record's copy of `loaderId`'s settled push that stands
-     * (restoreHandles): the record supplies the loader's value too. From then
-     * on this request drops every settled, thenable-free push the loader makes
-     * (live, or replayed from a cache entry, anywhere inside its body), and
-     * keeps the ones holding a thenable (holdsThenable: what the record could
-     * not keep), placed among the restored copies in the loader's push order.
+     * push() a record's copy of `loaderId`'s push that stands (restoreHandles):
+     * the record supplies the loader's value too. From then on this request
+     * drops every thenable-free push the loader makes (live, or replayed from
+     * a cache entry, anywhere inside its body), and keeps the ones holding a
+     * thenable (holdsThenable: what the record could not keep), placed among
+     * the restored copies in the loader's push order. A top-level promise is
+     * judged by its settled value, as the capture judged it (#1182): dropped
+     * when it settles thenable-free or rejects, else kept once it settles.
      */
     pushRestored(handleName: string, segmentId: string, data: unknown, loaderId: string): void;
     /**
@@ -140,6 +142,15 @@ export interface HandleStore {
      * takes a push made inside a hole it awaited.
      */
     setRecordAuthority(authority: (loaderId: string) => RecordAuthority): void;
+    /**
+     * Capture only (shell-capture.ts deriveShellCaptureContext): the slot
+     * holding `value` becomes a DSL-loader push without an owner, so the
+     * record and the prelude leave it out (getDataForSegment's
+     * `excludeLoaderPushes`). The capture owns a bake-lane loader's promise
+     * when it is pushed, and calls this once the promise settled to a value
+     * that holds one (#1182).
+     */
+    unrecordPush(handleName: string, segmentId: string, value: unknown): void;
     /**
      * `loaderId`'s run in this request settled (resolved or rejected), its
      * pushes made (loader-resolution.ts createLoaderExecutor). Its placeholders

package/dist/types/server/request-context.d.ts

@@ -13,7 +13,7 @@ import { parseCookiesFromHeader } from "./cookie-parse.js";
 import type { CacheErrorCategory } from "../cache/cache-error.js";
 import type { CookieOptions } from "../router/middleware.js";
 import type { LoaderDefinition } from "../types.js";
-import type { ScopedReverseFunction } from "../reverse.js";
+import type { AutofillAwareReverseFunction } from "../types/handler-context.js";
 import type { DefaultEnv, DefaultReverseRouteMap, DefaultRouteName } from "../types/global-namespace.js";
 import type { Handle } from "../handle.js";
 import { type ContextVar } from "../context-var.js";
@@ -28,6 +28,8 @@ import type { ResolvedTracing } from "../router/tracing.js";
 import type { RenderMode, RenderPhase } from "../router/timeout.js";
 import type { LocationStateEntry } from "../browser/react/location-state-shared.js";
 import type { RoutineTrace } from "../rsc/routine-plan.js";
+import type { ActionContinuation } from "../rsc/server-action.js";
+import type { FormActionOutcome } from "../rsc/progressive-enhancement.js";
 import { type ExecutionStart } from "../cache/invalidation-order.js";
 export interface RenderForegroundCursor {
     mode: RenderMode;
@@ -243,6 +245,12 @@ export interface RequestContext<TEnv = DefaultEnv, TParams = Record<string, stri
      * locally and passes it to scheduleShellCapture directly.
      */
     _shellCaptureRun?: boolean;
+    /**
+     * @internal Set beside `_shellCaptureRun` when the shell is keyed by the
+     * visitor's URL (`rewrite(...).shell("visitor")`): the capture renders the
+     * visitor's location and `ctx.rewrittenFrom`; the theme stays the default.
+     */
+    _shellCaptureForVisitor?: boolean;
     /**
      * @internal Bake-lane loader containers collected DURING a shell capture:
      * segment-key -> the loader's (pre-wrap) result promise. Populated by
@@ -256,9 +264,10 @@ export interface RequestContext<TEnv = DefaultEnv, TParams = Record<string, stri
     _shellCaptureLoaderRecords?: Map<string, Promise<unknown>>;
     /**
      * @internal Set on a capture's derived context when a loader pushed a
-     * value the record cannot keep (a deferred push, masked nested promises,
-     * or a push outside a loader body): the loader records then carry
-     * `runs: 1`, so a HIT still runs their bodies for those pushes.
+     * value the record cannot keep (masked nested promises, a pushed promise
+     * that settled to one, a live-lane loader's push, or a push outside a
+     * loader body): the loader records then carry `runs: 1`, so a HIT still
+     * runs their bodies for those pushes.
      */
     _shellCaptureUnrecordedLoaderPush?: true;
     /**
@@ -635,12 +644,25 @@ export interface RequestContext<TEnv = DefaultEnv, TParams = Record<string, stri
      * Generate URLs from route names.
      * Uses the global route map. After route matching, scoped (`.name`) resolution
      * works within the matched include() scope.
-     */
-    reverse: ScopedReverseFunction<Record<string, string>, DefaultReverseRouteMap>;
+     *
+     * Params are optional in the type because the fill depends on the phase.
+     * After the route match (route middleware, handlers, loaders, server actions)
+     * missing params come from the matched route's params; explicit params win.
+     * In global middleware before `next()` nothing is matched and the fill is
+     * empty, so a route with a required param throws `Missing param "<name>" for
+     * route "<route>"` at runtime (a param-less route still resolves).
+     */
+    reverse: AutofillAwareReverseFunction<Record<string, string>, DefaultReverseRouteMap>;
     /** @internal Route name from route matching, used for scoped reverse resolution */
     _routeName?: string;
     /** @internal Previous route key (from the navigation source), used for revalidation */
     _prevRouteKey?: string;
+    /**
+     * @internal Leaving a rewritten page, the visitor's URL moved
+     * (router/match-api.ts): the default revalidation counts it as a search
+     * change, since the render may read `ctx.rewrittenFrom`.
+     */
+    _visitorMoved?: boolean;
     /**
      * @internal True while the post-action revalidation render is running (set by
      * revalidateAfterAction). The "use cache" runtime reads this to prefer
@@ -650,6 +672,22 @@ export interface RequestContext<TEnv = DefaultEnv, TParams = Record<string, stri
      * revalidating in the background. A plain navigation (flag unset) keeps SWR.
      */
     _inActionRevalidation?: boolean;
+    /**
+     * @internal The outcome of the action this request ran (a JS server
+     * action's continuation, a no-JS form post's form state), set before route
+     * middleware wraps the re-render. While it is unset, applyRewrite
+     * (rsc/rewrite-passes.ts) moves a mutation with its body, so the action
+     * runs on the target's pass, or refuses it (`disallowMutations()`, or a
+     * body middleware read); once set, the request moves to the target, whose
+     * pass re-renders from it instead of running the action again (#1145).
+     */
+    _actionRan?: {
+        kind: "action";
+        continuation: ActionContinuation;
+    } | {
+        kind: "form";
+        outcome: FormActionOutcome;
+    };
     /**
      * @internal Render barrier for experimental `rendered()` API.
      * Resolves when all non-loader segments have settled and handle data
@@ -823,7 +861,7 @@ export interface RouteRecordWindow {
  * This is the type exported to library consumers. Internal code should
  * use the full RequestContext interface directly.
  */
-export type PublicRequestContext<TEnv = DefaultEnv, TParams = Record<string, string>> = Omit<RequestContext<TEnv, TParams>, "cookie" | "cookies" | "_readCookie" | "_readCookies" | "setCookie" | "deleteCookie" | "_handleStore" | "_transitionWhenRefs" | "_pprReplayPostMatchReason" | "_cacheStore" | "_prerender" | "_onDemandProducer" | "_searchParamsFilter" | "_shellCaptureRun" | "_shellImplicitCache" | "_shellLoaderSeed" | "_shellCaptureLoaderRecords" | "_shellCaptureUnrecordedLoaderPush" | "_shellCaptureLoaderLanes" | "_resolvedCacheKeys" | "_shellKey" | "_shellForcedMiss" | "_prerenderWarm" | "_runAtRequestEntry" | "_routeRecordWindow" | "_shellFragmentPayload" | "_shellCaptureGuardTripped" | "_shellCaptureGuardTrippedLoaderId" | "_explicitTaggedStores" | "_requestTags" | "_recordTagOwners" | "_recordLoaderTags" | "_cacheProfiles" | "_onResponseCallbacks" | "_pendingBackgroundTasks" | "_themeConfig" | "_readTheme" | "_documentCacheRender" | "_payloadVisitorTheme" | "_payloadDeferred" | "_requestKind" | "_payloadVisitorLocation" | "_locationState" | "_routeName" | "_prevRouteKey" | "_inActionRevalidation" | "_reportedErrors" | "_renderErrors" | "_recoveredHandlerErrors" | "_renderBarrier" | "_resolveRenderBarrier" | "_renderBarrierSegmentOrder" | "_treeHasStreaming" | "_renderBarrierWaiters" | "_handlerLoaderDeps" | "_awaitBeforeFlushLoaderIds" | "_renderBarrierHandleSnapshot" | "_renderBarrierGuardClosed" | "_reportBackgroundError" | "_debugPerformance" | "_metricsStore" | "_renderForeground" | "_activeRoutine" | "_renderDiagnosticsEnabled" | "_handlerStart" | "_tracing" | "_basename" | "_routerId" | "_versions" | "_setStatus" | "_rotateStateCookie" | "_setKeepCacheDirective" | "_freshReads" | "_setFreshReadsCookie" | "_requestRoot" | "_requestStart" | "_responseSent" | "_variables" | "_classifiedRoute" | "_requestMode" | "_cacheSignal" | "_dynamic" | "res">;
+export type PublicRequestContext<TEnv = DefaultEnv, TParams = Record<string, string>> = Omit<RequestContext<TEnv, TParams>, "cookie" | "cookies" | "_readCookie" | "_readCookies" | "setCookie" | "deleteCookie" | "_handleStore" | "_transitionWhenRefs" | "_pprReplayPostMatchReason" | "_cacheStore" | "_prerender" | "_onDemandProducer" | "_searchParamsFilter" | "_shellCaptureRun" | "_shellCaptureForVisitor" | "_shellImplicitCache" | "_shellLoaderSeed" | "_shellCaptureLoaderRecords" | "_shellCaptureUnrecordedLoaderPush" | "_shellCaptureLoaderLanes" | "_resolvedCacheKeys" | "_shellKey" | "_shellForcedMiss" | "_prerenderWarm" | "_runAtRequestEntry" | "_routeRecordWindow" | "_shellFragmentPayload" | "_shellCaptureGuardTripped" | "_shellCaptureGuardTrippedLoaderId" | "_explicitTaggedStores" | "_requestTags" | "_recordTagOwners" | "_recordLoaderTags" | "_cacheProfiles" | "_onResponseCallbacks" | "_pendingBackgroundTasks" | "_themeConfig" | "_readTheme" | "_documentCacheRender" | "_payloadVisitorTheme" | "_payloadDeferred" | "_requestKind" | "_payloadVisitorLocation" | "_locationState" | "_routeName" | "_prevRouteKey" | "_visitorMoved" | "_inActionRevalidation" | "_actionRan" | "_reportedErrors" | "_renderErrors" | "_recoveredHandlerErrors" | "_renderBarrier" | "_resolveRenderBarrier" | "_renderBarrierSegmentOrder" | "_treeHasStreaming" | "_renderBarrierWaiters" | "_handlerLoaderDeps" | "_awaitBeforeFlushLoaderIds" | "_renderBarrierHandleSnapshot" | "_renderBarrierGuardClosed" | "_reportBackgroundError" | "_debugPerformance" | "_metricsStore" | "_renderForeground" | "_activeRoutine" | "_renderDiagnosticsEnabled" | "_handlerStart" | "_tracing" | "_basename" | "_routerId" | "_versions" | "_setStatus" | "_rotateStateCookie" | "_setKeepCacheDirective" | "_freshReads" | "_setFreshReadsCookie" | "_requestRoot" | "_requestStart" | "_responseSent" | "_variables" | "_classifiedRoute" | "_requestMode" | "_cacheSignal" | "_dynamic" | "res">;
 /**
  * Marker for a waitUntil-scheduled fn whose task promise must NOT enter
  * _pendingBackgroundTasks. Used by the PPR shell capture for its own task:

package/dist/types/server/request-headers.d.ts

@@ -18,6 +18,18 @@
  * fill); the rest follow the rule so a new call site cannot drift into one.
  */
 export declare function requestHeaders(request: Request): Headers;
+/**
+ * A copy of `request`'s headers for a bodyless mirror of it (the PE
+ * re-render, route middleware around it, a rewrite pass after an action),
+ * without the body-framing ones and `content-type`, so a body check gated on
+ * the content-type passes over a request that has no body.
+ */
+export declare function bodylessHeaders(request: Request): Headers;
+/**
+ * A bodyless mirror of `request` at `url`: `method`, its
+ * {@link bodylessHeaders}, the signal and workerd's `cf`.
+ */
+export declare function bodylessRequest(url: string | URL, request: Request, method: string): Request;
 /**
  * Shadow `request.headers` with an own, non-enumerable getter that calls
  * `beforeRead` and returns the request's own Headers (stable per request, so