@rangojs/router 0.24.4 → 0.26.0

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

@@ -1,10 +1,12 @@
 import type { NavigationStore, NavigationClient, UpdateSubscriber, ResolvedSegment } from "./types.js";
 import type { ReactNode } from "react";
+export declare const addTransitionType: ((type: string) => void) | undefined;
 import type { RenderSegmentsOptions } from "../segment-system.js";
 import type { BoundTransaction } from "./navigation-transaction.js";
-import type { HandleData, NavigationUpdate, RscMetadata } from "./types.js";
+import type { HandleData, NavigationUpdate, RscMetadata, ShownEntry } from "./types.js";
 import type { LoaderStore } from "../loader-store.js";
 import { type TransitionWhenActionInput } from "./transition-when.js";
+import { type TransitionWhenKind } from "../types/segments.js";
 /**
  * Hold/animate decision for a commit: a non-intercept segment carries a
  * transition, no intercept is presented, and this navigation's
@@ -18,8 +20,10 @@ export declare function shouldStartViewTransition(segments: readonly ResolvedSeg
  * settled/cached segments make it a no-op. Urgent commits call onUpdate
  * directly: nothing is held there, a reader of a pending stream suspends to
  * its fallback. Also used by renderRoute's navigate() (testing/render-route.tsx).
+ * Every commit is tagged with its transition({ when }) `kind` (#1165), then
+ * `transitionTypes`.
  */
-export declare function commitInTransition(loaders: LoaderStore, onUpdate: UpdateSubscriber, segments: readonly ResolvedSegment[], update: NavigationUpdate, transitionTypes: readonly string[]): void;
+export declare function commitInTransition(loaders: LoaderStore, onUpdate: UpdateSubscriber, segments: readonly ResolvedSegment[], update: NavigationUpdate, kind: TransitionWhenKind, transitionTypes: readonly string[]): void;
 /**
  * Configuration for creating a partial updater
  */
@@ -45,13 +49,15 @@ export interface PartialUpdateConfig {
         /** What the response's handlers pushed, to the handle store. */
         handles(metadata: RscMetadata): void;
         /**
-         * Deliver the navigation state to its readers now. A page built with
-         * holes commits in the task of its click, before the notification of the
-         * click has gone out (event-controller.ts makeDebouncedNotifier), and
-         * React holds that commit where a hole is read with no boundary: without
-         * this useNavigation() reads idle, on the page being left, for the whole
-         * wait. Delivered first, `loading` is on screen when the commit is
-         * handed over, and stays while React holds it, as for a plain click.
+         * Deliver the navigation state to its readers now, and commit it. A page
+         * built with holes commits in the task of its click, before the
+         * notification of the click has gone out (event-controller.ts
+         * makeDebouncedNotifier), and React holds that commit where a hole is
+         * read with no boundary: without this useNavigation() reads idle, on the
+         * page being left, for the whole wait. Committed first, `loading` is on
+         * screen when the commit is handed over, and stays while React holds it,
+         * as for a plain click. Delivered at default priority it joins the
+         * commit's urgent batch, which brings idle with the URL, and never shows.
          */
         flush(): void;
     };
@@ -70,8 +76,8 @@ export interface CommitOverrides {
     interceptSourceUrl?: string;
     /** Server-set location state to merge into history.pushState */
     serverState?: Record<string, unknown>;
-    /** The committed route's name (payload metadata), remembered per history entry. */
-    routeName?: string;
+    /** The payload's metadata: its route name and rewrite target, remembered per history entry. */
+    metadata?: ShownEntry;
 }
 /**
  * Discriminated update mode for partial updates.
@@ -120,8 +126,10 @@ export type UpdateMode = {
     action?: TransitionWhenActionInput;
 };
 /**
- * Type for the fetchPartialUpdate function
+ * Type for the fetchPartialUpdate function. In `action` mode it resolves with
+ * the error of a loader that threw while it re-ran (revalidationErrorOf);
+ * the loader throws at its read.
  */
-export type PartialUpdater = (targetUrl: string, segmentIds: string[] | undefined, isRetry: boolean, signal: AbortSignal | undefined, tx: BoundTransaction, mode?: UpdateMode) => Promise<void>;
+export type PartialUpdater = (targetUrl: string, segmentIds: string[] | undefined, isRetry: boolean, signal: AbortSignal | undefined, tx: BoundTransaction, mode?: UpdateMode) => Promise<Error | undefined>;
 export declare function createPartialUpdater(config: PartialUpdateConfig): PartialUpdater;
 export { createPartialUpdater as default };

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

