@rangojs/router 0.5.1 → 0.6.0

package/dist/types.backup/browser/invalidate-client-cache.d.ts

@@ -1,17 +0,0 @@
-/**
- * Client seat of `invalidateClientCache()` (the `default` export condition).
- *
- * Makes the current client behave as if a server action had just completed:
- * the history cache is marked stale (SWR), the prefetch map is flushed, the
- * state rotates, and sibling tabs are broadcast to — the same
- * `markCacheAsStaleAndBroadcast()` path the server-action bridge uses. This is
- * the gentler mark-stale (not hard-clear) behavior, so Back renders the cached
- * entry instantly and revalidates.
- */
-export declare function invalidateClientCache(): void;
-/**
- * Client no-op for `keepClientCache()`. It is a server action directive (the
- * `react-server` condition sets a response header the action bridge reads);
- * there is nothing to suppress from the client side.
- */
-export declare function keepClientCache(): void;

package/dist/types.backup/browser/link-interceptor.d.ts

@@ -1,43 +0,0 @@
-import type { LinkInterceptorOptions, NavigateOptions } from "./types.js";
-/**
- * Check if an anchor points to the same page with only a hash change.
- * Used by both Link component and link-interceptor to let the browser
- * handle anchor scrolling natively.
- */
-export declare function isHashOnlyNavigation(anchor: HTMLAnchorElement): boolean;
-/**
- * Default link interception predicate
- *
- * Returns true if the link should be intercepted for SPA navigation.
- * Filters out:
- * - Cross-origin links
- * - Links with download attribute
- * - Links with target other than _self
- * - Links with data-no-intercept attribute
- *
- * @param link - The anchor element to check
- * @returns true if the link should be intercepted
- */
-export declare function defaultShouldIntercept(link: HTMLAnchorElement): boolean;
-/**
- * Set up link interception for SPA navigation
- *
- * Attaches a global click handler to intercept clicks on anchor elements
- * and call the onNavigate callback instead of performing a full page load.
- *
- * @param onNavigate - Callback when a link should navigate via SPA
- * @param options - Configuration options
- * @returns Cleanup function to remove the event listener
- *
- * @example
- * ```typescript
- * const cleanup = setupLinkInterception((url) => {
- *   window.history.pushState({}, "", url);
- *   fetchPartialUpdate(url);
- * });
- *
- * // Later, to clean up:
- * cleanup();
- * ```
- */
-export declare function setupLinkInterception(onNavigate: (url: string, options?: NavigateOptions) => void, options?: LinkInterceptorOptions): () => void;

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

@@ -1,33 +0,0 @@
-/**
- * Module-level debug flag for guarding call sites whose debug arguments do
- * non-trivial work (joins, maps, spreads, object literals). Because the Vite
- * transform folds INTERNAL_RANGO_DEBUG to a literal, an `if (IS_BROWSER_DEBUG)`
- * guard is minifier-DCE-able — the whole block drops from the production bundle.
- * Prefer this over isBrowserDebugEnabled() at hot call sites: a const guard folds
- * where a function call may not.
- */
-export declare const IS_BROWSER_DEBUG: boolean;
-interface BrowserLogContext {
-    requestId: string;
-    txId: string;
-    operation: string;
-}
-export declare function isBrowserDebugEnabled(): boolean;
-export declare function startBrowserTransaction(operation: string): BrowserLogContext;
-export declare function browserDebugLog(ctx: BrowserLogContext, message: string, details?: Record<string, unknown>): void;
-/**
- * Simple gated console.log for browser-side debug output.
- * Unlike browserDebugLog, this doesn't require a transaction context -
- * use it for standalone debug messages in partial-update, navigation-bridge, etc.
- */
-export declare function debugLog(msg: string, ...args: unknown[]): void;
-/**
- * Boot-sequence debug log: one line per initial-document step (flight decode,
- * handle stream, bridge wiring, initial tree build, hydration commit), each
- * stamped with performance.now() so the gap BEFORE hydrateRoot is visible.
- * The initial document path was otherwise silent — FE debug only started
- * talking at the first soft navigation, so a boot stall (e.g. an await that
- * holds initBrowserApp, and with it hydrateRoot) was invisible.
- */
-export declare function bootLog(step: string, details?: Record<string, unknown>): void;
-export {};

