@rangojs/router 0.24.4 → 0.26.0

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

@@ -7,6 +7,7 @@
 import type { EntryData, InterceptEntry, InterceptSelectorContext } from "../server/context";
 import type { HandlerContext, ResolvedSegment } from "../types";
 import type { SegmentResolutionDeps } from "./types.js";
+import type { RevalidationContext } from "./router-context.js";
 /**
  * Check if an intercept's when conditions are satisfied.
  * All when() functions must return true for the intercept to activate.
@@ -37,57 +38,29 @@ export declare function findInterceptForRoute(targetRouteKey: string, fromEntry:
     intercept: InterceptEntry;
     entry: EntryData;
 } | null;
+/** The segment id of `intercept`'s slot on `parentEntry`. */
+export declare function interceptSlotId(parentEntry: EntryData, intercept: InterceptEntry): string;
 /**
- * Resolve an intercept entry and emit segment with the slot name.
+ * Every segment id an intercept's slot owns, in order: the slot, then one
+ * loader segment per loader in declaration order, run or not. A request that
+ * resolves the intercept lists them in `matched` (match-result.ts).
  */
-export declare function resolveInterceptEntry<TEnv>(interceptEntry: InterceptEntry, parentEntry: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, deps: SegmentResolutionDeps<TEnv>, revalidationContext?: {
-    clientSegmentIds: Set<string>;
-    prevParams: Record<string, string>;
-    request: Request;
-    prevUrl: URL;
-    nextUrl: URL;
-    routeKey: string;
-    actionContext?: {
-        actionId?: string;
-        actionUrl?: URL;
-        actionResult?: any;
-        formData?: FormData;
-    };
-    stale?: boolean;
-}, options?: {
+export declare function interceptSegmentIds(parentEntry: EntryData, intercept: InterceptEntry): string[];
+/**
+ * Resolve an intercept entry: its slot segment, then its loader segments.
+ */
+export declare function resolveInterceptEntry<TEnv>(interceptEntry: InterceptEntry, parentEntry: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, deps: SegmentResolutionDeps<TEnv>, revalidationContext?: RevalidationContext, options?: {
     /**
-     * Skip the intercept's middleware execution. Set ONLY by the post-response
-     * background re-render paths (proactive caching, stale background
+     * Set ONLY by the post-response background re-render (stale background
      * revalidation), whose sole purpose is to re-render the segment tree to
-     * populate the cache. The foreground request already ran the intercept
-     * middleware before the response was sent — it validated auth, set cookies,
-     * and wrote context vars into the request context's shared `_variables`,
-     * which the background render reuses. Re-running middleware here would fire
-     * its side effects a SECOND time, and a middleware that short-circuits with
-     * a Response would `throw` and silently abort the cache write. Never set on
-     * the foreground path.
+     * populate the cache: a handler error rejects instead of rendering the
+     * error boundary, so a failure is never cached. Never set on the
+     * foreground path.
      */
-    skipMiddleware?: boolean;
+    background?: boolean;
 }): Promise<ResolvedSegment[]>;
 /**
- * Resolve only the loaders for a cached intercept segment.
- * Used on intercept cache hit to get fresh loader data while keeping cached component/layout.
+ * The loader segments of a cached intercept slot, on a cache hit: the slot
+ * keeps its cached component and layout, its loaders are never cached.
  */
-export declare function resolveInterceptLoadersOnly<TEnv>(interceptEntry: InterceptEntry, parentEntry: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, deps: SegmentResolutionDeps<TEnv>, revalidationContext: {
-    clientSegmentIds: Set<string>;
-    prevParams: Record<string, string>;
-    request: Request;
-    prevUrl: URL;
-    nextUrl: URL;
-    routeKey: string;
-    actionContext?: {
-        actionId?: string;
-        actionUrl?: URL;
-        actionResult?: any;
-        formData?: FormData;
-    };
-    stale?: boolean;
-}): Promise<{
-    loaderDataPromise: Promise<any[]> | any[];
-    loaderIds: string[];
-} | null>;
+export declare function resolveInterceptLoadersOnly<TEnv>(interceptEntry: InterceptEntry, parentEntry: EntryData, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, deps: SegmentResolutionDeps<TEnv>, revalidationContext: RevalidationContext): Promise<ResolvedSegment[]>;

package/dist/types/router/lazy-includes.d.ts

@@ -24,3 +24,10 @@ export declare function findLazyIncludes<TEnv = any>(items: AllUseItems[]): Arra
  * Also detects nested lazy includes and registers them as new entries
  */
 export declare function evaluateLazyEntry<TEnv = any>(entry: RouteEntry<TEnv>, deps: LazyEvalDeps<TEnv>): void | Promise<void>;
+/**
+ * Resolve an async include entry's provider once and cache the patterns on
+ * `entry.lazyPatterns`. Concurrent callers (match-time expansion and
+ * render-time loadManifest) share one in-flight import; it clears when it
+ * settles, so a rejected import is retried by the next request.
+ */
+export declare function resolveEntryPatterns<TEnv = any>(entry: RouteEntry<TEnv>): Promise<UrlPatterns<TEnv>>;

package/dist/types/router/match-middleware/intercept-resolution.d.ts

@@ -29,7 +29,7 @@
  *         v
  *   +----------------------+    +----------------------------+
  *   | Fresh intercept?     |yes>| resolveInterceptEntry()    |
- *   | (!cacheHit or        |    | - middleware, loaders, UI  |
+ *   | (!cacheHit or        |    | - loaders, UI              |
  *   |  no intercept segs)  |    +----------------------------+
  *   +----------------------+              |
  *         | no                            v
@@ -59,7 +59,7 @@
  *
  * 1. Fresh intercept (no cache):
  *    - Full resolution of intercept entry
- *    - Resolves middleware, loaders, and component
+ *    - Resolves loaders and component
  *    - Yields all intercept segments
  *
  * 2. Cache hit with intercept:

package/dist/types/router/middleware.d.ts

@@ -80,22 +80,6 @@ export declare function executeMiddleware<TEnv>(middlewares: Array<{
     entry: MiddlewareEntry<TEnv>;
     params: Record<string, string>;
 }>, request: Request, env: TEnv, variables: Record<string, any>, finalHandler: () => Promise<Response>, reverse?: (name: string, params?: Record<string, string>, search?: Record<string, unknown>) => string): Promise<Response>;
-/**
- * Execute middleware for intercepts (simplified execution)
- *
- * Intercepts use a shared stubResponse from the request context. This function:
- * - Runs middleware in sequence with a simple next() chain
- * - Returns Response if any middleware short-circuits (returns OR throws a Response, or redirects, BEFORE next())
- * - Returns null if all middleware calls next() - headers set after next() remain on stubResponse
- *
- * @param middlewares - Array of middleware functions
- * @param request - Original request
- * @param env - Environment bindings
- * @param params - Route params
- * @param variables - Shared variables object
- * @param stubResponse - Response from request context for collecting headers/cookies
- */
-export declare function executeInterceptMiddleware<TEnv>(middlewares: MiddlewareFn<TEnv>[], request: Request, env: TEnv, params: Record<string, string>, variables: Record<string, any>, stubResponse: Response, reverse?: (name: string, params?: Record<string, string>, search?: Record<string, unknown>) => string): Promise<Response | null>;
 /**
  * Execute middleware chain for loaders (simpler signature)
  *

package/dist/types/router/navigation-snapshot.d.ts

@@ -1,6 +1,8 @@
 import type { RouteMatchResult } from "./pattern-matching.js";
 export interface NavigationSnapshot {
     prevUrl: URL;
+    /** The visitor's URL of the page left, when `prevUrl` is its rewrite target. */
+    prevVisitorUrl: URL | null;
     prevParams: Record<string, string>;
     prevMatch: RouteMatchResult | null;
     interceptContextUrl: URL;

package/dist/types/router/prefetch-cache-ttl.d.ts

@@ -1,15 +1,14 @@
 /**
- * Resolve the prefetch cache TTL once, at router init, into the three derived
- * values the rest of the router consumes: seconds (for the Cache-Control
- * max-age), milliseconds (for the client-side in-memory cache), and the
- * Cache-Control header string (or false when caching is disabled).
+ * Resolve the prefetch cache TTL once, at router init, into the values the
+ * rest of the router consumes: seconds, and milliseconds for the client-side
+ * in-memory prefetch cache (shipped in payload metadata). Prefetch responses
+ * carry no Cache-Control: the browser HTTP cache would keep a prefetch whose
+ * render failed after its 200 went out (#1170).
  *
  * `false` disables prefetch caching (seconds 0). A non-finite input
  * (NaN/Infinity, e.g. from an env-derived number that failed to parse) is
- * treated as the default rather than producing a malformed
- * `Cache-Control: max-age=NaN` header; CDNs/browsers ignore such a directive,
- * which would silently disable caching on EVERY prefetch response. Negative
- * finite values clamp to 0 (disabled).
+ * treated as the default rather than disabling the cache. Negative finite
+ * values clamp to 0 (disabled).
  *
  * Policy note: this is the prefetch-TTL policy specifically. Other finite-number
  * guards in the codebase deliberately differ — defer.ts treats Infinity as an
@@ -17,11 +16,9 @@
  * at config time. They are NOT the same guard, so don't unify them.
  */
 export interface ResolvedPrefetchCacheTTL {
-    /** TTL in seconds for the Cache-Control max-age directive. */
+    /** TTL in seconds. */
     seconds: number;
     /** TTL in milliseconds for the client-side in-memory prefetch cache. */
     ms: number;
-    /** Cache-Control header value, or false when caching is disabled. */
-    cacheControl: string | false;
 }
 export declare function resolvePrefetchCacheTTL(rawTTL: number | false | undefined): ResolvedPrefetchCacheTTL;

package/dist/types/router/revalidation.d.ts

@@ -3,9 +3,16 @@
  *
  * Evaluates whether segments should revalidate based on params, actions, and custom functions.
  */
-import type { ResolvedSegment, HandlerContext } from "../types";
+import type { ResolvedSegment, HandlerContext, ShouldRevalidateFn } from "../types";
 import type { ActionContext } from "./types";
 import type { RevalidationTraceEntry } from "./logging.js";
+/**
+ * The predicate `revalidate(true)` / `revalidate(false)` stands for: the
+ * constant hard decision of `revalidate(() => true)` / `() => false`.
+ * Booleans are converted where they enter (the urls() helper, clientUrls()
+ * materialization, runRevalidate), so evaluation only ever sees functions.
+ */
+export declare function toShouldRevalidateFn(fn: ShouldRevalidateFn<any, any> | boolean): ShouldRevalidateFn<any, any>;
 /**
  * Options for revalidation evaluation
  */

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.
@@ -384,11 +378,6 @@ export interface RangoInternal<TEnv = any, TRoutes extends Record<string, unknow
      * Nonce provider for CSP
      */
     readonly nonce?: NonceProvider<TEnv>;
-    /**
-     * The consumer-set version (createRouter({ version })), used for both of the
-     * router's versions. Undefined when the router uses its build versions.
-     */
-    readonly version?: string;
     /**
      * URL patterns reference for build-time manifest generation
      */

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

@@ -490,35 +490,12 @@ export interface RangoOptions<TEnv = any> {
      */
     nonce?: NonceProvider<TEnv>;
     /**
-     * Version override. When set, this exact value is used for both of the
-     * router's versions: it keys the router's cached data (segments, `"use
-     * cache"` values, loader data) and its stored HTML (PPR shells,
-     * document-cache responses), is sent in payload metadata, and is what the
-     * browser's `_rsc_v` is compared with (a mismatch reloads the tab).
-     *
-     * Leave it unset for the default: rango computes two versions per router at
-     * build time, a data version from the router's server code and a document
-     * version that also covers the client assets. The same code builds to the
-     * same versions, so a deploy that does not change this router keeps its
-     * cache. In dev both are a stamp bumped on every RSC module edit.
-     *
-     * Set it to clear this router's cache on demand (change the value), or to
-     * tie the cache to your own release id (a per-deploy value clears the cache
-     * on every deploy).
-     *
-     * @default the router's build versions
-     */
-    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/mask-nested.d.ts

@@ -59,9 +59,11 @@ export declare function settleNestedThenables(value: unknown): Promise<void>;
 /**
  * True when `value` is a thenable or holds one where the capture's loader
  * push funnel masks it (maskNestedContainerThenables): through plain data
- * objects, arrays and React element props. Such a push stays out of a shell's
- * record and reaches a HIT only from a run of its loader there, so a HIT
- * keeps it; a push without one is the record's (HandleStore.pushRestored).
+ * objects, arrays and React element props. A settled push that holds one
+ * stays out of a shell's record and reaches a HIT only from a run of its
+ * loader there, so a HIT keeps it; a push without one is the record's
+ * (HandleStore.pushRestored). A top-level thenable is judged by the value it
+ * settles to, on both sides (#1182).
  */
 export declare function holdsThenable(value: unknown): boolean;
 /**

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/router-versions.d.ts

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

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