@rangojs/router 0.24.4 → 0.25.0

package/dist/types/router/router-context.d.ts

@@ -8,7 +8,7 @@ import type { ResolveSegmentOptions } from "./segment-resolution.js";
  * Revalidation context passed to segment resolution
  */
 export interface RevalidationContext {
-    clientSegmentIds: Set<string>;
+    clientSegmentIds: ReadonlySet<string>;
     prevParams: Record<string, string>;
     request: Request;
     prevUrl: URL;
@@ -20,7 +20,7 @@ export interface RevalidationContext {
         actionResult?: any;
         formData?: FormData;
     };
-    stale: boolean;
+    stale?: boolean;
 }
 /**
  * Result from intercept lookup
@@ -61,7 +61,7 @@ export interface RouterContext<TEnv = any> {
         id: string;
     }>;
     resolveInterceptEntry: (intercept: InterceptEntry, entry: EntryData, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext?: RevalidationContext, options?: {
-        skipMiddleware?: boolean;
+        background?: boolean;
     }) => Promise<ResolvedSegment[]>;
     collectWithMarkers?: <T>(gen: AsyncGenerator<T | {
         __type: "id";
@@ -111,19 +111,7 @@ export interface RouterContext<TEnv = any> {
     }>;
     telemetry?: TelemetrySink;
     requestId?: string;
-    resolveInterceptLoadersOnly?: (intercept: InterceptEntry, entry: EntryData, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext: {
-        clientSegmentIds: Set<string>;
-        prevParams: Record<string, string>;
-        request: Request;
-        prevUrl: URL;
-        nextUrl: URL;
-        routeKey: string;
-        actionContext?: any;
-        stale?: boolean;
-    }) => Promise<{
-        loaderDataPromise: Promise<any[]> | any[];
-        loaderIds: string[];
-    } | null>;
+    resolveInterceptLoadersOnly?: (intercept: InterceptEntry, entry: EntryData, handlerContext: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext: RevalidationContext) => Promise<ResolvedSegment[]>;
 }
 /**
  * Get router dependencies from AsyncLocalStorage context

package/dist/types/router/router-interfaces.d.ts

@@ -296,12 +296,6 @@ export interface RangoInternal<TEnv = any, TRoutes extends Record<string, unknow
      * Always includes at least the "default" profile.
      */
     readonly cacheProfiles: Record<string, import("../cache/profile-registry.js").CacheProfile>;
-    /**
-     * Cache-Control header value for prefetch responses.
-     * False means no caching of prefetch responses.
-     * Derived from prefetchCacheTTL.
-     */
-    readonly prefetchCacheControl: string | false;
     /**
      * TTL in milliseconds for the client-side in-memory prefetch cache.
      * 0 means caching is disabled.

package/dist/types/router/router-options.d.ts

@@ -510,15 +510,12 @@ export interface RangoOptions<TEnv = any> {
      */
     version?: string;
     /**
-     * TTL (in seconds) for the in-memory prefetch cache and the
-     * Cache-Control header on prefetch responses.
+     * TTL (in seconds) for the client-side in-memory prefetch cache.
      *
      * Controls how long prefetch responses are kept in the client-side
-     * in-memory cache and sets `Cache-Control: private, max-age=<ttl>`
-     * on prefetch responses, so the browser's HTTP cache may reuse them
-     * (`private`: shared caches such as a CDN do not store them). A route an
-     * intercept targets gets no prefetch `Cache-Control`: whether its
-     * response is the modal or the full page depends on the source page.
+     * in-memory cache. Prefetch responses carry no `Cache-Control`, so the
+     * browser's HTTP cache does not keep them: a prefetch whose render failed
+     * after its 200 went out would otherwise answer later requests.
      *
      * The cache is automatically invalidated on server actions regardless
      * of TTL, so this is primarily a staleness safety net.

package/dist/types/router/segment-resolution/prefetch-deferral.d.ts

@@ -24,7 +24,7 @@
  * force a same-route render from an intercept source (match-api.ts), and a
  * unit deferred on that ground would be dropped from the response as held.
  */