package/dist/types.backup/browser/merge-segment-loaders.d.ts

@@ -1,38 +0,0 @@
-import type { ResolvedSegment } from "./types.js";
-/**
- * Merge partial loader data from server with cached loader data.
- *
- * During partial revalidation (stale or action), the server may return only
- * some loaders that pass the revalidation check. The component still needs
- * all loader data, so we merge fresh data with cached data.
- *
- * @param fromServer - Segment returned from server with partial loaders
- * @param fromCache - Cached segment with full loader data
- * @returns Merged segment with complete loader data
- */
-export declare function mergeSegmentLoaders(fromServer: ResolvedSegment, fromCache: ResolvedSegment): ResolvedSegment;
-/**
- * Check if segments need loader merging during partial revalidation.
- *
- * Returns true when:
- * - Server returned fewer loaders than cached (partial revalidation)
- * - Both segments have loader data promises
- */
-export declare function needsLoaderMerge(fromServer: ResolvedSegment, fromCache: ResolvedSegment | undefined): fromCache is ResolvedSegment;
-/**
- * Insert diff segments that aren't in the matched array into allSegments.
- *
- * During consolidation fetch for concurrent actions, loader segments may be
- * excluded from the request. The server returns them in the diff but not in
- * the matched array. This function inserts them at the correct position
- * (after their parent layout segment).
- *
- * Loader segment IDs follow the pattern: {parentLayoutId}D{index}.{loaderId}
- * Example: M9L0L1D0.actionCounter has parent layout M9L0L1
- *
- * @param allSegments - Mutable array of segments to insert into
- * @param diff - Array of segment IDs that changed (from server response)
- * @param matchedIdSet - Set of segment IDs from matched array
- * @param newSegmentMap - Map of segment ID to segment data from server
- */
-export declare function insertMissingDiffSegments(allSegments: ResolvedSegment[], diff: string[] | undefined, matchedIdSet: Set<string>, newSegmentMap: Map<string, ResolvedSegment>): void;

package/dist/types.backup/browser/navigation-bridge.d.ts

@@ -1,27 +0,0 @@
-import type { NavigationBridge, NavigationBridgeConfig } from "./types.js";
-import { createNavigationTransaction } from "./navigation-transaction.js";
-import type { EventController } from "./event-controller.js";
-export { createNavigationTransaction };
-/**
- * Extended configuration for navigation bridge with event controller
- */
-export interface NavigationBridgeConfigWithController extends NavigationBridgeConfig {
-    eventController: EventController;
-    /** RSC version from initial payload metadata. */
-    version?: string;
-}
-/**
- * Create a navigation bridge for handling client-side navigation
- *
- * The bridge coordinates all navigation operations:
- * - Link click interception
- * - Browser back/forward (popstate)
- * - Programmatic navigation
- *
- * Uses the event controller for reactive state management.
- *
- * @param config - Bridge configuration
- * @returns NavigationBridge instance
- */
-export declare function createNavigationBridge(config: NavigationBridgeConfigWithController): NavigationBridge;
-export { createNavigationBridge as default };

package/dist/types.backup/browser/navigation-client.d.ts

@@ -1,17 +0,0 @@
-import type { NavigationClient, RscBrowserDependencies } from "./types.js";
-/**
- * Create a navigation client for fetching RSC payloads
- *
- * The client handles building URLs with RSC parameters and
- * deserializing the response using the RSC runtime.
- *
- * Checks the in-memory prefetch cache before making a network request.
- * Tries the source-scoped key first (populated when the server tagged
- * the response as source-sensitive via `X-RSC-Prefetch-Scope: source`)
- * and falls back to the Rango-state-keyed wildcard slot used for the
- * common source-agnostic case.
- *
- * @param deps - RSC browser dependencies (createFromFetch)
- * @returns NavigationClient instance
- */
-export declare function createNavigationClient(deps: Pick<RscBrowserDependencies, "createFromFetch">): NavigationClient;

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

