@rangojs/router 0.27.0 → 0.28.0

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

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

@@ -93,14 +93,6 @@ export interface PrefetchDeferral {
      * a navigation to the page lists.
      */
     below?: true;
-    /**
-     * The loaders this prefetch deferred, by `$$id` (registerDeferredLoader).
-     * A deferred loader runs only if something reads it: a handler's or another
-     * loader's ctx.use() starts it through its registration
-     * (startDeferredLoader), and revalidation.ts deliverStartedLoaders delivers
-     * what was started by the end of resolution.
-     */
-    deferredLoaders?: Map<string, DeferredLoader>;
 }
 /**
  * How a request may use the route's cache() record, decided once per match
@@ -126,7 +118,14 @@ export interface RecordUse {
      */
     readonly refresh: boolean;
 }
-/** A loader this prefetch deferred: PrefetchDeferral.deferredLoaders. */
+/**
+ * A DSL loader registered and not started (InternalHandlerContext
+ * ._deferredLoaders): a prefetch deferred it, or a pass that skips loaders
+ * (`skipLoaders`) did not run it. It runs only if something reads it: a
+ * handler's or another loader's ctx.use() starts it through its registration
+ * (startDeferredLoader), and revalidation.ts deliverStartedLoaders delivers
+ * what a prefetch started by the end of resolution.
+ */
 export interface DeferredLoader {
     /**
      * The segment that registers it. Its run files its handle pushes there,
@@ -212,17 +211,20 @@ export declare function interceptFillSkips(match: {
 /** PrefetchDeferral.record, or all of it open when the match has no plan. */
 export declare function recordUse(ctx: HandlerContext<any, any> | undefined): RecordUse;
 /**
- * Register a loader this prefetch deferred, with the segment that registers
- * it and how to start it there (PrefetchDeferral.deferredLoaders). The first
+ * Register a loader resolution does not start, with the segment that
+ * registers it and how to start it there (DeferredLoader). The first
  * registration wins, as the loader's one run per request does.
  */
 export declare function registerDeferredLoader(ctx: HandlerContext<any, any>, loaderId: string, owner: string, start: () => Promise<unknown>): void;
 /**
- * A reader asks for a loader this prefetch deferred and nothing has started:
- * start it through its registration and return the run, or undefined when
- * the read takes the ordinary path. Without this the reader ran the loader
- * bare, without its cache() binding, and the segment delivered afterwards
- * read the binding: two values on one page and an extra run on a HIT.
+ * A reader asks for a registered loader (registerDeferredLoader) and nothing
+ * has started it: start it through its registration and return the run, or
+ * undefined when the read takes the ordinary path. Without this the reader
+ * ran the loader bare, as a handler-invoked loader: in a prefetch without its
+ * cache() binding, so the segment delivered afterwards read the binding (two
+ * values on one page, an extra run on a HIT); in a route record's background
+ * re-render outside its DSL scope, so the record kept its handle pushes and
+ * every HIT showed them twice.
  *
  * A started cache() binding of the loader (`_loaderCacheOverrides`) is never
  * redirected here: the read is that binding's own MISS execution, and
@@ -231,8 +233,8 @@ export declare function registerDeferredLoader(ctx: HandlerContext<any, any>, lo
 export declare function startDeferredLoader(ctx: HandlerContext<any, any>, loaderId: string): Promise<unknown> | undefined;
 /**
  * The segment a run of `loaderId` files its handle pushes under: the one
- * that registers it when this prefetch deferred it, else the segment being
- * resolved.
+ * that registers it when it is registered (registerDeferredLoader), else the
+ * segment being resolved.
  */
 export declare function loaderOwner(ctx: HandlerContext<any, any>, loaderId: string): string | undefined;
 /**

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

@@ -0,0 +1,93 @@
+/**
+ * ResolutionPass: what one walk over a matched chain reads.
+ *
+ * Every function of the segment walker (revalidation.ts, intercept-resolution.ts)
+ * resolves against the same request: the handler context, the segments the
+ * client holds, the previous and next location, the action, the staleness and
+ * the router's deps. They take this one object instead of threading the same
+ * ten values through each signature in a fixed order, where two adjacent
+ * `URL`s or `Record<string, string>`s could swap without a type error.
+ *
+ * A full match (a document, the background re-render of a route record, a
+ * build-time prerender) is a FRESH pass: see FRESH below.
+ */
+import type { HandlerContext } from "../../types.js";
+import type { ActionContext, SegmentResolutionDeps } from "../types.js";
+/**
+ * The segment ids the client holds, the set resolution works on (match-api.ts
+ * may delete a route's id from the listed set to force a render). Empty on a
+ * full refetch.
+ */
+export type ClientHeld = ReadonlySet<string>;
+/**
+ * The client of a full match: it holds nothing and asks for nothing to be
+ * kept. Compared by identity (`pass.client === FRESH`), never by size: a
+ * partial request whose client holds nothing (NOTHING_HELD, an empty
+ * `_rsc_segments`) still asks the revalidate() rules. On a FRESH pass every
+ * segment is new without a decision, trace entry or `revalidation.decision`
+ * event, and the walker takes the full match's branches (revalidation.ts,
+ * each marked FRESH).
+ */
+export declare const FRESH: ClientHeld;
+/**
+ * A pass without the router's deps: what match middleware knows about the
+ * request. createSegmentWrappers (segment-wrappers.ts) binds the deps.
+ */
+export interface ResolutionPassInput<TEnv = any> {
+    readonly context: HandlerContext<any, TEnv>;
+    readonly client: ClientHeld;
+    /** The matched route's params, stamped on every segment the walk emits. */
+    readonly params: Record<string, string>;
+    readonly prevParams: Record<string, string>;
+    /** Undefined only on a build-time FRESH pass (freshPassInput). */
+    readonly request: Request | undefined;
+    readonly prevUrl: URL;
+    readonly nextUrl: URL;
+    readonly routeKey: string;
+    readonly actionContext?: ActionContext;
+    readonly stale?: boolean;
+    /**
+     * No loader is started and no loader segment is emitted: build time
+     * (prerender-match.ts) and the background re-render of a route record
+     * (background-revalidation.ts), whose records never hold loaders.
+     * resolveOwnerLoaders registers each loader instead: in the re-render a
+     * handler's read starts it as its declaration; at build time a read
+     * throws (setupBuildUse).
+     */
+    readonly skipLoaders?: boolean;
+    /**
+     * A render error rethrows instead of rendering the error boundary, and a
+     * streamed handler's rejection is not recovered. Build time only, so a
+     * failure (or `throw new Skip()`) reaches the build instead of being baked
+     * into a frozen 200 (issue #587).
+     */
+    readonly throwOnError?: boolean;
+    /**
+     * The request is a navigation, though the pass is FRESH: the background
+     * re-render of a record a navigation read stale or wrote
+     * (background-revalidation.ts). An entry's error reports isPartial, as the
+     * navigation's own pass does.
+     */
+    readonly partialRequest?: boolean;
+}
+export interface ResolutionPass<TEnv = any> extends ResolutionPassInput<TEnv> {
+    readonly deps: SegmentResolutionDeps<TEnv>;
+}
+/**
+ * The input of a full match's pass (FRESH). At build time the prerender
+ * context's `request` is a throwing getter (handler-context.ts
+ * createPrerenderContext): the pass carries undefined instead.
+ */
+export declare function freshPassInput<TEnv>(context: HandlerContext<any, TEnv>, routeKey: string, params: Record<string, string>, options?: {
+    skipLoaders?: boolean;
+    throwOnError?: boolean;
+    partialRequest?: boolean;
+}): ResolutionPassInput<TEnv>;
+/**
+ * The input of a pass whose client holds nothing: every segment is new and
+ * renders. The background re-render of an intercept (background-revalidation.ts)
+ * resolves with it.
+ */
+export declare function heldNothingPassInput<TEnv>(context: HandlerContext<any, TEnv>, routeKey: string, params: Record<string, string>, options?: {
+    skipLoaders?: boolean;
+}): ResolutionPassInput<TEnv>;

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

@@ -1,13 +1,20 @@
 /**
- * Revalidation Path Segment Resolution
+ * The segment walker.
  *
- * Functions for resolving segments during partial (revalidation) requests.
- * Mirrors the fresh path but adds revalidation awareness: only re-resolves
- * segments whose revalidate() predicate returns true.
+ * Resolves a matched chain's segments (loaders, layouts, routes, parallels,
+ * orphan layouts, error boundaries) in handler-first order. A partial request
+ * re-resolves only what the client lacks and what a held segment's
+ * revalidate() rules ask for. A full match (a document, the background
+ * re-render of a route record, a build-time prerender) walks the same code
+ * with `pass.client === FRESH` (resolution-pass.ts): every segment is new,
+ * and the branches marked FRESH keep what the full match has always done
+ * differently.
  */
 import { type EntryData, type LoaderEntry } from "../../server/context";
 import type { HandlerContext, ResolvedSegment, ShouldRevalidateFn } from "../../types";
-import type { SegmentResolutionDeps, SegmentRevalidationResult, ActionContext } from "../types.js";
+import type { SegmentRevalidationResult } from "../types.js";
+import type { InterceptResult } from "../router-context.js";
+import { type ResolutionPass } from "./resolution-pass.js";
 /**
  * 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
@@ -37,23 +44,37 @@ export interface LoaderOwner {
      * False for an intercept: never a document.
      */
     readonly bakeLane: boolean;
+    /**
+     * The owner declares loading(false). A FRESH pass then settles every loader
+     * before the handler runs (resolveOwnerLoaders). Unset for an intercept.
+     */
+    readonly loadingDisabled?: 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).
+ * The walker'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).
+ *
+ * Loaders run lazily via ctx.use() and are memoized, so they run in
+ * parallel. A FRESH pass kicks every loader off without an await, in the
+ * tick the call starts: a reader's ctx.use(Loader) finds the binding only if
+ * it registered first (docs/design/handle-push-ownership.md).
  */
