@rangojs/router 0.27.0 → 0.29.0

package/dist/types/router/match-handlers.d.ts

@@ -1,9 +1,8 @@
 import type { ReactNode } from "react";
 import type { ErrorBoundaryHandler, ErrorInfo, ErrorPhase, MatchResult } from "../types";
 import { type EntryData, type InterceptEntry, type InterceptSelectorContext } from "../server/context.js";
-import type { MatchApiDeps } from "./types.js";
+import type { ActionContext, MatchApiDeps } from "./types.js";
 import type { RouterContext } from "./router-context.js";
-import { type ActionContext } from "./match-context.js";
 import type { MiddlewareFn } from "./middleware.js";
 import { type TelemetrySink } from "./telemetry.js";
 export interface MatchHandlerDeps<TEnv = any> {
@@ -33,11 +32,8 @@ export interface MatchHandlers<TEnv = any> {
             handler: MiddlewareFn;
             params: Record<string, string>;
         }>;
-        responseType?: string;
-        handler?: Function;
         params?: Record<string, string>;
-        negotiated?: boolean;
-        manifestEntry?: EntryData;
+        routeKey?: string;
     } | null>;
 }
 /**

package/dist/types/router/match-middleware/background-revalidation.d.ts

@@ -36,7 +36,7 @@
  *         |
  *         v
  *   +---------------------------+
- *   | resolveAllSegments()    |  Fresh resolution (no revalidation)
+ *   | FRESH segment pass      |  Fresh resolution (no revalidation)
  *   | + resolveIntercepts()   |  Ensures complete components
  *   +---------------------------+
  *         |
@@ -94,10 +94,12 @@
  * FRESH RESOLUTION (NO REVALIDATION)
  * ===================================
  *
- * Both full and partial requests use resolveAllSegments() (without
+ * Both full and partial requests resolve with a FRESH pass (without
  * revalidation logic) to ensure all segments have complete components.
  * Using revalidation-aware resolution would produce null components
- * for skipped segments, which would corrupt the cache entry.
+ * for skipped segments, which would corrupt the cache entry. Under an
+ * intercept the walk still skips the intercepted route's entry, as the MISS
+ * does: an intercept: record never holds the route's page.
  */
 import type { ResolvedSegment } from "../../types.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
@@ -118,25 +120,14 @@ import { type RequestContext } from "../../server/request-context.js";
  * MAX_REVALIDATION_INTERVAL, as after a refresh that throws.
  *
  * Runs on a DERIVED request context that owns the per-render state the