@@ -1,25 +0,0 @@
-/**
- * A module-level handle to the active navigation store.
- *
- * The boot path (`rsc-router.tsx`) calls `createNavigationStore()` directly;
- * there is no global store singleton. This handle is the live reference for
- * code that needs the store but does not
- * receive it by argument: the jar-divergence observer (below) and the client
- * seat of `invalidateClientCache()` (added later).
- *
- * Dependency-light on purpose: it imports only `setRangoStateObserver` and the
- * store type, so pulling it into the default root entry does not drag the
- * navigation store into bundles that previously lacked it.
- */
-import type { NavigationStore } from "./types.js";
-/**
- * Register the active navigation store at boot, and wire the jar-divergence
- * observer: when a per-request cookie read detects an EXTERNAL rotation (a
- * sibling tab, a server `Set-Cookie`, or a cookie clear), mark this tab's
- * history cache stale. The history cache is not state-keyed, so the value
- * rotation alone does not reach it. No broadcast, no prefetch clear, no
- * re-rotation — the value already changed externally.
- */
-export declare function registerNavigationStore(store: NavigationStore): void;
-/** The active navigation store, or null before boot has registered it. */
-export declare function getRegisteredStore(): NavigationStore | null;

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

@@ -1,95 +0,0 @@
-import type { NavigationStore, ResolvedSegment, HandleData } from "./types.js";
-/**
- * Clone the handleData CONTAINERS (the handle-name map and each segment map) so
- * a cache entry is decoupled from the live map that eventController mutates — it
- * adds/deletes segment keys and REPLACES bucket arrays in place. The bucket
- * arrays themselves are shared by reference, NOT copied: a bucket array is only
- * ever replaced wholesale (eventController.setHandleData reassigns it,
- * resolveDeferredHandleValues builds a fresh one) and collect functions read it
- * without mutating, so sharing is safe and skips an O(elements) copy on every
- * cache write — the per-yield streaming hot path. This also preserves any
- * non-serializable bucket contents (React elements, functions, etc.).
- */
-export declare function cloneHandleData(handleData: HandleData): HandleData;
-/**
- * Options for generating a history key
- */
-export interface HistoryKeyOptions {
-    /** If true, append :intercept suffix to differentiate intercept entries */
-    intercept?: boolean;
-}
-/**
- * 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.
- *
- * For intercept routes, append `:intercept` suffix to cache them separately
- * from non-intercept versions of the same URL.
- */
-export declare function generateHistoryKey(url?: string, options?: HistoryKeyOptions): string;
-/**
- * Configuration for creating a navigation store
- */
-export interface NavigationStoreConfig {
-    initialLocation?: {
-        href: string;
-    };
-    initialSegmentIds?: string[];
-    initialHistoryKey?: string;
-    initialSegments?: ResolvedSegment[];
-    /**
-     * Maximum number of history entries to cache (default: 20)
-     * Older entries are evicted when limit is reached
-     */
-    cacheSize?: number;
-    /**
-     * Enable cross-tab cache invalidation via BroadcastChannel (default: true)
-     * When cache is cleared (via server actions or invalidateClientCache()),
-     * other tabs will also clear their cache
-     */
-    crossTabSync?: boolean;
-    /**
-     * Auto-refresh when another tab mutates data on the same path (default: true)
-     * Triggered when cache is cleared via server actions or invalidateClientCache()
-     * Requires crossTabSync to be enabled
-     */
-    crossTabAutoRefresh?: boolean;
-    /**
-     * Callback to invoke when cross-tab refresh is triggered
-     * Called when another tab invalidates the cache for a related route
-     */
-    onCrossTabRefresh?: () => void;
-}
-/**
- * Create a navigation store for managing browser-side navigation state
- *
- * The store manages two types of state:
- * - NavigationState: Public state exposed via useNavigation hook
- * - SegmentState: Internal segment management for partial RSC updates
- *
- * @param config - Initial configuration
- * @returns NavigationStore instance
- *
- * @example
- * ```typescript
- * const store = createNavigationStore({
- *   initialLocation: window.location,
- *   initialSegmentIds: [],
- * });
- *
- * // Subscribe to state changes (for useNavigation hook)
- * const unsubscribe = store.subscribe(() => {
- *   const state = store.getState();
- *   console.log('Navigation state:', state);
- * });
- *
- * // Update state
- * store.setState({ state: 'loading' });
- *
- * // Subscribe to UI updates (for re-rendering)
- * store.onUpdate((update) => {
- *   console.log('New root:', update.root);
- * });
- * ```
- */
-export declare function createNavigationStore(config?: NavigationStoreConfig): NavigationStore;