-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<{
+export declare function resolveOwnerLoaders<TEnv>(pass: ResolutionPass<TEnv>, owner: LoaderOwner, belongsToRoute: boolean): Promise<{
     segments: ResolvedSegment[];
     matchedIds: string[];
 }>;
 /**
- * Resolve only loader segments for all entries with revalidation logic.
+ * Resolve only loader segments for all entries: a cache() or prerender HIT
+ * serves the cached non-loader segments, and loaders are never cached. Under
+ * an intercept the route's entry, and on an intercept's fill an entry the
+ * client lacks, are skipped as resolveAllSegments skips them, after the ppr
+ * header latch below has read the chain's leaf.
  */
-export declare function resolveLoadersOnlyWithRevalidation<TEnv>(entries: EntryData[], context: HandlerContext<any, TEnv>, clientSegmentIds: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, routeKey: string, deps: SegmentResolutionDeps<TEnv>, actionContext?: ActionContext, stale?: boolean): Promise<{
+export declare function resolveLoadersOnly<TEnv>(pass: ResolutionPass<TEnv>, entries: EntryData[], walk?: Pick<RevalidatingWalkOptions, "interceptResult">): Promise<{
     segments: ResolvedSegment[];
     matchedIds: string[];
 }>;
@@ -65,9 +86,9 @@ export declare function buildEntryRevalidateMap(entries: EntryData[]): Map<strin
     revalidate: ShouldRevalidateFn<any, any>[];
 }>;
 /**
- * Resolve parallel segments with revalidation.
+ * Resolve an entry's parallel slots: each slot's segment and its loaders.
  */
-export declare function resolveParallelSegmentsWithRevalidation<TEnv>(entry: EntryData, params: Record<string, string>, context: 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, stale?: boolean, options?: {
+export declare function resolveParallelSegments<TEnv>(pass: ResolutionPass<TEnv>, entry: EntryData, belongsToRoute: boolean, options?: {
     /**
      * Seed for an unknown parent-chain slot (slot not in clientSegmentIds) when
      * there are no deciding revalidate fns. "type-derived" (default, main path):
@@ -85,43 +106,73 @@ export declare function resolveParallelSegmentsWithRevalidation<TEnv>(entry: Ent
      * to it: loader sub-ids are filtered out and slots are re-grouped by parent).
      */
     loaderOrder?: "after" | "before";
-    /** Matched chain entry being resolved; see ResolveSegmentOptions.boundaryEntry. */
+    /**
+     * The matched chain entry being resolved: where the sync path catches a
+     * handler error, so a streamed slot handler (or a slot owned by a
+     * routeless layout) recovers into the same boundary. Defaults to `entry`.
+     */
     boundaryEntry?: EntryData;
 }): Promise<SegmentRevalidationResult>;
 /**
- * Resolve entry handler (layout, cache, or route) with revalidation.
+ * Resolve a chain entry's handler (layout, cache, or route) into its segment.
  */
-export declare function resolveEntryHandlerWithRevalidation<TEnv>(entry: Exclude<EntryData, {
+export declare function resolveEntryHandler<TEnv>(pass: ResolutionPass<TEnv>, entry: Exclude<EntryData, {
     type: "parallel";
-}>, params: Record<string, string>, context: 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, stale?: boolean): Promise<{
+}>, belongsToRoute: boolean): Promise<{
     segment: ResolvedSegment;
     matchedId: string;
 }>;
 /**
- * Resolve segments with revalidation awareness (for partial rendering).
+ * Resolve one chain entry's segments: its loaders, its handler, its orphan
+ * layouts and its parallels, handler first.
  */
-export declare function resolveSegmentWithRevalidation<TEnv>(entry: Exclude<EntryData, {
+export declare function resolveSegment<TEnv>(pass: ResolutionPass<TEnv>, entry: Exclude<EntryData, {
     type: "parallel";
-}>, routeKey: string, params: Record<string, string>, context: HandlerContext<any, TEnv>, clientSegmentIds: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, deps: SegmentResolutionDeps<TEnv>, actionContext?: ActionContext, stale?: boolean, 
-/** The matched route's full chain; see ResolveSegmentOptions.chain (fresh.ts). */
+}>, 
+/** The matched route's full chain; see RevalidatingWalkOptions.chain. */
 chain?: readonly EntryData[]): Promise<SegmentRevalidationResult>;
 /**
- * Resolve orphan layout with revalidation.
+ * Resolve an orphan layout: its loaders, its handler, its slots and the
+ * routeless entries nested in it.
  */
-export declare function resolveOrphanLayoutWithRevalidation<TEnv>(orphan: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, clientSegmentIds: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, routeKey: string, belongsToRoute: boolean, deps: SegmentResolutionDeps<TEnv>, actionContext?: ActionContext, stale?: boolean, 
+export declare function resolveOrphanLayout<TEnv>(pass: ResolutionPass<TEnv>, orphan: EntryData, belongsToRoute: boolean, 
 /** Parent route entry — its loaders are inherited so parallel slots can access them. */
 parentRouteEntry?: EntryData, 
-/** Matched chain entry being resolved (see ResolveSegmentOptions.boundaryEntry); defaults to parentRouteEntry. */
+/**
+ * Matched chain entry being resolved (see
+ * resolveParallelSegments's boundaryEntry); defaults to
+ * parentRouteEntry.
+ */
 boundaryEntry?: EntryData | undefined): Promise<SegmentRevalidationResult>;
+/** What resolveAllSegments needs beyond its pass. */
+export interface RevalidatingWalkOptions {
+    /**
+     * The intercept the request resolves: the route's entry (its handler and
+     * loaders) is skipped and only its id is matched. None on a full match.
+     */
+    readonly interceptResult?: InterceptResult | null;
+    /** For the intercept skip's debug log. */
+    readonly localRouteName?: string;
+    /** Where an entry's error boundary reports (resolveWithErrorBoundary). */
+    readonly pathname: string;
+    /**
+     * The matched route's full entry chain. Defaults to `entries`;
+     * withCacheLookup passes it when it resolves only the entries above a
+     * cache() boundary. An orphan list can hold an entry of the chain: a bare
+     * cache() marker sits in its layout's layout[] (it wraps that layout's
+     * routes) and is the parent of the routes after it. For those routes it
+     * resolves once, as a chain entry, below the cache() header latch (issue
+     * #918: resolved twice on a MISS, once and discarded on a HIT).
+     */
+    readonly chain?: readonly EntryData[];
+}
 /**
- * Resolve all segments for a route with revalidation logic (for matchPartial).
+ * Resolve all segments for a route: a partial match (matchPartial), a full
+ * match with a FRESH pass, or the FRESH pass of an intercept record's
+ * background re-render (rerenderAndCacheRoute). A thrown action's pass is cut
+ * at its error boundary (ActionContext.boundary).
  */
-export declare function resolveAllSegmentsWithRevalidation<TEnv>(entries: EntryData[], routeKey: string, params: Record<string, string>, context: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, actionContext: ActionContext | undefined, interceptResult: {
-    intercept: any;
-    entry: EntryData;
-} | null, localRouteName: string, pathname: string, deps: SegmentResolutionDeps<TEnv>, stale?: boolean, 
-/** The matched route's full chain; see ResolveSegmentOptions.chain (fresh.ts). */
-chain?: readonly EntryData[]): Promise<{
+export declare function resolveAllSegments<TEnv>(pass: ResolutionPass<TEnv>, entries: EntryData[], walk: RevalidatingWalkOptions): Promise<{
     segments: ResolvedSegment[];
     matchedIds: string[];
 }>;

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

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