- * foreground reads while it is still producing the page (a stale HIT re-runs
- * its loaders; a proactive render starts once the Response exists, while its
- * body streams):
- *   - _handleStore: read late (loader pushes and aux-lane tracking in
- *     loader-resolution.ts, nested cache restores and captures in
- *     cache-scope.ts), so a swap sent live pushes into this render.
- *     setupLoaderAccess binds the store at setup, so it runs inside the
- *     derived context too.
- *   - _metricsStore: undefined, and the DSL store below has `metrics` unset
- *     (track() reads that one), so nothing lands on the foreground's perf
- *     timeline. ctx.Store.run closes over ctx.Store, so the derived store
- *     needs its own run.
- *   - response writes (headers, cookies, status, onResponse callbacks) go to
- *     a throwaway context (whose status gates the write, above) and are
- *     dropped: a layout above the cache() boundary is outside the header
- *     guard and an error boundary sets a status, so they would otherwise
- *     reach the live response.
- * runWithRequestContext also re-establishes the request ALS, which a waitUntil
- * task on workerd loses; the DSL store is a different ALS (build context).
+ * foreground reads while it is still producing the page:
+ * RENDER_PASS_FIELDS["background-revalidation"] (server/render-pass.ts) lists
+ * each field and why. The DSL store below has `metrics` unset too (track()
+ * reads that one), so nothing lands on the foreground's perf timeline;
+ * ctx.Store.run closes over ctx.Store, so the derived store needs its own run.
+ * runAsBackgroundWork also re-establishes the request ALS, which a waitUntil
+ * task on workerd loses, and marks the pass's onError reports `background`;
+ * the DSL store is a different ALS (build context).
  */
 export declare function rerenderAndCacheRoute<TEnv>(ctx: MatchContext<TEnv>, requestCtx: RequestContext<TEnv>, cacheScope: CacheScope, routerCtx: RouterContext<TEnv>): Promise<number>;
 /**

package/dist/types/router/match-middleware/cache-lookup.d.ts

@@ -1,95 +1,44 @@
 /**
  * Cache Lookup Middleware
  *
- * First middleware in the pipeline. Checks cache before segment resolution.
+ * First middleware in the pipeline. Before segment resolution runs, it serves
+ * a stored match from the first source that answers:
  *
- * FLOW DIAGRAM
- * ============
- *
- *   source (empty)
- *         |
- *         v
- *   +---------------------+
- *   | Is action request?  |──yes──> yield* source (pass through)
- *   +---------------------+
- *         | no
- *         v
- *   +---------------------+
- *   | Cache enabled?      |──no───> yield* source (pass through)
- *   +---------------------+
- *         | yes
- *         v
- *   +---------------------+
- *   | Lookup cache        |
- *   | (pathname, params)  |
- *   +---------------------+
- *         |
- *   +-----+-----+
- *   |           |
- *  miss        hit
- *   |           |
- *   v           v
- * yield*    Set state.cacheHit = true
- * source    Set state.shouldRevalidate
- *   |           |
- *   |           v
- *   |    +---------------------------+
- *   |    | For each cached segment:  |
- *   |    |  - Apply revalidation     |
- *   |    |  - Set component = null   |
- *   |    |    if client has it       |
- *   |    +---------------------------+
- *   |           |
- *   |           v
- *   |    +---------------------------+
- *   |    | Resolve fresh loaders     |  <-- Loaders are NEVER cached
- *   |    | (always fresh data)       |
- *   |    +---------------------------+
- *   |           |
- *   |           v
- *   |    yield cached segments
- *   |    yield fresh loader segments
- *   |           |
- *   +-----------+
- *         |
- *         v
- *      next middleware
+ *   1. Prerender: the writable on-demand overlay, then the bundled build
+ *      manifest. A live render (an action or a stale partial) reads them too
+ *      when the route has no live handler (not a Passthrough).
+ *   2. The dev Static store (`__PRERENDER_DEV_URL`, isStaticPrerender entries).
+ *   3. The route's cache() record (the segment cache). An action or a stale
+ *      partial renders live (rendersLive) and reads no record.
  *
+ * Every source serves through serveStoredSegments: pre-rendering is caching
+ * at build time, so a prerender entry is a cache hit through the same segment
+ * path. When no source answers, the request passes through to
+ * segment-resolution.
  *
- * CACHE BEHAVIOR
- * ==============
+ * A STORED HIT
+ * ============
  *
- * Cache HIT:
  *   - state.cacheHit = true signals downstream middleware to skip
- *   - Cached segments have their components nullified if client already has them
- *   - Loaders are always re-resolved for fresh data
- *   - state.shouldRevalidate triggers background SWR if cache was stale
- *
- * Cache MISS:
- *   - Passes through to segment-resolution middleware
- *   - No segments yielded from this middleware
- *
- * Loaders:
- *   - NEVER cached in the segment cache
- *   - Always resolved fresh on every request
- *   - Ensures data freshness even with cached UI components
- *   - Segment cache staleness does NOT propagate to loader revalidation;
+ *   - A segment the client already holds and keeps has its component nullified
+ *   - Loaders are always re-resolved fresh: never cached or pre-rendered.
+ *     Segment cache staleness does NOT propagate to loader revalidation;
  *     loaders use their own revalidation rules (actionId, user-defined)
+ *   - A cache() record sets state.shouldRevalidate, which triggers background
+ *     SWR when the record was stale
  *
+ * REVALIDATION RULES (cache() record)
+ * ===================================
  *
- * REVALIDATION RULES
- * ==================
- *
- * Each cached segment is evaluated against its revalidation rules:
+ * Each record segment the client holds is evaluated against its rules:
  *
- *   1. No rules defined -> use default (skip if client has segment)
+ *   1. No rules defined -> re-render the route's own segments when the search
+ *      or the route params changed; otherwise skip (nullify component)
  *   2. Rules return false -> skip re-render (nullify component)
  *   3. Rules return true -> re-render (keep component)
  *
- * Revalidation context includes:
- *   - Previous/next URL and params
- *   - Request object
- *   - Action context (if POST)
+ * Revalidation context includes the previous/next URL and params, the request
+ * and the action context (if POST).
  */
 import type { ResolvedSegment } from "../../types.js";
 import { type EntryData } from "../../server/context.js";