package/dist/types.backup/browser/navigation-transaction.d.ts

@@ -1,75 +0,0 @@
-import type { NavigateOptions, NavigationStore, ResolvedSegment, StreamingToken } from "./types.js";
-import type { EventController, NavigationHandle } from "./event-controller.js";
-export { resolveNavigationState } from "./history-state.js";
-/**
- * Options for committing a navigation transaction
- */
-interface CommitOptions {
-    url: string;
-    segmentIds: string[];
-    segments: ResolvedSegment[];
-    replace?: boolean;
-    scroll?: boolean;
-    /** User-provided state to store in history.state */
-    state?: unknown;
-    /** If true, only update store without changing URL/history (for server actions) */
-    storeOnly?: boolean;
-    /** If true, this is an intercept route - store in history.state for popstate handling */
-    intercept?: boolean;
-    /** Source URL where the intercept was triggered from (stored in history.state) */
-    interceptSourceUrl?: string;
-    /** If true, only update cache without touching store or history (for background stale revalidation) */
-    cacheOnly?: boolean;
-    /** Server-set location state to merge into history.pushState */
-    serverState?: Record<string, unknown>;
-}
-/**
- * Options that can override the pre-configured commit settings
- */
-interface BoundCommitOverrides {
-    /** Override scroll behavior (e.g., disable for intercepts) */
-    scroll?: boolean;
-    /** Override replace behavior (e.g., force replace for intercepts) */
-    replace?: boolean;
-    /** Override user-provided state */
-    state?: unknown;
-    /** Mark this as an intercept route */
-    intercept?: boolean;
-    /** Source URL where intercept was triggered from */
-    interceptSourceUrl?: string;
-    /** If true, only update cache (for stale revalidation) */
-    cacheOnly?: boolean;
-    /** Server-set location state to merge into history.pushState */
-    serverState?: Record<string, unknown>;
-}
-/**
- * Bound transaction with pre-configured commit options (without segmentIds/segments)
- */
-export interface BoundTransaction {
-    readonly currentUrl: string;
-    /** Start streaming and get a token to end it when the stream completes */
-    startStreaming(): StreamingToken;
-    /** Commit the navigation. Returns the effective scroll option for the caller to handle. */
-    commit(segmentIds: string[], segments: ResolvedSegment[], overrides?: BoundCommitOverrides): {
-        scroll?: boolean;
-    };
-}
-/**
- * Navigation transaction for managing state during navigation
- * Uses the event controller handle for lifecycle management
- */
-interface NavigationTransaction extends Disposable {
-    commit(options: CommitOptions): {
-        scroll?: boolean;
-    };
-    with(options: Omit<CommitOptions, "segmentIds" | "segments">): BoundTransaction;
-    /** The navigation handle from the event controller */
-    handle: NavigationHandle;
-}
-/**
- * Creates a navigation transaction that coordinates with the event controller.
- * Handles loading state transitions and cleanup on completion/abort.
- */
-export declare function createNavigationTransaction(store: NavigationStore, eventController: EventController, url: string, options?: NavigateOptions & {
-    skipLoadingState?: boolean;
-}): NavigationTransaction;

package/dist/types.backup/browser/network-error-handler.d.ts

@@ -1,35 +0,0 @@
-import { NetworkError } from "../errors.js";
-import type { UpdateSubscriber } from "./types.js";
-/**
- * Convert an unknown error to a NetworkError, or return null if not network-related.
- *
- * Pure function: extracts the "is this a network error?" decision from
- * navigation-bridge and server-action-bridge so it can be unit tested.
- */
-export declare function toNetworkError(error: unknown, context: {
-    url: string;
-    operation: "action" | "navigation" | "revalidation";
-}): NetworkError | null;
-/**
- * Emit a NetworkError to the nearest error boundary (offline, failed fetch).
- */
-export declare function emitNetworkError(onUpdate: UpdateSubscriber, error: NetworkError, pathname: string): void;
-/**
- * Emit a navigation processing error to the nearest error boundary. Used when a
- * navigation response cannot be processed (an undecodable Flight body, or any
- * unanticipated failure while building the response) -- for both fresh and
- * prefetched responses, since both funnel through the navigation catch. Without
- * this, such a failure becomes an uncaught rejection that silently aborts the
- * navigation instead of surfacing the route's error boundary.
- */
-export declare function emitNavigationError(onUpdate: UpdateSubscriber, error: unknown, pathname: string): void;
-/**
- * Check if an error is safe to suppress in background operations.
- *
- * Background revalidation (SWR, navigated-away refetch) should silently
- * swallow AbortErrors and network errors since the user has already moved
- * on and showing an error would be disruptive.
- *
- * Pure function, easily unit tested.
- */
-export declare function isBackgroundSuppressible(error: unknown): boolean;

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

