@rangojs/router 0.27.0 → 0.29.0

package/dist/bin/rango.js

@@ -1644,7 +1644,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@rangojs/router",
-      version: "0.27.0",
+      version: "0.29.0",
       description: "Django-inspired RSC router with composable URL patterns",
       keywords: [
         "react",

package/dist/types/__internal.d.ts

@@ -53,7 +53,13 @@ export type { CachedEntryData, CacheGetResult, SerializedSegmentData, CacheDefau
  * @internal
  * Router context for AsyncLocalStorage.
  */
-export type { RouterContext, RevalidationContext, InterceptResult, } from "./router/router-context.js";
+export type { RouterContext, InterceptResult, } from "./router/router-context.js";
+/**
+ * @internal
+ * The request side of a revalidating resolution pass (RouterContext's
+ * revalidating resolvers take it).
+ */
+export type { ResolutionPassInput } from "./router/segment-resolution/resolution-pass.js";
 /**
  * @internal
  * Route match context during pipeline processing.

package/dist/types/browser/action-fence.d.ts

@@ -20,7 +20,8 @@
  *
  * The drop runs the batch's follow-up: when an action of the batch did not
  * land on the page on screen, the action bridge refetches that page once,
- * whole, after the navigation the user started, unless an intercept is on
+ * whole (or whole above an action's error boundary on screen, which it
+ * holds), after the navigation the user started, unless an intercept is on
  * screen (server-action-bridge.ts followUp; the rules are R1-R7 in
  * docs/internal/execution-model.md).
  *

package/dist/types/browser/event-controller.d.ts

@@ -59,6 +59,11 @@ export interface ActionEntry {
     startedAt: number;
     /** Whether action processing is complete (may still be streaming) */
     completed?: boolean;
+    /**
+     * Set when a later call started (see startAction): "id" hides this call
+     * from every reader, "name" from readers that match by export name.
+     */
+    supersededBy?: "id" | "name";
 }
 /**
  * Derived navigation state (computed from source of truth)
@@ -70,7 +75,7 @@ export interface DerivedNavigationState {
     isStreaming: boolean;
     /** Whether a navigation is active (fetching or streaming, before commit) */
     isNavigating: boolean;
-    /** Current committed location */
+    /** The location of the last page flushed to React (useNavigation keeps the page on screen) */
     location: NavigationLocation;
     /** URL being navigated to (null if idle) */
     pendingUrl: string | null;
@@ -207,7 +212,8 @@ export interface EventController {
     startAction(actionId: string, args: unknown[], 
     /** Originating history entry key; scopes location-state arbitration. */
     cohort?: string): ActionHandle;
-    abortAllActions(): void;
+    /** Abort every action in flight except `except` (an ActionHandle id). */
+    abortAllActions(except?: string): void;
     getState(): DerivedNavigationState;
     getActionState(actionId: string): TrackedActionState;
     getLocation(): NavigationLocation;

package/dist/types/browser/history-state.d.ts

@@ -21,15 +21,9 @@ export declare function hasLocationState(state: unknown): boolean;
  */
 export declare function pushHistoryWithIdx(state: Record<string, unknown> | null, url: string, replace: boolean): void;
 /**
- * The forced-MISS reload marker (`SHELL_MISS_PARAM` in rsc/shell-serve.ts,
- * which the browser bundle must not import): a degraded PPR shell HIT
- * reloads the page with it, and the server renders a marked request like a
- * cache miss.
- */
-export declare const SHELL_MISS_MARKER: string;
-/**
- * Drop the forced-MISS marker from the address bar at boot, keeping the
- * history entry's state (initBrowserApp calls it before any location read).
+ * Drop the forced-MISS marker (`WIRE.shellMiss`, rsc/shell-serve.ts) from the
+ * address bar at boot, keeping the history entry's state (initBrowserApp
+ * calls it before any location read).
  * Left in place, a refresh or a shared link would stay off the shell and the
  * app's search params would carry it. The server strips the same marker from
  * the request before rendering (shell-serve.ts withoutShellMissMarker), so

package/dist/types/browser/navigation-store.d.ts

@@ -24,16 +24,18 @@ export declare function liveHandleDataForCache(eventController: Pick<EventContro
  * Options for generating a history key
  */
 export interface HistoryKeyOptions {
-    /** If true, append :intercept suffix to differentiate intercept entries */
+    /** Key an intercept entry (apart from the plain entry for the URL). */
     intercept?: boolean;
+    /** The page the intercept was opened over (history.state.sourceUrl). */
+    interceptSource?: string;
 }
 /**
- * Generate a cache key from a URL.
- * Uses pathname + search (query params) directly as the key.
- * Hash fragments (#) are excluded since they don't affect server data.
+ * Generate a cache key from a URL: pathname + search. Hash fragments (#) are
+ * excluded since they don't affect server data.
  *
- * For intercept routes, append `:intercept` suffix to cache them separately
- * from non-intercept versions of the same URL.
+ * An intercept entry is keyed `<url>:intercept:<source>`: its cached tree
+ * includes the page under the intercept. hasInterceptCache relies on the
+ * `:intercept:` separator.
  */
 export declare function generateHistoryKey(url?: string, options?: HistoryKeyOptions): string;
 /**

package/dist/types/browser/partial-update.d.ts

@@ -112,18 +112,29 @@ export type UpdateMode = {
      * transition({ when }) sees kind "revalidate", not "replace".
      */
     refresh?: boolean;
+    /** The cross-tab refresh's held boundary (see `action`). */
+    boundary?: string;
 } | {
     type: "leave-intercept";
     interceptSourceUrl?: string;
+    boundary?: never;
 } | {
     type: "stale-revalidation";
     interceptSourceUrl?: string;
+    /** Back/Forward's held boundary (see `action`). */
+    boundary?: string;
 } | {
     type: "action";
     interceptSourceUrl?: string;
     actionId?: string;
     /** The action's FormData and result, for transition({ when }) `action`. */
     action?: TransitionWhenActionInput;
+    /**
+     * An action's error boundary the page shows (actionBoundaryAt): the
+     * server renders above it, its cached segment stays, and the page
+     * holds only the ids above it.
+     */
+    boundary?: string;
 };
 /**
  * Type for the fetchPartialUpdate function. In `action` mode it resolves with

package/dist/types/browser/react/filter-segment-order.d.ts

@@ -26,8 +26,8 @@ export declare function loaderParentId(id: string): string;
  * 2. Place each parallel slot id (contains ".@") immediately after its
  *    parent layout/route id. Raw segment-resolution emission order does NOT
  *    guarantee this: route-mounted parallels are resolved/pushed BEFORE the
- *    route handler's segment is appended (see fresh.ts:resolveSegment for
- *    routes, and revalidation.ts ~915-919), so matched can read
+ *    route handler's segment is appended (see resolveSegment in
+ *    segment-resolution/revalidation.ts), so matched can read
  *    `[..., R0.@panel, R0]`. collectHandleData consumes segmentOrder verbatim
  *    with later-wins semantics, so without normalization the route handler's
  *    Meta would override the slot's more-specific Meta — backwards.

package/dist/types/browser/react/use-action.d.ts

@@ -18,14 +18,19 @@ export type ServerActionFunction = ((...args: any[]) => Promise<any>) & {
  * Features:
  * - Tracks action lifecycle: idle → loading → streaming → idle
  * - Captures result/error locally (React handles cleanup)
- * - If multiple actions fire, tracks only the last one
+ * - If the same action fires several times, reports the latest call to
+ *   start. An earlier call that settles later changes nothing it reports;
+ *   a latest call that was aborted reports idle with nothing. One call at a
+ *   time, not one per argument: a reader filtering on `payload` cannot track
+ *   an earlier call once a later one starts.
  * - Supports selector pattern like useNavigation
  *
  * Matching behavior:
  * - **Function reference**: Uses full $$id for exact matching. This is precise
  *   and distinguishes between actions with the same name in different files.
  * - **String**: Matches by suffix (action name after #). This is convenient
- *   but may be ambiguous if multiple files export the same action name.
+ *   but may be ambiguous if multiple files export the same action name: it
+ *   follows the latest call of any action with that export name.
  *
  * @param action - Either a server action function or a string action name.
  *   - **Function**: Must be directly imported in the client component.

package/dist/types/browser/react/use-handle.d.ts

@@ -21,21 +21,24 @@ import type { RouteStateSignal } from "../event-controller.js";
 export declare function useHandle<T, A>(handle: Handle<T, A>): Rango.FlightSerialize<A>;
 export declare function useHandle<T, A, S>(handle: Handle<T, A>, selector: (data: Rango.FlightSerialize<A>) => S): S;
 /**
- * Route state the controller's handle notifications drive (useHandle,
- * useSegments) commits with the page it belongs to. NavigationProvider
- * flushes the controller inside every payload update, so a value known then
- * is set in the page's lane. A page handed over urgently (signal "release")
- * takes a value that arrives before it commits the same way: set at default
- * priority, it renders in the page's lane, and the page's effects read it.
- * A page in a transition (signal "anchor") does not: until it commits
+ * Route state the controller's handle notifications drive commits with the
+ * page it belongs to. NavigationProvider flushes the controller inside every
+ * payload update, with signal "anchor" for a page in a transition and
+ * "release" for an urgent one, so the page's own change is set in the page's
+ * lane and the page's effects read it. From the anchor until the page commits
  * (releaseRouteState() from the provider's layout effect, signal "release"),
- * a new value waits, and is applied in the commit's task, right after the
- * page's own commit. In the page's lane, a value that suspends in a revealed
- * <Suspense> (a crumb's content) would hold the page; in a lane of its own,
- * it commits over the page being left and takes the page's transition types
- * (#1165); and a transition entangled with the page misses its commit when it
- * is set after React rendered the page, before its view transition's
- * mutation, and starts a view transition of its own. A value shallow-equal to
- * the last one sets nothing, so a reader renders only when its value moves.
+ * a later change waits and is applied in the commit's task, right after the
+ * page's own commit: set in a lane of its own, it would commit over the page
+ * being left (#1165).
+ *
+ * `waitForRelease`, set by useHandle only: the anchor's own change waits too,
+ * so a handle value lands right after its page's commit, never in its lane. A
+ * handle value can carry a promise that suspends, and in the page's lane one
+ * that suspends in a revealed <Suspense> would hold the page. Nothing
+ * useSegments reads can suspend, so it leaves it off and its path and
+ * location commit with their page.
+ *
+ * A value shallow-equal to the last one sets nothing, so a reader renders only
+ * when its value moves.
  */
-export declare function useCommitAnchoredState<T>(init: () => T): [T, (value: T, signal?: RouteStateSignal) => void];
+export declare function useCommitAnchoredState<T>(init: () => T, waitForRelease?: boolean): [T, (value: T, signal?: RouteStateSignal) => void];

package/dist/types/browser/react/use-link-status.d.ts

@@ -14,8 +14,11 @@ export interface LinkStatus {
 /**
  * Hook to track the pending state of a Link component
  *
- * Must be used inside a Link component. Returns `{ pending: true }`
- * when navigation to this link's destination is in progress.
+ * Must be used inside a Link component. Returns `{ pending: true }` while a
+ * navigation to the link's destination is in flight, until the page it
+ * brings commits: under transition() while React holds that page, and
+ * through a server redirect until the target page commits. A newer
+ * navigation ends it at once.
  *
  * Useful for showing inline loading indicators on individual links.
  *

package/dist/types/browser/segment-reconciler.d.ts

@@ -62,10 +62,38 @@ export interface ReconcileResult {
  */
 export declare function reconcileSegments(input: ReconcileInput): ReconcileResult;
 /**
- * Reconcile error segments with cached segments.
+ * Reconcile an error-boundary response with cached segments.
  *
- * For error responses, the server returns the error boundary segment.
- * This function overlays error segments onto the full cached tree,
- * preserving sibling layouts that aren't in the error parent chain.
+ * The server returns the error boundary segment and, above it, what the
+ * action's revalidation re-ran (rsc/server-action.ts). This function overlays
+ * them onto the full cached tree, preserving sibling layouts that aren't in
+ * the error parent chain. The error segment replaces its cached copy; every
+ * other segment merges as an action's does (mergeCached).
  */
 export declare function reconcileErrorSegments(cachedSegments: ResolvedSegment[], errorSegments: ResolvedSegment[]): ReconcileResult;
+/**
+ * The ids a page holds once an action's error boundary `boundary` shows: the
+ * ones above it. Nothing at or below the boundary ran after the action's
+ * write (its response and the follow-up cut there), so the next request must
+ * not hold it. ShortCodes nest, so those ids start with the boundary's: the
+ * boundary, its loaders (`${id}D…`), its slots and every entry under it. A
+ * sibling with a longer index (`…R10` beside `…R1`) is kept.
+ */
+export declare function idsAboveBoundary(ids: string[], boundary: string | undefined): string[];
+/**
+ * The error segment of every action error boundary committed, by identity
+ * (server-action-bridge.ts adds and deletes). An entry shows one while its
+ * cached list still holds that object: a later commit on the entry replaces
+ * the list, and a refetch that holds the boundary keeps it. Weak, so a
+ * replaced boundary is not kept alive. Two routers never share a segment
+ * object. No hook reads it.
+ */
+export declare const actionBoundaries: WeakSet<ResolvedSegment>;
+/**
+ * The index of the deepest action error boundary in `segments`, -1 for none.
+ * It is that action's outcome, which no GET reproduces: a background refetch
+ * of the page (the follow-up, Back/Forward's stale revalidation, the
+ * cross-tab refresh) holds it and renders what is above it. At 0 nothing is
+ * above it.
+ */
+export declare function actionBoundaryAt(segments: readonly ResolvedSegment[]): number;

package/dist/types/browser/types.d.ts

@@ -191,11 +191,24 @@ export interface InflightAction {
  * @internal This type is an implementation detail. Use PublicNavigationState instead.
  */
 export interface NavigationState {
-    /** Navigation lifecycle state (idle or loading during navigation) */
+    /**
+     * Lifecycle state: `"loading"` while a navigation is in flight and while a
+     * server action runs, `"idle"` otherwise
+     */
     state: "idle" | "loading";
-    /** Whether RSC data is currently streaming (initial load or navigation) */
+    /**
+     * Whether RSC data is currently streaming: a navigation's response, or a
+     * server action's response (initial load, navigation or action)
+     */
     isStreaming: boolean;
-    /** Current location */
+    /**
+     * True while a navigation is in flight (fetching or streaming, before its
+     * commit); false during a server action, whose `state` is still `"loading"`.
+     * Drive a navigation progress bar from this and an action spinner from
+     * `state`.
+     */
+    isNavigating: boolean;
+    /** The page on screen; moves when the next page shows (`pendingUrl` is the page being fetched) */
     location: NavigationLocation;
     /** URL being navigated to (null when idle) */
     pendingUrl: string | null;
@@ -450,6 +463,8 @@ export interface NavigateOptionsInternal extends Omit<NavigateOptions, "state">
     _skipCache?: boolean;
     /** Server redirects already followed by this navigation chain (0 for a user navigation) */
     _redirectHops?: number;
+    /** The URL a redirected navigation chain started from: a link to it stays pending (useLinkStatus) */
+    _redirectFrom?: string;
 }
 /**
  * Options for useRouter push/replace methods.
@@ -558,7 +573,8 @@ export interface NavigationStore {
          */
         handlesPending?: boolean;
     } | undefined;
-    hasHistoryCache(historyKey: string): boolean;
+    /** Whether an intercept entry is cached for the plain `historyKey`, from any source page. */
+    hasInterceptCache(historyKey: string): boolean;
     /**
      * Update only the handleData (and optionally the stale / handlesPending flags)
      * of an existing cache entry. When a flag is omitted the entry's current value
@@ -602,6 +618,8 @@ export interface FetchPartialOptions {
     signal?: AbortSignal;
     /** If true, this is a stale cache revalidation request - server should force revalidators */
     staleRevalidation?: boolean;
+    /** Sent as `_rsc_boundary` (wire-params.ts WIRE.boundary). */
+    boundary?: string;
     interceptSourceUrl?: string;
     /** RSC version for cache invalidation detection */
     version?: string;
@@ -666,7 +684,8 @@ export interface ServerActionBridgeConfig {
  */
 export interface NavigationBridge {
     navigate(url: string, options?: NavigateOptionsInternal): Promise<void>;
-    refresh(): Promise<void>;
+    /** `crossTab`: another tab's write; an action's error boundary stays. */
+    refresh(crossTab?: boolean): Promise<void>;
     /** `event`: the popstate event; a traversal the browser animated itself (hasUAVisualTransition) is not animated again. */
     handlePopstate(event?: PopStateEvent): Promise<void>;
     registerLinkInterception(): () => void;

package/dist/types/browser/wire-protocol.d.ts

@@ -0,0 +1,26 @@
+/** The parameters of a partial request: a navigation, a prefetch or a JS server action. */
+export interface PartialRequestInit {
+    /** A JS server action's id: written as `_rsc_action` in place of `_rsc_partial`. */
+    action?: string;
+    /** The mounted segment ids the server diffs against. */
+    segmentIds: readonly string[];
+    /**
+     * An empty `segmentIds`: "send" writes `_rsc_segments=` (navigation,
+     * action), "omit" leaves it out (prefetch). The prefetch cache keys carry
+     * the difference.
+     */
+    emptySegments: "send" | "omit";
+    stale?: boolean;
+    boundary?: string;
+    version?: string;
+    routerId?: string;
+    rewriteTarget?: string;
+    fill?: boolean;
+}
+/**
+ * Writes the partial-request parameters onto `url` in the one order every
+ * sender uses. Navigation and prefetch cache keys are built from the result
+ * (prefetch/cache.ts), so a navigation adopts a prefetch only while both
+ * write identically: browser/__tests__/wire-urls.test.ts pins the strings.
+ */
+export declare function writePartialParams(url: URL, init: PartialRequestInit): URL;

package/dist/types/cache/cache-key-utils.d.ts

@@ -97,8 +97,10 @@ export declare const KEY_PART_PREFIX = "key:";
  * (CacheScope.resolveKeyFrom, CacheScope.resolvePartition): the `key()`
  * results of the scope's cache() chain, outermost first, then its default
  * parts: the keyGenerator results of enclosing scopes on another store
- * (#974) and, for a record key under a scope without its own `key()`, its
- * default key (or its store's keyGenerator result, #970).
+ * (#974) and, for a route record key, the scope's own part: without a
+ * `key()` of its own, its default key (or its store's keyGenerator result,
+ * #970); with one, the default key's request kind (`doc`, `partial` or
+ * `intercept:<intercept>`, routeRecordKind in cache-scope.ts).
  *
  * Key scheme invariant (#975). A `key()` result is often request input,
  * and a record key has no route or scope discriminator (the store reads
@@ -124,9 +126,13 @@ export declare const KEY_PART_PREFIX = "key:";
  * A namespaced `key()` result starts with `key:` and holds no `|`. A
  * composed key holds a `|` and either starts with `key:` or holds no `:`.
  * Among composed keys, splitting on `|` recovers each part, a part's kind
- * (a `key:` prefix, or no `:` at all) and its value. Pinned by the collision
- * probe in src/cache/__tests__/cache-scope-chain.test.ts. A keyGenerator
- * result is the store's own namespace, as before.
+ * (a `key:` prefix, or no `:` at all) and its value. A request kind part is
+ * a default key's prefix without the URL after it, so it never equals a
+ * default key part; a keyGenerator part can equal it (`doc`) only when the
+ * keyGenerator returns a constant, which already gives every URL one record.
+ * Pinned by the collision probe in
+ * src/cache/__tests__/cache-scope-chain.test.ts. A keyGenerator result is
+ * the store's own namespace, as before.
  *
  * Shared with the testing helper `shellCacheKey`, so a test builds the
  * production partition.

package/dist/types/cache/cache-scope.d.ts

@@ -14,16 +14,23 @@ import { type ExecutionStart } from "./tag-invalidation.js";
 import { type OwnedPushDelivery } from "./handle-snapshot.js";
 import type { RequestContext } from "../server/request-context.js";
 type CacheKeyFn = NonNullable<PartialCacheOptions["key"]>;
+/**
+ * A route record that answered. `restoreHandles` is set when the lookup left
+ * the handle restore to its caller (lookupRouteDetailed `deferHandles`),
+ * which names the segments it sends (handle-snapshot.ts restoreHandles).
+ */
+export interface CachedRouteHit {
+    segments: ResolvedSegment[];
+    shouldRevalidate: boolean;
+    restoreHandles?: (sentIds: ReadonlySet<string>) => Promise<void>;
+}
 /**
  * Discriminated outcome of a route cache lookup — see
  * {@link CacheScope.lookupRouteDetailed} for what each status licenses.
  */
 export type CacheRouteLookupOutcome = {
     status: "hit";
-    result: {
-        segments: ResolvedSegment[];
-        shouldRevalidate: boolean;
-    };
+    result: CachedRouteHit;
 } | {
     status: "miss" | "bypass" | "error";
 };
@@ -187,14 +194,18 @@ export declare class CacheScope {
      * enclosing partition (#970, #974). A scope whose own config sets no
      * `key()` appends its own default key (resolveDefaultKey). Reusing the
      * outer `key()` result alone would give every route under the inner
-     * cache() one record: a `key()` replaces the whole default key, so an
-     * outer key that names no route (`tier:gold`) would make `/a` HIT `/b`'s
-     * record. A scope with its own `key()` adds no default key: a `key()` is a
-     * full override, and its store's keyGenerator does not run. With no
-     * partition part it is resolveDefaultKey alone. With a `key()` on the
-     * chain but no request context it rejects (keyWithoutContextError).
-     * `partitionedPrefix` prefixes a key built from partition parts only (the
-     * response family's `response:`).
+     * cache() one record: a `key()` replaces the default key's URL part, so
+     * an outer key that names no route (`tier:gold`) would make `/a` HIT
+     * `/b`'s record. A scope with its own `key()` adds no default key: its `key()`
+     * replaces the URL part, and its store's keyGenerator does not run. It
+     * appends `kind` instead (routeRecordKind): the `key()` decides which
+     * requests of one kind share a record, never that a document, a
+     * navigation and an intercept navigation do. With no partition part it is
+     * resolveDefaultKey alone. With a `key()` on the chain but no request
+     * context it rejects (keyWithoutContextError). `partitionedPrefix`
+     * prefixes a key built from partition parts only (the response family's
+     * `response:`, which passes no `kind`: a response route answers every
+     * request alike).
      *
      * Each `key()` result lives on the request context (`_resolvedCacheKeys`),
      * by function: it runs once per request whatever the default key
@@ -205,7 +216,7 @@ export declare class CacheScope {
      * itself: a `key()` calling `cookies()` would trip the capture guard there,
      * and a capture must store the partition its request resolved.
      */
-    resolveKeyFrom(defaultKey: string, partitionedPrefix?: string): Promise<string>;
+    resolveKeyFrom(defaultKey: string, partitionedPrefix?: string, kind?: string): Promise<string>;
     /**
      * @internal The request partition of a ppr route's shell under this scope
      * (resolveShellPartition): its partition parts (resolvePartitionParts),
@@ -285,14 +296,14 @@ export declare class CacheScope {
      *
      * @param pathname - URL pathname for cache key generation
      * @param params - Route params for cache key generation
-     * @param isIntercept - Whether this is an intercept navigation (uses different cache key)
+     * @param intercept - The intercept an intercept navigation selected
+     *   (interceptRecordKey): its record has its own key
      * @param ownedPushes - What the record is to each loader's handle pushes
      *   (withCacheLookup: loader-cache.ts loaderPins), called on a hit
+     * @param deferHandles - Restore no handle value here: the caller calls the
+     *   hit's `restoreHandles` once it decided which segments it sends
      */
-    lookupRoute(pathname: string, params: Record<string, string>, isIntercept?: boolean, ownedPushes?: () => OwnedPushDelivery): Promise<{
-        segments: ResolvedSegment[];
-        shouldRevalidate: boolean;
-    } | null>;
+    lookupRoute(pathname: string, params: Record<string, string>, intercept?: string, ownedPushes?: () => OwnedPushDelivery, deferHandles?: boolean): Promise<CachedRouteHit | null>;
     /**
      * @internal lookupRoute with a discriminated outcome. The PPR replay
      * composition (withCacheLookup) may substitute the seeded doc record ONLY on
@@ -311,7 +322,7 @@ export declare class CacheScope {
      * A corrupt entry that was evicted reads as `miss`: the store was consulted
      * and holds nothing servable, which is the post-eviction truth.
      */
-    lookupRouteDetailed(pathname: string, params: Record<string, string>, isIntercept?: boolean, ownedPushes?: () => OwnedPushDelivery): Promise<CacheRouteLookupOutcome>;
+    lookupRouteDetailed(pathname: string, params: Record<string, string>, intercept?: string, ownedPushes?: () => OwnedPushDelivery, deferHandles?: boolean): Promise<CacheRouteLookupOutcome>;
     /**
      * Record this scope's segment-DSL cache({ tags }) into the request tag union
      * synchronously, under the same gate cacheRoute() uses for a write.
@@ -341,13 +352,14 @@ export declare class CacheScope {
      * @param pathname - URL pathname for cache key generation
      * @param params - Route params for cache key generation
      * @param segments - All resolved segments to cache
-     * @param isIntercept - Whether this is an intercept navigation (uses different cache key)
+     * @param intercept - The intercept an intercept navigation selected
+     *   (interceptRecordKey): its record has its own key
      * @param start - Where the render of `segments` started: the record is not
      *   written when one of its tags was invalidated since (#977,
      *   predatesInvalidation). A shell capture's doc record passes none: it
      *   lives only in the shell entry, which putShell gates by its own start.
      */
-    cacheRoute(pathname: string, params: Record<string, string>, segments: ResolvedSegment[], isIntercept?: boolean, start?: ExecutionStart): Promise<void>;
+    cacheRoute(pathname: string, params: Record<string, string>, segments: ResolvedSegment[], intercept?: string, start?: ExecutionStart): Promise<void>;
 }
 /**
  * @internal The request partition of a ppr route's shell: with a route
@@ -392,7 +404,7 @@ export declare function createShellImplicitDocScope(marker: ShellImplicitCacheMa
  * normal partial navigation replay), substitute an implicit doc-level scope
  * so withCacheLookup/withCacheStore treat the WHOLE matched route as a
  * cache() boundary — the shell entry IS a cache() of the handler layer, with
- * loaders as the live carve-outs (resolveFreshLoadersAndYield).
+ * loaders as the live carve-outs (serveStoredSegments).
  *
  * A document HIT tail (`docTail`) always gets the implicit scope: it replays
  * the shell's own record and never consults a route-derived scope, whose

package/dist/types/cache/cf/cf-cache-constants.d.ts

@@ -38,13 +38,13 @@ export declare const CACHE_REVALIDATING_AT_HEADER = "x-edge-cache-revalidating-a
  * re-arm re-puts the full window and restarts CF's retention clock, pinning a
  * perpetually-stale entry (one whose background revalidation keeps failing) past
  * its intended hard-expiry indefinitely. Mirrors the KVSegmentEnvelope `e`
- * field and the remaining-ttl math in promoteSegmentToL1/promoteItemToL1.
+ * field and the remaining-ttl math in promoteToL1.
  * @internal
  */
 export declare const CACHE_EXPIRES_AT_HEADER = "x-edge-cache-expires-at";
 /**
  * Header stashing the route author's original Cache-Control on L1 document
- * entries. putResponse/promoteResponseToL1 overwrite Cache-Control with a long
+ * entries. putResponse/promoteToL1 overwrite Cache-Control with a long
  * `max-age` so the CF Cache API retains the entry across the whole SWR window;
  * getResponse restores this original value before serving so the client and any
  * upstream CDN see the author's intended directive, not the internal edge TTL.