@@ -112,7 +61,7 @@ export declare function setPrerenderStoreForTests(store: PrerenderStore | null |
  * misses the store and renders live, and replay — including its heal
  * capture — must stay available for it (withCacheStore records the doc
  * record on that path; state.cacheSource is not "prerender"). The store
- * memoizes per routeKey/paramHash, so this probe and tryPrerenderLookup's
+ * memoizes per routeKey/paramHash, so this probe and readPrerenderSource's
  * subsequent get() share one underlying load.
  */
 export declare function prerenderEntryExists(routeKey: string | undefined, params: Record<string, string>, pathname: string, entries: EntryData[]): Promise<boolean>;
@@ -127,14 +76,13 @@ export type GeneratorMiddleware<T> = (source: AsyncGenerator<T>) => AsyncGenerat
 /**
  * Creates cache lookup middleware
  *
- * Checks cache for segments. If cache hit:
- * - Applies revalidation to determine which segments need re-rendering
- * - Resolves loaders fresh (loaders are NOT cached by design)
- * - Sets state.cacheHit = true
- * - Sets state.shouldRevalidate if SWR needed
- * - Yields cached segments + fresh loader segments
+ * The middleware is serveStoredSegments. It serves a stored match when one
+ * answers, in this order: the prerender overlay and build store (Prerender
+ * and on-demand routes), the dev Static store, then the route's cache()
+ * record. It yields the stored segments and the loaders resolved fresh and
+ * sets state.cacheHit (and state.shouldRevalidate for a cache() record, for
+ * background SWR).
  *
- * If cache miss:
- * - Passes through to next middleware
+ * If nothing answers, passes through to the next middleware.
  */
 export declare function withCacheLookup<TEnv>(ctx: MatchContext<TEnv>, state: MatchPipelineState): GeneratorMiddleware<ResolvedSegment>;

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

@@ -29,15 +29,16 @@
  *  yes          no
  *   |           |
  *   v           v
- * resolveAll  resolveAllWithRevalidation
- * Segments    Segments
- *   |           |
+ * FRESH pass  partial pass
  *   |           | (compares with prev state)
  *   |           | (handles null components)
  *   |           |
  *   +-----------+
  *         |
  *         v
+ *   resolveAllSegments()
+ *         |
+ *         v
  *   +---------------------------+
  *   | Update state:             |
  *   |  - state.segments         |
@@ -54,13 +55,14 @@
  * RESOLUTION MODES
  * ================
  *
+ * Both use resolveAllSegments().
+ *
  * Full Match (document request):
- *   - Uses resolveAllSegments()
- *   - No revalidation logic (nothing to compare against)
+ *   - A FRESH pass (freshPassInput): no revalidation logic (nothing to
+ *     compare against)
  *   - Simple resolution of all route entries
  *
  * Partial Match (navigation):
- *   - Uses resolveAllSegmentsWithRevalidation()
  *   - Compares current vs previous params/URL
  *   - Sets component = null for segments client already has
  *   - Respects custom revalidation rules

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

@@ -11,6 +11,13 @@ export interface NavigationSnapshot {
     clientSegmentSet: Set<string>;
     filteredSegmentIds: string[];
     stale: boolean;
+    /**
+     * The id of an action's error boundary on screen that a stale request holds
+     * (`_rsc_boundary`, the action follow-up): read only beside `stale`, so it
+     * has every stale guarantee (a live render, no route-cache or document-cache
+     * read or store, no PPR replay).
+     */
+    heldBoundary?: string;
     isSameRouteNavigation: boolean;
     effectiveFromUrl: URL;
     effectiveFromMatch: RouteMatchResult | null;

package/dist/types/router/prerender-match.d.ts

@@ -1,12 +1,23 @@
 import type { RouterContext } from "./router-context.js";
-import type { ResolveSegmentOptions } from "./segment-resolution.js";
-import type { EntryData } from "../server/context";
 import type { PartialPrerenderProps } from "../urls/pattern-types.js";
-import type { HandlerContext, ResolvedSegment } from "../types";
 import type { SerializedSegmentData } from "../cache/types.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
 import type { RouterVersions } from "../router-versions.js";
 import type { OnDemandRouteConfig } from "../prerender/on-demand.js";
+/**
+ * An intercept a navigation can select over the route that the build does
+ * not bake: its HIT misses (selectInterceptVariant) and it renders live,
+ * with the request instead of BuildContext.
+ * - `same-slot`: another intercept on its layout fills the same slot.
+ * - `handler-response` / `layout-response`: its handler or layout returned a
+ *   Response for this URL.
+ * - `local-name`: it targets the route's localRouteName, which the build
+ *   never bakes.
+ */
+export interface LiveIntercept {
+    slot: string;
+    reason: "same-slot" | "handler-response" | "layout-response" | "local-name";
+}
 export interface PrerenderMatchDeps<TEnv = any> {
     /** Owning router id; scopes bake-time root-scope/search-schema lookups the
      *  same way reqCtx._routerId does at runtime (issue #762). */
@@ -21,7 +32,7 @@ export interface PrerenderMatchDeps<TEnv = any> {
     findMatch: (pathname: string) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
     buildRouterContext: () => RouterContext<TEnv>;
     mergedRouteMap: Record<string, string>;
-    resolveAllSegments: (entries: EntryData[], routeKey: string, params: Record<string, string>, context: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>, options?: ResolveSegmentOptions) => Promise<ResolvedSegment[]>;
+    resolveAllSegments: RouterContext<TEnv>["resolveAllSegments"];
 }
 /**
  * Build-time pre-render match. Resolves segments with a BuildContext
@@ -46,9 +57,13 @@ onDemand?: boolean): Promise<{
     routeName: string;
     params: Record<string, string>;
     interceptSegments?: SerializedSegmentData[];
-    /** RSC-encoded MERGED (main + intercept) handle map for the intercept artifact;
-     *  the sinks store it as-is (no longer merge raw records). */
+    /** RSC-encoded handle map for the intercept artifact: the intercept's
+     *  pushes and those of the main segments the intercepted route does not
+     *  own; the sinks store it as-is. */
     interceptHandles?: string;
+    /** The intercepts the intercept variant does not hold, for the build's
+     *  warning (warnLiveIntercepts). */
+    liveIntercepts?: LiveIntercept[];
     passthrough?: true;
     /** On-demand only: the render hit `notFound()` and nothing else failed. */
     notFound?: true;

package/dist/types/router/preview-match.d.ts

@@ -1,22 +1,17 @@
-import type { EntryData } from "../server/context";
 import type { RouteMatchResult } from "./pattern-matching.js";
 import type { MiddlewareFn } from "./middleware.js";
 export interface PreviewMatchDeps<TEnv = any> {
     findMatch: (pathname: string) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
 }
 /**
- * Preview match - returns route middleware without segment resolution.
- * Also returns responseType and handler for response routes (non-RSC short-circuit).
+ * Preview match - returns the route, its params and route middleware without
+ * segment resolution (a content-negotiated variant's, when one wins).
  */
 export declare function previewMatch<TEnv = any>(request: Request, _context: TEnv, deps: PreviewMatchDeps<TEnv>): Promise<{
     routeMiddleware?: Array<{
         handler: MiddlewareFn;
         params: Record<string, string>;
     }>;
-    responseType?: string;
-    handler?: Function;
     params?: Record<string, string>;
-    negotiated?: boolean;
-    manifestEntry?: EntryData;
     routeKey?: string;
 } | null>;

package/dist/types/router/request-classification.d.ts

@@ -61,6 +61,11 @@ interface FullRenderPlan<TEnv = any> {
     mode: "full-render";
     route: RouteSnapshot<TEnv>;
     negotiated: boolean;
+    /**
+     * No route matched: the render path renders the 404 (match() re-throws
+     * RouteNotFoundError). Set by rsc/request-stages.ts classify.
+     */
+    unmatched?: true;
 }
 interface PartialRenderPlan<TEnv = any> {
     mode: "partial-render";

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

@@ -3,26 +3,9 @@ import type { EntryData, InterceptEntry, InterceptSelectorContext, MetricsStore
 import type { HandlerContext, ResolvedSegment, ShouldRevalidateFn } from "../types.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
 import type { TelemetrySink } from "./telemetry.js";
-import type { ResolveSegmentOptions } from "./segment-resolution.js";
 import type { EvaluateRevalidationOptions } from "./revalidation.js";
-/**
- * Revalidation context passed to segment resolution
- */
-export interface RevalidationContext {
-    clientSegmentIds: ReadonlySet<string>;
-    prevParams: Record<string, string>;
-    request: Request;
-    prevUrl: URL;
-    nextUrl: URL;
-    routeKey: string;
-    actionContext?: {
-        actionId?: string;
-        actionUrl?: URL;
-        actionResult?: any;
-        formData?: FormData;
-    };
-    stale?: boolean;
-}
+import type { ResolutionPassInput } from "./segment-resolution/resolution-pass.js";
+import type { RevalidatingWalkOptions } from "./segment-resolution/revalidation.js";
 /**
  * Result from intercept lookup
  */
@@ -51,43 +34,21 @@ export interface RouterContext<TEnv = any> {
     getMetricsStore: () => MetricsStore | undefined;
     createCacheScope: (cacheConfig: any, parent: CacheScope | null) => CacheScope | null;
     findInterceptForRoute: (routeKey: string, parentEntry: EntryData | null, selectorContext: InterceptSelectorContext, isAction: boolean) => InterceptResult | null;
-    resolveAllSegmentsWithRevalidation: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, actionContext: any | undefined, interceptResult: InterceptResult | null, localRouteName: string, pathname: string, stale?: boolean, 
-    /** The matched route's full chain when `entries` is part of it (ResolveSegmentOptions.chain). */
-    chain?: readonly EntryData[]) => Promise<{
+    /** The segment walker; a full match passes freshPassInput (FRESH). */
+    resolveAllSegments: (pass: ResolutionPassInput<TEnv>, entries: EntryData[], walk: RevalidatingWalkOptions) => Promise<{
         segments: ResolvedSegment[];
         matchedIds: string[];
     }>;
-    resolveAllSegmentsWithRevalidationGenerator?: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, loaderPromises: Map<string, Promise<any>>, actionContext?: any) => AsyncGenerator<ResolvedSegment | {
-        __type: "id";
-        id: string;
-    }>;
-    resolveInterceptEntry: (intercept: InterceptEntry, entry: EntryData, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext?: RevalidationContext, options?: {
+    resolveInterceptEntry: (pass: ResolutionPassInput<TEnv>, intercept: InterceptEntry, entry: EntryData, belongsToRoute: boolean, options?: {
         background?: boolean;
     }) => Promise<ResolvedSegment[]>;
-    collectWithMarkers?: <T>(gen: AsyncGenerator<T | {
-        __type: "id";
-        id: string;
-    }>) => Promise<{
-        items: T[];
-        matchedIds: string[];
-    }>;
     evaluateRevalidation: (params: EvaluateRevalidationOptions<TEnv>) => Promise<boolean>;
     getRequestContext: () => {
         waitUntil: (fn: () => Promise<void>) => void;
         _handleStore?: any;
     } | undefined;
-    resolveAllSegments: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>, options?: ResolveSegmentOptions) => Promise<ResolvedSegment[]>;
-    resolveAllSegmentsGenerator?: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>) => AsyncGenerator<ResolvedSegment | {
-        __type: "id";
-        id: string;
-    }>;
-    collectSegmentsFromGenerator?: <T>(gen: AsyncGenerator<T | {
-        __type: "id";
-        id: string;
-    }>) => Promise<T[]>;
     createHandleStore: () => any;
-    resolveLoadersOnly?: (entries: EntryData[], handlerContext: HandlerContext<any, TEnv>) => Promise<ResolvedSegment[]>;
-    resolveLoadersOnlyWithRevalidation?: (entries: EntryData[], handlerContext: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, routeKey: string, actionContext?: any, stale?: boolean) => Promise<{
+    resolveLoadersOnly?: (pass: ResolutionPassInput<TEnv>, entries: EntryData[], walk?: Pick<RevalidatingWalkOptions, "interceptResult">) => Promise<{
         segments: ResolvedSegment[];
         matchedIds: string[];
     }>;
@@ -96,7 +57,7 @@ export interface RouterContext<TEnv = any> {
     }>;
     telemetry?: TelemetrySink;
     requestId?: string;
-    resolveInterceptLoadersOnly?: (intercept: InterceptEntry, entry: EntryData, handlerContext: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext: RevalidationContext) => Promise<ResolvedSegment[]>;
+    resolveInterceptLoadersOnly?: (pass: ResolutionPassInput<TEnv>, intercept: InterceptEntry, entry: EntryData, belongsToRoute: boolean) => Promise<ResolvedSegment[]>;
 }
 /**
  * Get router dependencies from AsyncLocalStorage context

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

@@ -4,7 +4,6 @@ import type { ReverseFunction } from "../reverse.js";
 import type { UrlPatterns } from "../urls.js";
 import type { ClientUrlPatterns } from "../client-urls/types.js";
 import type { UrlBuilder, EnvCompatible } from "../urls/pattern-types.js";
-import type { EntryData } from "../server/context";
 import type { ErrorInfo, MatchResult } from "../types";
 import type { NonceProvider } from "../rsc/types.js";
 import type { ShellCaptureDebug } from "../rsc/shell-capture.js";
@@ -12,6 +11,7 @@ import type { ExecutionContext } from "../server/request-context.js";
 import type { SerializedSegmentData } from "../cache/types.js";
 import type { MiddlewareEntry, MiddlewareFn } from "./middleware.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
+import type { LiveIntercept } from "./prerender-match.js";
 import type { ExtractParams } from "../types/route-config.js";
 import { RSC_ROUTER_BRAND } from "./router-registry.js";
 import type { RangoOptions, RootLayoutProps } from "./router-options.js";
@@ -19,6 +19,7 @@ import type { DefaultVars } from "../types/global-namespace.js";
 import type { ResolvedTimeouts, OnTimeoutCallback } from "./timeout.js";
 import type { ResolvedTracing } from "./tracing.js";
 import type { TelemetrySink } from "./telemetry.js";
+import type { ActionContext } from "./types.js";
 /**
  * Options passed to router.fetch(), router.match(), and other request entrypoints.
  * All entrypoints use this same shape for consistency.
@@ -425,8 +426,10 @@ export interface RangoInternal<TEnv = any, TRoutes extends Record<string, unknow
         routeName: string;
         params: Record<string, string>;
         interceptSegments?: SerializedSegmentData[];
-        /** RSC-encoded MERGED (main + intercept) handle map for the intercept artifact. */
+        /** RSC-encoded handle map for the intercept artifact (see matchForPrerender). */
         interceptHandles?: string;
+        /** The intercepts the intercept artifact does not hold (see matchForPrerender). */
+        liveIntercepts?: LiveIntercept[];
         passthrough?: true;
     } | null>;
     /**
@@ -438,27 +441,18 @@ export interface RangoInternal<TEnv = any, TRoutes extends Record<string, unknow
         handles: string;
     } | null>;
     /**
-     * Preview match - returns route middleware without segment resolution.
-     * Also returns responseType and handler for response routes (non-RSC short-circuit).
+     * Preview match - returns the route, its params and route middleware
+     * without segment resolution.
      */
     previewMatch(request: Request, input?: RouterRequestInput<TEnv>): Promise<{
         routeMiddleware?: Array<{
             handler: import("./middleware.js").MiddlewareFn;
             params: Record<string, string>;
         }>;
-        responseType?: string;
-        handler?: Function;
         params?: Record<string, string>;
-        negotiated?: boolean;
-        manifestEntry?: EntryData;
         routeKey?: string;
     } | null>;
-    matchPartial(request: Request, input?: RouterRequestInput<TEnv>, actionContext?: {
-        actionId?: string;
-        actionUrl?: URL;
-        actionResult?: any;
-        formData?: FormData;
-    }): Promise<MatchResult | null>;
+    matchPartial(request: Request, input?: RouterRequestInput<TEnv>, actionContext?: ActionContext): Promise<MatchResult | null>;
     /**
      * Match an error to the nearest error boundary and return error segments
      *

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

@@ -9,7 +9,7 @@
  */
 import type { ReactNode } from "react";
 import type { EntryData } from "../../server/context";
-import type { ResolvedSegment, HandlerContext } from "../../types";
+import type { ResolvedSegment, ErrorInfo, HandlerContext } from "../../types";
 import type { SegmentResolutionDeps } from "../types.js";
 import type { TelemetrySink } from "../telemetry.js";
 /** The errorContext shape wrapLoaderPromise expects as its 5th argument. */
@@ -70,16 +70,32 @@ export interface ErrorReportContext {
     routeKey?: string;
     env?: any;
     isPartial?: boolean;
-    requestStartTime?: number;
     telemetry?: TelemetrySink;
 }
+type Thrower = {
+    id: string;
+    type: ErrorInfo["segmentType"];
+};
+/**
+ * Note that `id` threw `error`, for an error its owning entry's boundary
+ * catches (a parallel slot's sync throw, an orphan layout's): onError names
+ * the segment that threw, as a streamed slot's rejection does. Kept on the
+ * request context, never the module: a reused error object (a constant, a
+ * memoized rejection) can be thrown by another request, or by a Prerender
+ * pass that rethrows before catchSegmentError reads it. Returns `error`, to
+ * rethrow.
+ */
+export declare function noteThrower(error: unknown, id: string, type: ErrorInfo["segmentType"]): unknown;
 /**
  * Handle a caught error during segment resolution by creating an
  * error or not-found segment with the nearest boundary.
  *
  * Called by resolveWithErrorBoundary to produce error/notFound segments.
+ * `entry` is where the boundary is looked up; `thrower` names the segment
+ * that threw when it is not `entry` (an intercept's slot, under its declaring
+ * entry), for the report, the server print and the client's ErrorInfo.
  */
-export declare function catchSegmentError<TEnv>(error: unknown, entry: EntryData, params: Record<string, string>, deps: SegmentResolutionDeps<TEnv>, report?: ErrorReportContext, pathname?: string): ResolvedSegment;
+export declare function catchSegmentError<TEnv>(error: unknown, entry: EntryData, params: Record<string, string>, deps: SegmentResolutionDeps<TEnv>, report?: ErrorReportContext, pathname?: string, thrower?: Thrower): ResolvedSegment;
 /**
  * Generic error boundary wrapper for segment resolution.
  * Catches non-Response errors and produces an error/notFound segment

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

@@ -94,8 +94,8 @@ export declare function loaderPins(entries: readonly EntryData[], reqCtx: Reques
  * PPR loader lane rule — the canonical source statement; other sites point
  * here (consumer docs: skills/ppr/SKILL.md "The loader lane rule";
  * docs/design/loader-container-bake.md). This is the single funnel every
- * loader segment path routes through (fresh resolveLoaders, cache-hit
- * resolveLoadersOnly, revalidation resolveLoadersOnlyWithRevalidation, and
+ * loader segment path routes through (resolveOwnerLoaders: the full match's
+ * FRESH pass, cache-hit and revalidation resolveLoadersOnly, and
  * intercept loaders in intercept-resolution.ts, which pass no bake key and
  * never run under a shell capture), so the lane is decided here, per LOADER,
  * never by the entry's loading():
@@ -109,7 +109,7 @@ export declare function loaderPins(entries: readonly EntryData[], reqCtx: Reques
  *   plain objects, arrays and JSX props are masked (mask-nested.ts) and stay
  *   live holes at the consumer's own Suspense — per-request material must be
  *   promise-shaped (the #692 cross-session scar). The masked container
- *   registers on `_shellCaptureLoaderRecords`: it holds the capture gate
+ *   registers on `_shellCaptureState.loaderRecords`: it holds the capture gate
  *   (bounded by `ppr.captureTimeout`) and pins into the snapshot's loader
  *   family, and on a HIT the recorded container is overlaid onto the fresh
  *   run (below) so the payload matches the frozen prelude outside the holes.

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

@@ -7,16 +7,16 @@
  * consuming Suspense subtree postpones as a hole, and the serve pass runs them
  * fresh into it.
  *
- * Capture mode is signalled by `requestCtx._shellCaptureRun`, set to true ONLY on
+ * Capture mode is signalled by `requestCtx._shellCaptureState.run`, set ONLY on
  * the derived request context of the background capture task (shell-capture.ts);
- * the foreground render never sets it. This module is the single home for the
+ * the foreground render never has it. This module is the single home for the
  * mask so every loader execution site gates the same way (loader-cache.ts
- * `resolveLoaderData`, fresh.ts `resolveLoaders`).
+ * `resolveLoaderData`, revalidation.ts `resolveOwnerLoaders`).
  */
 import { type RequestContext } from "../../server/request-context.js";
 /**
  * True when the current render is the active PPR shell capture and route loaders
- * must be masked rather than executed. Reads `_shellCaptureRun` off the ALS
+ * must be masked rather than executed. Reads `_shellCaptureState` off the ALS
  * request context (the capture task re-establishes its derived context via
  * runWithRequestContext), so it is accurate at the loader resolution sites, which
  * run synchronously inside the pipeline's context frame.