@@ -1,61 +0,0 @@
-import type { NavigationStore, NavigationClient, UpdateSubscriber, ResolvedSegment } from "./types.js";
-import type { ReactNode } from "react";
-import type { RenderSegmentsOptions } from "../segment-system.js";
-import type { BoundTransaction } from "./navigation-transaction.js";
-/**
- * Configuration for creating a partial updater
- */
-export interface PartialUpdateConfig {
-    store: NavigationStore;
-    client: NavigationClient;
-    onUpdate: UpdateSubscriber;
-    renderSegments: (segments: ResolvedSegment[], options?: RenderSegmentsOptions) => Promise<ReactNode> | ReactNode;
-    /** RSC version getter — returns the current version (may change after HMR) */
-    getVersion?: () => string | undefined;
-}
-/**
- * Options that can override the pre-configured commit settings
- */
-export interface CommitOverrides {
-    /** Override scroll behavior (e.g., disable for intercepts) */
-    scroll?: boolean;
-    /** Override replace behavior (e.g., force replace for intercepts) */
-    replace?: boolean;
-    /** Mark this as an intercept route */
-    intercept?: boolean;
-    /** Source URL where intercept was triggered from */
-    interceptSourceUrl?: string;
-    /** Server-set location state to merge into history.pushState */
-    serverState?: Record<string, unknown>;
-}
-/**
- * Discriminated update mode for partial updates.
- */
-export type UpdateMode = {
-    type: "navigate";
-    /** Cached segments for the target URL. When provided, these are used to build
-     * the segment map instead of the current page's segments. This ensures consistency
-     * when we send cached segment IDs to the server - if the server returns empty diff,
-     * we use the same segments we told the server we have. */
-    targetCacheSegments?: ResolvedSegment[];
-    /** Cached handle data for the target URL. When server returns empty diff and we're
-     * rendering from cache, this is passed to the UI to restore breadcrumbs etc. */
-    targetCacheHandleData?: Record<string, Record<string, unknown[]>>;
-    /** Source URL for intercept restore (popstate cache miss) */
-    interceptSourceUrl?: string;
-} | {
-    type: "leave-intercept";
-    interceptSourceUrl?: string;
-} | {
-    type: "stale-revalidation";
-    interceptSourceUrl?: string;
-} | {
-    type: "action";
-    interceptSourceUrl?: string;
-};
-/**
- * Type for the fetchPartialUpdate function
- */
-export type PartialUpdater = (targetUrl: string, segmentIds: string[] | undefined, isRetry: boolean, signal: AbortSignal | undefined, tx: BoundTransaction, mode?: UpdateMode) => Promise<void>;
-export declare function createPartialUpdater(config: PartialUpdateConfig): PartialUpdater;
-export { createPartialUpdater as default };

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