-import { type EntryData, type LoaderEntry } from "../../server/context.js";
+import { type EntryData, type InterceptEntry, type LoaderEntry } from "../../server/context.js";
 import type { HandlerContext } from "../../types.js";
 import type { CacheScope } from "../../cache/cache-scope.js";
 /**
@@ -148,33 +148,42 @@ export interface DeferredLoader {
  * in the tree declares `prefetch: false`.
  */
 export declare function resolveDeferralScope(entries: readonly EntryData[]): 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 declare function resolveInterceptDeferralScope(intercept: InterceptEntry): DeferralScope;
 /**
  * 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 declare function partialDeferralMode(request: {
     fill: boolean;
     prefetch: boolean;
     method: string;
     isAction: boolean;
-    isIntercept: boolean;
     isShellCapture: boolean;
 }): PrefetchDeferral["mode"];
+export declare const NOTHING_HELD: ReadonlySet<string>;
 /**
  * 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 declare function planPrefetchDeferral(entries: readonly EntryData[], mode: PrefetchDeferral["mode"], matched: {
     pr?: boolean;
     od?: boolean;
-}, cacheScope: CacheScope | null | undefined, held?: ReadonlySet<string>): PrefetchDeferral | undefined;
+}, cacheScope: CacheScope | null | undefined, held?: ReadonlySet<string>, scope?: DeferralScope): PrefetchDeferral | undefined;
 export declare function getPrefetchDeferral(ctx: HandlerContext<any, any> | undefined): PrefetchDeferral | undefined;
 /** The request is a fill: a held segment is skipped without consulting anything. */
 export declare function isFillRequest(ctx: HandlerContext<any, any>): boolean;
@@ -186,6 +195,20 @@ export declare function isFillRequest(ctx: HandlerContext<any, any>): boolean;
  * deciding site resolves with.
  */
 export declare function fillSends(ctx: HandlerContext<any, any>, segmentId: string, held: ReadonlySet<string>): boolean | 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 declare function interceptFillSkips(match: {
+    handlerContext: HandlerContext<any, any>;
+    isIntercept: boolean;
+    clientSegmentSet: ReadonlySet<string>;
+}, segment: string | {
+    id: string;
+    namespace?: string;
+}): boolean;
 /** PrefetchDeferral.record, or all of it open when the match has no plan. */
 export declare function recordUse(ctx: HandlerContext<any, any> | undefined): RecordUse;
 /**

package/dist/types/router/segment-resolution/revalidation.d.ts

@@ -5,14 +5,48 @@
  * Mirrors the fresh path but adds revalidation awareness: only re-resolves
  * segments whose revalidate() predicate returns true.
  */
-import { type EntryData } from "../../server/context";
+import { type EntryData, type LoaderEntry } from "../../server/context";
 import type { HandlerContext, ResolvedSegment, ShouldRevalidateFn } from "../../types";
 import type { SegmentResolutionDeps, SegmentRevalidationResult, ActionContext } from "../types.js";
 /**
- * Resolve loaders with revalidation awareness (for partial rendering).
- * Returns both segments to render AND all matched segment IDs.
+ * A deferred loader something started in this request (a handler that awaits
+ * it with ctx.use(), or another loader) ran in the prefetch whatever its flag
+ * says: deliver that run instead of having the fill run it a second time. A
+ * reader starts it through its registration (prefetch-deferral.ts
+ * startDeferredLoader), so the delivery's resolveLoaderData finds the same
+ * run or cache() binding. Called once resolution has awaited every handler it
+ * awaits; a streamed handler that reads the loader later is not seen, and
+ * that loader runs again in the fill.
  */