@@ -86,6 +86,14 @@ export interface DecodedPrefetch {
      * one prefetch serves unlimited adoptions within TTL/state validity.
      */
     respawn?: () => DecodedPrefetch;
+    /**
+     * The prefetch's stall timer (executePrefetchFetch). Navigation clears it on
+     * the entry it serves: from then on the click owns the stream, which runs to
+     * its end (a Flight response that arrived is never aborted mid-stream). A
+     * prefetch nobody adopted keeps it, so a stalled one is still aborted.
+     * Absent on a respawned entry, which has no timer.
+     */
+    stallTimer?: ReturnType<typeof setTimeout>;
     /**
      * Release the buffered reserve bytes. Called when the entry is evicted
      * without being consumed (expiry, FIFO, sweep, cache clear) so the tee

package/dist/types/browser/rango-marker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Publishes `window.__rango = { version }` so outside tools can tell a page is
+ * a Rango app and which router release serves it. Write-only and informational:
+ * nothing in the router reads it (rango-marker.test.ts greps src/ for reads),
+ * and only the npm semver is exposed, no build hash, router id or config.
+ */
+export declare function publishRangoMarker(): void;

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

@@ -5,6 +5,16 @@
 export declare const LOADER_SEGMENT_ID: RegExp;
 /** True for a loader sub-id ("M0L0D1.user"), false for a layout/route/slot id. */
 export declare function isLoaderSegmentId(id: string): boolean;
+/**
+ * The parent of a loader sub-id (`${parentId}D${index}.${loaderId}`); any
+ * other id unchanged. parentId is a shortCode (never "D"), or
+ * `${shortCode}.${slotName}` for an intercept slot's loaders, where the
+ * user-chosen name may hold an uppercase "D" ("@Detail"). Strip from the first
+ * `D<index>.`: splitting on a bare "D" mis-cut "@Detail" to "@" and silently
+ * dropped the loader's data. Correct only because slot names cannot contain
+ * "." (assertValidSlotName, route-definition/dsl-helpers.ts).
+ */
+export declare function loaderParentId(id: string): string;
 /**
  * Build the handle-collection segment order from a raw `matched` list.
  *

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

@@ -1,4 +1,5 @@
 import type { Handle } from "../../handle.js";
+import type { RouteStateSignal } from "../event-controller.js";
 /**
  * Hook to access collected handle data.
  *
@@ -19,3 +20,22 @@ import type { Handle } from "../../handle.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
+ * (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.
+ */
+export declare function useCommitAnchoredState<T>(init: () => T): [T, (value: T, signal?: RouteStateSignal) => void];

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

@@ -5,6 +5,12 @@
  * include() mount prefix. Inside an include("/shop", ...) scope,
  * the returned function resolves local paths relative to /shop.
  *
+ * Under a parameterized mount (`include("/:accountId", ...)`) the mount's
+ * params are filled from the current route params, as `useReverse` does:
+ * `href("/issues")` at `/acme/board` returns `/acme/issues`. A mount param
+ * missing from the current match throws `Missing param` when the returned
+ * function is called.
+ *
  * For absolute paths (outside the current mount), use the bare
  * href() function directly instead.
  *

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

@@ -13,7 +13,12 @@ import type { RouterInstance } from "../types.js";
  *
  * RELATIVE paths (no leading `/`, no scheme/query/hash) resolve against the
  * current include() mount: `router.push("cart")` inside `include("/shop")`
- * navigates to `/shop/cart`. Absolute paths stay APP-absolute — unlike
+ * navigates to `/shop/cart`. Under a parameterized mount
+ * (`include("/:accountId", ...)`) the mount's params are filled from the
+ * current route params: `router.push("issues")` at `/acme/board` navigates
+ * to `/acme/issues`, and a missing mount param rejects the push/replace
+ * promise with `Missing param` (a prefetch skips the target).
+ * Absolute paths stay APP-absolute — unlike
  * basename, the mount is scoped, and absolute pushes legitimately target
  * outside it, so they are never auto-prefixed.
  *

package/dist/types/browser/response-adapter.d.ts

@@ -48,9 +48,11 @@ export declare function handleReloadHeader(response: Response, opts: {
  * end-of-stream, calling onComplete when done.
  *
  * `onComplete` receives `endedCleanly`: true only on a normal EOF drain, false
- * on a read error or an abort (the signal cancelled the reader). Callers that
- * gate a "fully complete" fast path (e.g. prefetch's `entry.complete`) must
- * treat a non-clean end as incomplete — a broken stream is not complete data.
+ * on a read error, an abort (the signal cancelled the reader), or a body that
+ * ends with PREFETCH_FAILED_ROW (a prefetch whose render reported an error,
+ * rsc/prefetch-render-error.ts). Callers that gate a "fully complete" fast
+ * path (e.g. prefetch's `entry.complete`) must treat a non-clean end as
+ * incomplete — a broken stream is not complete data.
  *
  * If the response has no body, onComplete fires synchronously with `true`
  * (an empty body is a clean, complete stream).

package/dist/types/browser/scroll-restoration.d.ts

@@ -63,10 +63,12 @@ export declare function cancelScrollRestorationPolling(): void;
  *
  * @param options.retryIfStreaming - If true, poll while streaming until we can scroll to target
  * @param options.isStreaming - Function to check if streaming is in progress
+ * @param options.committed - React has committed the restored tree (a layout effect)
  */
 export declare function restoreScrollPosition(options?: {
     retryIfStreaming?: boolean;
     isStreaming?: () => boolean;
+    committed?: boolean;
 }): boolean;
 /**
  * Handle hash link scrolling.
@@ -86,9 +88,11 @@ export declare function scrollToTop(): void;
 export declare function handleNavigationStart(): void;
 /**
  * Handle scroll for a back/forward traversal, at popstate before anything
- * renders: save the page being left under ITS key (history has already moved,
- * so saveCurrentScrollPosition would use the destination's key) and track the
- * destination as the displayed entry.
+ * renders: save the page on screen under ITS key (history has already moved,
+ * so saveCurrentScrollPosition would use the destination's key). A second
+ * traversal before the first one's restore commits (a rapid double Back, a
+ * deferred animated restore) saves the page still on screen, never an entry
+ * it did not show.
  */
 export declare function handleTraversalStart(): void;
 /**
@@ -96,11 +100,13 @@ export declare function handleTraversalStart(): void;
  * @param options.restore - If true, restore saved position (for popstate)
  * @param options.scroll - If false, don't scroll at all
  * @param options.isStreaming - Function to check if streaming is in progress (for retry logic)
+ * @param options.committed - Called after React committed the new tree
  */
 export declare function handleNavigationEnd(options: {
     restore?: boolean;
     scroll?: boolean;
     isStreaming?: () => boolean;
+    committed?: boolean;
 }): void;
 /**
  * Update the history state key after pushState/replaceState.

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

@@ -2,15 +2,17 @@ import type { ResolvedSegment } from "./types.js";
 /**
  * Determines the merging behavior for segment reconciliation.
  *
- * - 'action': From server-action-bridge's own merge. Always merges loaders,
- *   always preserves cached loading (even undefined), never clears cached
- *   segment loading.
- * - 'navigation': From partial-update during normal navigation. Does NOT merge
- *   loaders, preserves cached loading only when defined, clears truthy loading
- *   on cached segments not in server diff.
+ * - 'action': From server-action-bridge's own merge. Always preserves cached
+ *   loading (even undefined), never clears cached segment loading.
+ * - 'navigation': From partial-update during normal navigation. Preserves
+ *   cached loading only when defined, clears truthy loading on cached
+ *   segments not in server diff.
  * - 'stale-revalidation': From partial-update during stale revalidation or
- *   action-triggered refetch. Merges loaders, always preserves cached loading
- *   (same as action), clears truthy loading on cached segments not in server diff.
+ *   action-triggered refetch. Always preserves cached loading (same as
+ *   action), clears truthy loading on cached segments not in server diff.
+ *
+ * No actor merges loader data: a loader the server skipped, an intercept's
+ * included, is its own cached segment in `matched`.
  */
 export type ReconcileActor = "navigation" | "action" | "stale-revalidation";
 export interface ReconcileInput {
@@ -52,11 +54,6 @@ export interface ReconcileResult {
  *   (not undefined). When cached is undefined, lets server value through
  *   because we're building a new tree.
  *
- * Loader merging:
- * - action/stale-revalidation: Merges partial loader data when server returns
- *   fewer loaders than cached (revalidation only updated some loaders).
- * - navigation: Does not merge (full navigation fetches complete data).
- *
  * Cached segment handling (segments in matched but not in server response):
  * - action: Returns cached segment as-is (preserve tree structure).
  * - navigation/stale-revalidation: Clears truthy loading to undefined

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

@@ -29,6 +29,11 @@ export type HandleData = Record<string, Record<string, unknown[]>>;
  */
 export interface RscMetadata {
     pathname: string;
+    /**
+     * Path and search of the URL the route rendered, when middleware rewrote
+     * the request there. Kept per history entry and sent back as `_rsc_rt`.
+     */
+    rewriteTarget?: string;
     segments: ResolvedSegment[];
     /** Router instance ID — the current app's identity. A mismatch with the
      *  client's id (sent as _rsc_rid) is detected server-side and answered with
@@ -223,6 +228,12 @@ export interface TrackedActionState {
     error: unknown | null;
     /** Result data from the action (preserved after completion) */
     result: unknown | null;
+    /**
+     * The error of a loader that threw while it re-ran after this successful
+     * action (the first, when several did). The loader also throws at its
+     * useLoader read, where the nearest error boundary catches it.
+     */
+    revalidationError: unknown | null;
 }
 /**
  * The value returned by {@link useAction} when called without a selector.
@@ -262,13 +273,23 @@ export interface SegmentState {
     currentUrl: string;
     currentSegmentIds: string[];
 }
+/**
+ * What a committed payload says about the page it shows, remembered per
+ * history entry (NavigationStore.rememberDisplayedEntry).
+ *
+ * @internal This type is an implementation detail and may change without notice.
+ */
+export interface ShownEntry {
+    readonly routeName?: string;
+    readonly rewriteTarget?: string;
+}
 /**
  * What the router remembers about one history entry for transition({ when })
- * (NavigationStore.rememberDisplayedEntry).
+ * and the requests made from it (NavigationStore.rememberDisplayedEntry).
  *
  * @internal This type is an implementation detail and may change without notice.
  */
-export interface HistoryEntryMemory {
+export interface HistoryEntryMemory extends ShownEntry {
     readonly routeName: string | undefined;
     /** The entry's `history.state` as last recorded. */
     readonly state: unknown;
@@ -295,6 +316,12 @@ export interface NavigationUpdate {
         /** Function to check if streaming is in progress */
         isStreaming?: () => boolean;
     };
+    /**
+     * Handed to React inside startTransition (commitInTransition, an action's
+     * commit, a cached back/forward's): NavigationProvider joins the route
+     * state that arrives while React holds it to its commit.
+     */
+    inTransition?: true;
 }
 /**
  * Plain object accepted as {@link PlainHistoryState}. The `any` string index
@@ -504,12 +531,12 @@ export interface NavigationStore {
     /**
      * Per-history-entry memory for transition({ when }) sources: record the
      * entry on screen (keyed by its `history.state.key`) with its current
-     * `history.state` and, when given, its route name (kept from the last
-     * record otherwise; every push/replace creates a new key, so a stale name
-     * never carries to another entry). Called after every commit, restore and
-     * state merge.
+     * `history.state` and, when `shown` is given, its route name and rewrite
+     * target (both kept from the last record otherwise; every push/replace
+     * creates a new key, so a stale record never carries to another entry).
+     * Called after every commit, restore and state merge.
      */
-    rememberDisplayedEntry(routeName?: string): void;
+    rememberDisplayedEntry(shown?: ShownEntry): void;
     /**
      * The memory of the entry on screen, or of `entryKey`. At popstate
      * history.state already belongs to the destination, so back/forward reads
@@ -570,6 +597,8 @@ export interface FetchPartialOptions {
     targetUrl: string;
     segmentIds: string[];
     previousUrl: string;
+    /** The page's RscMetadata.rewriteTarget, sent as `_rsc_rt`. */
+    rewriteTarget?: string;
     signal?: AbortSignal;
     /** If true, this is a stale cache revalidation request - server should force revalidators */
     staleRevalidation?: boolean;
@@ -638,7 +667,8 @@ export interface ServerActionBridgeConfig {
 export interface NavigationBridge {
     navigate(url: string, options?: NavigateOptionsInternal): Promise<void>;
     refresh(): Promise<void>;
-    handlePopstate(): Promise<void>;
+    /** `event`: the popstate event; a traversal the browser animated itself (hasUAVisualTransition) is not animated again. */
+    handlePopstate(event?: PopStateEvent): Promise<void>;
     registerLinkInterception(): () => void;
     registerDelegatedPrefetch(): () => void;
     /** Current RSC version (live, reflects the latest updateVersion). */

package/dist/types/build/route-types/per-module-writer.d.ts

@@ -11,6 +11,18 @@ export declare function writePerModuleRouteTypes(root: string, filter?: ScanFilt
  * e.g. `export const patterns = urls(...)` -> ["patterns"]
  */
 export declare function findUrlsVariableNames(code: string): string[];
+export interface PerModuleRouteTypesPlan {
+    genPath: string;
+    /** A urls()/clientUrls() variable resolved to zero routes; content is empty. */
+    isPlaceholder: boolean;
+    content: string;
+}
+/**
+ * Pure half of the per-module writer: reads sources, never writes. Returns
+ * null when the file has no `urls(`/`clientUrls(` or no named routes and no
+ * urls() variable. Throws on failure.
+ */
+export declare function planPerModuleRouteTypesForFile(filePath: string): PerModuleRouteTypesPlan | null;
 /**
  * Generate per-module route types for a single url module file.
  * Follows include() calls recursively to produce the full route tree.

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

@@ -21,8 +21,6 @@ export declare class CFCacheStore<TEnv = unknown> implements SegmentCacheStore<T
     private readonly namespace?;
     private readonly explicitBaseUrl?;
     private readonly waitUntil?;
-    /** The `version` option: used for every versioned family when set. */
-    private readonly explicitVersion?;
     private readonly edgeLookupTimeoutMs;
     private readonly edgeReadTimeoutMs;
     private readonly kvReadTimeoutMs;

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

@@ -278,22 +278,6 @@ export interface CFCacheStoreOptions<TEnv = unknown> {
      * (safe to set large) rather than the invalidation-latency ceiling.
      */
     tagCacheTtl?: number;
-    /**
-     * Cache version string override. When set, this exact value prefixes every
-     * versioned key the store writes (`v/{version}/...`), for cached data and
-     * stored HTML alike; changing it makes every earlier entry unreachable.
-     *
-     * Leave it unset for the default: the store keys with the versions of the
-     * router serving the request. Segment entries and `"use cache"` items use
-     * the router's data version; document responses and PPR shells use its
-     * document version (see `createRouter({ version })`). Those are computed
-     * from the router's built code, so a deploy that does not change the router
-     * keeps its entries.
-     *
-     * Tag invalidation markers are never versioned: an invalidation applies to
-     * the entries of every version, including one that comes back in a rollback.
-     */
-    version?: string;
     /**
      * Latency budget (ms) for an L1 edge cache (CF Cache API) read. A `match`
      * slower than this is abandoned and treated as a miss, so a degraded colo

package/dist/types/cache/cf/cf-shell-frame.d.ts

@@ -37,6 +37,8 @@ export interface ShellFrameHead {
     ta?: number;
     /** ShellCacheEntry.initialTheme */
     i?: string;
+    /** ShellCacheEntry.pathname (a visitor-keyed shell's rendered location). */
+    lp?: string;
     /** ShellCacheEntry.docKey; navigation replay needs it after any round trip. */
     dk?: string;
     /** ShellCacheEntry.prunedRecords (diagnostic). */

package/dist/types/cache/handle-snapshot.d.ts

@@ -73,8 +73,8 @@ export type OwnedPushDelivery = (loaderId: string) => RecordAuthority;
  * says the record supplies that loader's value too ("pin", "copies"), and is
  * a placeholder (pushPlaceholder) everywhere else: without `owned`, every
  * owner. Neither claims its loader, so the loader's own cache() HIT still
- * delivers (the thenable pushes a restored copy lets through, or its entry's
- * pushes in a placeholder's place).
+ * delivers (the pushes holding a promise a restored copy lets through, or its
+ * entry's pushes in a placeholder's place).
  */
 export declare function restoreHandles(handles: Record<string, SegmentHandleData>, handleStore: HandleStore, owners?: HandleOwners, owned?: OwnedPushDelivery): void;
 /**

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

@@ -389,7 +389,7 @@ export interface ShellCacheEntry {
     /** React.version captured at prerender time; the read-time invalidation gate. */
     reactVersion: string;
     /**
-     * Build version captured at prerender time: the RSC handler's `version`,
+     * Build version captured at prerender time: the RSC handler's version,
      * which is the router's DOCUMENT version (router-versions.ts) — a hash of
      * its server code and the client asset names by default, a stamp bumped on
      * dev RSC-module edits. The second read-time gate: a persistent shared
@@ -412,6 +412,14 @@ export interface ShellCacheEntry {
      * ThemeProvider.
      */
     initialTheme?: string;
+    /**
+     * The payload pathname of a shell keyed by the visitor's URL
+     * (`rewrite(...).shell("visitor")`, visitorShellKey); absent when the
+     * capture rendered its key's own URL. The serve tail replays it as it does
+     * `initialTheme`, and the serve gate serves the entry only to a request
+     * that renders this location.
+     */
+    pathname?: string;
     /**
      * The CAPTURE DATA SNAPSHOT, in stored/serialized form: the doc segment
      * record every HIT replays the handler layer from (`docKey`) and the
@@ -617,11 +625,13 @@ export interface ShellSnapshotLoaderValue {
      */
     holes: 0 | 1;
     /**
-     * 1 when the capture saw a loader push it could not record (a deferred
-     * push, one with masked nested promises, or one made outside any loader
-     * body): a HIT then still runs the loader body in the background
-     * (pin-first) so those pushes reach the page. 0: a hole-free record is
-     * served from the pin alone and its body does not run on a HIT.
+     * 1 when the capture saw a loader push it could not record (one whose
+     * settled value holds masked nested promises, one a live-lane loader made,
+     * or one made outside any loader body): a HIT then still runs the loader
+     * body in the background (pin-first) so those pushes reach the page. A
+     * pushed promise that settles thenable-free is recorded (#1182).
+     * 0: a hole-free record is served from the pin alone and its body does not
+     * run on a HIT.
      *
      * Both bits are always written. A record stored before they existed (v0.17)
      * reads each missing bit as 1 (buildShellLoaderSeed): its snapshot lacks

package/dist/types/cache/vercel/vercel-cache-store.d.ts

@@ -102,7 +102,7 @@ export interface VercelCacheStoreOptions<TEnv = unknown> {
      *
      * Vercel does not reconcile entries between deployments; the store does it
      * through its keys, which carry the serving router's cache versions (see
-     * `version`). So a deploy that changes a router's code stops reading that
+     * `getCacheVersions`). So a deploy that changes a router's code stops reading that
      * router's old entries, and a deploy that does not keeps them. A namespace
      * that changes per deployment (`getCache({ namespace: VERCEL_DEPLOYMENT_ID })`)
      * still works and clears the cache on every deploy, which is what you want
@@ -128,18 +128,6 @@ export interface VercelCacheStoreOptions<TEnv = unknown> {
      * segmentation). Receives the request context and the default key.
      */
     keyGenerator?: (ctx: RequestContext<TEnv>, defaultKey: string) => string | Promise<string>;
-    /**
-     * Version override, folded into every versioned key as `v/{version}/...`.
-     * When set, this exact value is used for cached data and stored HTML alike;
-     * changing it makes everything this store wrote before unreachable.
-     *
-     * Leave it unset for the default: the store keys with the versions of the
-     * router serving the request, as CFCacheStore does. Segments and `"use
-     * cache"` items use the router's data version; responses and PPR shells use
-     * its document version (see `createRouter({ version })`). Tag markers are
-     * never versioned, so an invalidation applies to every version.
-     */
-    version?: string;
     /**
      * Max serialized entry size in bytes before a write is skipped. Defaults to
      * VERCEL_MAX_ITEM_BYTES (2 MB - the platform's hard cap).
@@ -238,8 +226,6 @@ export declare class VercelCacheStore<TEnv = unknown> implements SegmentCacheSto
     readonly keyGenerator?: (ctx: RequestContext<TEnv>, defaultKey: string) => string | Promise<string>;
     private readonly cache;
     private readonly waitUntil?;
-    /** The `version` option: used for every versioned family when set. */
-    private readonly explicitVersion?;
     private readonly maxItemBytes;
     private readonly memo;
     private readonly handleMemos;

package/dist/types/client-urls/client-urls.d.ts

@@ -1,7 +1,11 @@
 import { type TrieNode } from "../router/route-trie-builder.js";
-import type { ClientUrlBuilder, ClientUrlPatterns } from "./types.js";
+import type { ClientUrlBuilder, ClientUrlHelpers, ClientUrlPatterns } from "./types.js";
 import type { ExtractRoutes } from "../urls/type-extraction.js";
 import type { ClientUrlItems } from "./types.js";
+export declare const loader: ClientUrlHelpers["loader"];
+export declare const revalidate: ClientUrlHelpers["revalidate"];
+export declare const loading: ClientUrlHelpers["loading"];
+export declare const transition: ClientUrlHelpers["transition"];
 export declare function clientUrls<const TItems extends ClientUrlItems>(builder: ClientUrlBuilder<TItems>): ClientUrlPatterns<ExtractRoutes<TItems>>;
 /**
  * The router's trie over a group's routes, each pattern joined to the
@@ -24,4 +28,4 @@ export declare function buildClientUrlsTrie(routes: readonly {
         readonly trailingSlash?: string;
     };
 }[], mount: string, foreign?: readonly string[]): TrieNode;
-export type { ClientTransitionConfig, ClientUrlBuilder, ClientUrlHelpers, ClientUrlInterceptRecord, ClientUrlItem, ClientUrlItemInput, ClientUrlItems, ClientLayoutFn, ClientPathOptions, ClientUrlLoaderRecord, ClientPathFn, ClientUrlPatterns, ClientUrlRouteRecord, ClientUrlUse, } from "./types.js";
+export type { ClientTransitionConfig, ClientUrlBuilder, ClientUrlComponent, ClientUrlHelpers, ClientUrlInterceptRecord, ClientUrlItem, ClientUrlItemInput, ClientUrlItems, ClientLayoutFn, ClientPathOptions, ClientUrlLoaderRecord, ClientPathFn, ClientUrlPatterns, ClientUrlRouteRecord, ClientUrlUse, } from "./types.js";

package/dist/types/client-urls/revalidate-registry.d.ts

@@ -1,4 +1,4 @@
 import type { ShouldRevalidateFn } from "../types.js";
-export declare function registerClientUrlRevalidators(fns: Readonly<Record<string, ShouldRevalidateFn<any, any>>>): void;
+export declare function registerClientUrlRevalidators(fns: Readonly<Record<string, ShouldRevalidateFn<any, any> | boolean>>): void;
 export declare function getClientUrlRevalidator(key: string): ShouldRevalidateFn<any, any> | undefined;
 export declare function clearClientUrlRevalidators(): void;

package/dist/types/client-urls/server-projection.d.ts

@@ -38,11 +38,11 @@ export interface ClientUrlProjectionRoute {
      *  loader(), so a prefetch of the route defers them. Absent (= none) in
      *  projections serialized before the option existed. */
     readonly deferrableLoaderIndices?: readonly number[];
-    /** Per loader (aligned with loaderIds), the keys of its hoisted
-     *  revalidate() predicates in declaration order; materialization attaches
-     *  the registered predicates (revalidate-registry.ts). Absent when no
-     *  loader declares one. */
-    readonly loaderRevalidate?: readonly (readonly string[])[];
+    /** Per loader (aligned with loaderIds), its revalidate() arguments in
+     *  declaration order: a hoisted predicate's key, whose registration
+     *  materialization attaches (revalidate-registry.ts), or a boolean
+     *  literal. Absent when no loader declares one. */
+    readonly loaderRevalidate?: readonly (readonly (string | boolean)[])[];
     /** One per leading loader its layout()s declare
      *  (ClientUrlRouteRecord.layoutLoaders): the record's ordinal in the
      *  definition. Two routes whose loader at an index carries the same ordinal
@@ -62,6 +62,10 @@ export interface ClientUrlProjectionIntercept {
     readonly targetName: string;
     readonly loaderIds: readonly string[];
     readonly hasLoading: boolean;
+    /** As on a route (ClientUrlProjectionRoute.deferrableLoaderIndices). */
+    readonly deferrableLoaderIndices?: readonly number[];
+    /** As on a route (ClientUrlProjectionRoute.loaderRevalidate). */
+    readonly loaderRevalidate?: readonly (readonly (string | boolean)[])[];
 }
 export interface ClientUrlProjection {
     readonly version: 1;