@@ -1,183 +0,0 @@
-/**
- * Prefetch Cache
- *
- * In-memory cache storing eagerly-decoded prefetch payloads for instant,
- * already-warm cache hits on subsequent navigation. A prefetch fetches the
- * RSC partial AND decodes it (createFromFetch) up front — decoding the Flight
- * stream resolves the route's client references, so the route's JS chunks are
- * imported during prefetch rather than on click. The decoded payload is reused
- * verbatim by navigation, so a prefetched click loads no new code. Two key
- * scopes are in play:
- * - Wildcard (default): built by `buildPrefetchKey(rangoState, target)` —
- *   shape `rangoState\0/target?...`. Shared across all source pages and
- *   invalidated automatically when Rango state bumps (deploy or
- *   server-action invalidation).
- * - Source-scoped: built by `buildSourceKey(rangoState, sourceHref, target)`
- *   — shape `rangoState\0sourceHref\0/target?...`. Embeds the Rango state
- *   (so rotation invalidates source-scoped entries too) plus the source
- *   href (so each originating page gets its own slot). Populated when the
- *   server tags a response with `X-RSC-Prefetch-Scope: source` (intercept
- *   modals etc.), OR when a Link opts in with `prefetchKey=":source"` — in
- *   both cases so source-sensitive responses cannot bleed into navigations
- *   from other pages.
- *
- * Also tracks in-flight prefetch promises. Each promise resolves to the
- * decoded prefetch entry (or null), letting navigation adopt a
- * still-downloading prefetch without issuing a duplicate request. A
- * single promise can be registered under multiple alias keys (see
- * `setInflightPromiseWithAliases`) so same-source navigations adopt via
- * their source key while cross-source ones fall through to the wildcard
- * alias — with consume/clear atomically removing every alias.
- *
- * Replaces the previous browser HTTP cache approach which was unreliable
- * due to response draining race conditions and browser inconsistencies.
- *
- * State here lives in module-level singletons (cache, inflight, generation,
- * cacheTTL, etc.) rather than a per-instance factory. This is correct because
- * exactly one router is live per document — an SPA navigation crossing a
- * host-router boundary forces a full document reload — so the singletons are
- * effectively per-document. Unit tests reset them via clearPrefetchCache().
- */
-import type { RscPayload } from "../types.js";
-/**
- * A prefetch that has been fetched AND eagerly decoded. Storing the decoded
- * payload (not the raw Response) is what makes a prefetched navigation "warm":
- * decoding the Flight stream during prefetch pulls the route's client chunks,
- * so the click reuses ready elements and loads no new JS.
- */
-export interface DecodedPrefetch {
-    /** The eagerly-decoded RSC payload. Reused verbatim by navigation. */
-    payload: Promise<RscPayload>;
-    /**
-     * Resolves when the underlying RSC stream finishes draining. Navigation
-     * forwards this as its streamComplete so scroll/revalidation gating is
-     * unchanged from the fresh-fetch path.
-     */
-    streamComplete: Promise<void>;
-    /**
-     * Prefetch scope as tagged by the server via `X-RSC-Prefetch-Scope`.
-     * `"source"` means the response is source-page-sensitive and must not be
-     * reused by a navigation from a different page — navigation enforces this
-     * when it adopted an inflight entry through the wildcard key.
-     */
-    scope: "source" | "wildcard";
-    /**
-     * Synchronously-readable flag, flipped to true when `streamComplete` resolves
-     * (the entire RSC stream has drained). Navigation reads this at click time to
-     * tell a FULLY warmed prefetch (payload commits without suspending → safe to
-     * commit in a startTransition, no fallback flash) from a partially-warmed one
-     * (still streaming → stream its fallbacks like a cold load). Starts false.
-     */
-    complete: boolean;
-}
-/**
- * Initialize the prefetch cache with the configured TTL and max size.
- * Called once at app startup with the values from server metadata. Each
- * argument is applied only when provided, so a caller can set just the TTL.
- * A TTL of 0 disables the in-memory cache and all prefetching. A size below 1
- * is ignored (the default is kept) — disabling prefetch is the TTL's job.
- */
-export declare function initPrefetchCache(ttlMs?: number, maxSize?: number): void;
-/**
- * Check if the prefetch cache is disabled (TTL <= 0).
- * When disabled, no prefetch requests should be issued.
- */
-export declare function isPrefetchCacheDisabled(): boolean;
-/**
- * Build a cache key by combining a scope prefix with the target URL.
- *
- * Low-level primitive — callers that want a specific scope should use
- * one of:
- * - Wildcard (source-agnostic): prefix is the Rango state value from
- *   `getRangoState()`. Shared across all source pages. Invalidated
- *   automatically when Rango state bumps (deploy or server-action).
- *   Key shape: `rangoState\0/target?...`.
- * - Source-scoped: use `buildSourceKey()`. Key shape:
- *   `rangoState\0sourceHref\0/target?...` — embeds the Rango state so
- *   rotation invalidates source-scoped entries alongside wildcard ones,
- *   plus the source page href so the key is unique per originating page.
- *   Populated either when the server tags a response with
- *   `X-RSC-Prefetch-Scope: source` (intercept modals, etc.) or when a
- *   Link opts in via `prefetchKey=":source"`.
- *
- * The `_rsc_segments` query param that travels in the target URL means
- * clients with different mounted segment trees naturally get different
- * keys — so segment-level diffs remain consistent across both scopes.
- */
-export declare function buildPrefetchKey(prefix: string, targetUrl: URL): string;
-/**
- * Build a source-scoped cache key. Key shape:
- * `rangoState\0sourceHref\0/target?...`.
- *
- * - `rangoState` is included so state rotation invalidates source-scoped
- *   entries alongside wildcard ones.
- * - `sourceHref` makes the key unique per originating page.
- */
-export declare function buildSourceKey(rangoState: string, sourceHref: string, targetUrl: URL): string;
-/**
- * Check if a prefetch is already cached, in-flight, or queued for the given key.
- */
-export declare function hasPrefetch(key: string): boolean;
-/**
- * Consume a cached, eagerly-decoded prefetch. Returns null if not found or
- * expired. One-time consumption: the entry is deleted after retrieval.
- * Returns null when caching is disabled (TTL <= 0).
- *
- * Does NOT check in-flight prefetches — use consumeInflightPrefetch()
- * for that (returns a Promise instead of a resolved entry).
- */
-export declare function consumePrefetch(key: string): DecodedPrefetch | null;
-/**
- * Consume an in-flight prefetch promise. Returns null if no prefetch is
- * in-flight for this key. The returned Promise resolves to the decoded
- * prefetch entry (or null if the fetch failed/was aborted, or carried a
- * control header the navigation must re-fetch to honor).
- *
- * One-time consumption: the promise entry is removed (along with any
- * sibling aliases registered via `setInflightPromiseWithAliases`) so a
- * second call on any alias returns null — only one caller can adopt the
- * shared Response stream. The `inflight` set entry is intentionally
- * kept so that `hasPrefetch()` continues to return true while the
- * underlying fetch is still downloading — this prevents
- * `prefetchDirect()` or other callers from starting a duplicate request
- * during the handoff window. The inflight flag is cleaned up naturally
- * by `clearPrefetchInflight()` in the fetch's `.finally()`.
- */
-export declare function consumeInflightPrefetch(key: string): Promise<DecodedPrefetch | null> | null;
-/**
- * Store an eagerly-decoded prefetch in the in-memory cache.
- *
- * Skips storage if the generation has changed since the fetch started
- * (a server action invalidated the cache mid-flight).
- */
-export declare function storePrefetch(key: string, entry: DecodedPrefetch, fetchGeneration: number): void;
-/**
- * Remove a single stored prefetch entry. Used to evict an entry whose body
- * stream stalled after headers arrived (its payload / streamComplete never
- * settle), so future prefetches and navigation refetch instead of dedupe-ing
- * against — and awaiting — a stuck entry.
- *
- * Identity-guarded: only evicts when the entry CURRENTLY stored under `key` is
- * the exact `entry` we published. A generation check alone is insufficient —
- * after this entry is consumed (consumePrefetch) and a fresh prefetch
- * republishes under the SAME key in the SAME generation, a gen-only guard would
- * delete that valid newer entry. Reference identity drops only our own stalled
- * entry.
- */
-export declare function removePrefetch(key: string, entry: DecodedPrefetch): void;
-/**
- * Capture the current generation. The returned value is passed to
- * storePrefetch so it can detect stale completions.
- */
-export declare function currentGeneration(): number;
-export declare function markPrefetchInflight(key: string): void;
-export declare function setInflightPromise(key: string, promise: Promise<DecodedPrefetch | null>): void;
-/**
- * Store the same in-flight Promise under multiple keys, recording them
- * as sibling aliases. Consuming or clearing any one alias atomically
- * removes every entry, guaranteeing the shared Response stream has a
- * single consumer even when navigation looks up either key.
- */
-export declare function setInflightPromiseWithAliases(keys: string[], promise: Promise<DecodedPrefetch | null>): void;
-export declare function clearPrefetchInflight(key: string): void;
-export declare function clearPrefetchCache(): void;