-export declare function resolveLoadersWithRevalidation<TEnv>(entry: EntryData, ctx: HandlerContext<any, TEnv>, belongsToRoute: boolean, clientSegmentIds: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, routeKey: string, deps: SegmentResolutionDeps<TEnv>, actionContext?: ActionContext, shortCodeOverride?: string, stale?: boolean): Promise<{
+export declare function deliverStartedLoaders<TEnv>(ctx: HandlerContext<any, TEnv>, segments: ResolvedSegment[]): void;
+/**
+ * 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 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 declare function ownerOf(entry: EntryData, shortCodeOverride?: string): LoaderOwner;
+/**
+ * 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 declare function resolveOwnerLoaders<TEnv>(owner: LoaderOwner, ctx: HandlerContext<any, TEnv>, belongsToRoute: boolean, clientSegmentIds: ReadonlySet<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, routeKey: string, deps: SegmentResolutionDeps<TEnv>, actionContext?: ActionContext, stale?: boolean): Promise<{
     segments: ResolvedSegment[];
     matchedIds: string[];
 }>;

package/dist/types/router/segment-resolution.d.ts

@@ -1,3 +1,3 @@
 export { handleHandlerResult, warnOnStreamedResponse, buildLoaderErrorContext, } from "./segment-resolution/helpers.js";
 export { resolveLoaders, type ResolveSegmentOptions, resolveSegment, resolveOrphanLayout, resolveParallelEntry, resolveAllSegments, resolveLoadersOnly, } from "./segment-resolution/fresh.js";
-export { resolveLoadersWithRevalidation, resolveLoadersOnlyWithRevalidation, buildEntryRevalidateMap, resolveParallelSegmentsWithRevalidation, resolveEntryHandlerWithRevalidation, resolveSegmentWithRevalidation, resolveOrphanLayoutWithRevalidation, resolveAllSegmentsWithRevalidation, } from "./segment-resolution/revalidation.js";
+export { resolveLoadersOnlyWithRevalidation, buildEntryRevalidateMap, resolveParallelSegmentsWithRevalidation, resolveEntryHandlerWithRevalidation, resolveSegmentWithRevalidation, resolveOrphanLayoutWithRevalidation, resolveAllSegmentsWithRevalidation, } from "./segment-resolution/revalidation.js";

package/dist/types/router/segment-wrappers.d.ts

@@ -2,6 +2,7 @@ import type { EntryData, InterceptEntry } from "../server/context";
 import type { HandlerContext, ResolvedSegment, ShouldRevalidateFn } from "../types";
 import type { SegmentResolutionDeps } from "./types.js";
 import type { ResolveSegmentOptions } from "./segment-resolution.js";
+import type { RevalidationContext } from "./router-context.js";
 import type { InterceptSelectorContext } from "../server/context";
 export interface SegmentWrappers<TEnv = any> {
     resolveAllSegments: (entries: EntryData[], routeKey: string, params: Record<string, string>, context: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>, options?: ResolveSegmentOptions) => Promise<ResolvedSegment[]>;
@@ -36,12 +37,9 @@ export interface SegmentWrappers<TEnv = any> {
         entry: EntryData;
     } | null;
     resolveInterceptEntry: (interceptEntry: InterceptEntry, parentEntry: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, belongsToRoute?: boolean, revalidationContext?: any, options?: {
-        skipMiddleware?: boolean;
+        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>;
+    resolveInterceptLoadersOnly: (interceptEntry: InterceptEntry, parentEntry: EntryData, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext: RevalidationContext) => Promise<ResolvedSegment[]>;
 }
 /**
  * Create thin wrapper functions that bind segmentDeps to extracted

package/dist/types/router/substitute-pattern-params.d.ts

@@ -17,8 +17,9 @@
  *                         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 declare function substitutePatternParams(pattern: string, params: Record<string, string | undefined>, routeName: string): string;
 /**

package/dist/types/router/tracing.d.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/dist/types/rsc/full-payload.d.ts

@@ -28,10 +28,22 @@ export declare function buildFullPayload(m: MatchResult, ctx: HandlerContext<any
  * 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 declare function renderedLocation(reqCtx: Pick<RequestContext<any>, "_variables" | "_shellCaptureRun" | "_documentCacheRender" | "_payloadVisitorLocation" | "res"> | undefined, url: URL): URL;
+export declare function renderedLocation(reqCtx: Pick<RequestContext<any>, "_variables" | "_shellCaptureRun" | "_shellCaptureForVisitor" | "_documentCacheRender" | "_payloadVisitorLocation" | "res"> | undefined, url: URL): 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 declare function payloadLocation(reqCtx: Parameters<typeof renderedLocation>[0], url: URL): {
+    pathname: string;
+    rewriteTarget?: string;
+};
 /**
  * The theme a document payload carries as `metadata.initialTheme` (the
  * ThemeProvider's first state), read with no identity guard: it is the

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

@@ -117,6 +117,14 @@ export declare function buildRouteMiddlewareEntries<TEnv>(routeMiddleware: Array
     entry: MiddlewareEntry<TEnv>;
     params: Record<string, string>;
 }>;
+/**
+ * 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 declare function actionRenderRequest(request: Request): Request;
 /**
  * Merge stub headers from the request context onto an existing Response in
  * place, then drain onResponse callbacks. Used when a Response cannot flow

package/dist/types/rsc/manifest-init.d.ts

@@ -4,6 +4,26 @@
  * Builds a fresh route trie from every registered URL-pattern mount for
  * dev/HMR scenarios where the manifest exists but the trie needs rebuilding.
  */
+/** True when the trie installed for `router.id` was built from this router. */
+export declare function isRouterTrieBuiltFrom(router: {
+    id?: string;
+}): boolean;
+/** 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 declare function ensureRouterTrie(router: TrieSource): Promise<void>;
 /**
  * Build a fresh route trie from the router's URL-pattern mounts and store it in
  * the per-router cache. Also sets the per-router manifest and merges into the

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)

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,

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). */

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/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;
 };
@@ -129,6 +135,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 +205,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 +279,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 +313,7 @@ export type CachedHeaderScope = {
 /**
  * Context stored in AsyncLocalStorage
  */
-interface HelperContext {
+interface HelperContext extends IncludeScopePosition {
     manifest: Map<string, EntryData>;
     namespace: string;
     parent: EntryData | null;
@@ -399,6 +422,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
@@ -689,7 +743,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