@rangojs/router 0.5.1 → 0.6.0

package/dist/types.backup/browser/react/location-state-shared.d.ts

@@ -1,162 +0,0 @@
-import type { ReactElement } from "react";
-/**
- * Internal entry representing a state value with its unique key.
- * When __rsc_ls_lazy is true, __rsc_ls_value holds a getter function
- * that is called at navigation time (not at entry creation time).
- */
-export interface LocationStateEntry {
-    readonly __rsc_ls_key: string;
-    readonly __rsc_ls_value: unknown;
-    readonly __rsc_ls_lazy?: boolean;
-}
-/**
- * Options for createLocationState
- */
-export interface LocationStateOptions {
-    /** When true, the state is cleared from history after first read (flash message pattern) */
-    flash?: boolean;
-}
-type LocationStateUnsafeFn = (...args: never[]) => unknown;
-type LocationStateUnsafeCtor = abstract new (...args: never[]) => unknown;
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type IsUnknown<T> = IsAny<T> extends true ? false : unknown extends T ? true : false;
-/**
- * Branded error surfaced when a value that cannot live in location state is
- * used. Location state is written into `history.state`, which uses the
- * structured clone algorithm; React elements, functions, and symbols throw a
- * `DataCloneError` at runtime. Carries a human-readable reason so the compile
- * error explains the fix.
- */
-export type LocationStateUnsafe<Reason extends string> = {
-    readonly __rango_location_state_unsafe: Reason;
-};
-/**
- * Maps `T` to itself when it is safe to store in location state, or to a branded
- * {@link LocationStateUnsafe} error for the disallowed parts: `unknown`, React
- * elements (RSC/JSX content), functions, class constructors, and symbols.
- * Recurses through arrays, `Map`, `Set`, and plain objects; structured-clone
- * built-ins (`Date`, `RegExp`, typed arrays, `Blob`, `File`, `FormData`) pass
- * through. Consumed by {@link ValidateLocationState}, which is intersected into a
- * definition's value parameter so posting RSC content is a COMPILE error, not a
- * runtime `DataCloneError`. (`any` is unguardable and remains an escape hatch.)
- */
-export type LocationStateSafe<T> = IsUnknown<T> extends true ? LocationStateUnsafe<"location state needs an explicit, concrete type; `unknown` cannot be verified as serializable"> : T extends LocationStateUnsafeFn ? LocationStateUnsafe<"functions cannot be stored in location state"> : T extends LocationStateUnsafeCtor ? LocationStateUnsafe<"class constructors cannot be stored in location state"> : T extends symbol ? LocationStateUnsafe<"symbols cannot be stored in location state"> : T extends ReactElement ? LocationStateUnsafe<"React/RSC content cannot be stored in location state; store plain data and render it on arrival"> : T extends string | number | boolean | bigint | null | undefined ? T : T extends Date | RegExp | ArrayBuffer | ArrayBufferView | Blob | File | FormData ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<LocationStateSafe<K>, LocationStateSafe<V>> : T extends ReadonlySet<infer V> ? ReadonlySet<LocationStateSafe<V>> : T extends readonly unknown[] ? {
-    [K in keyof T]: LocationStateSafe<T[K]>;
-} : T extends object ? {
-    [K in keyof T]: LocationStateSafe<T[K]>;
-} : T;
-/**
- * `unknown` (a no-op) when `T` is safe to store in location state, otherwise a
- * branded {@link LocationStateUnsafe} object. Intersected into the value
- * parameter of a definition's call and `write()` so POSTING RSC content (or any
- * non-serializable value) is a compile error whose text carries the reason —
- * without a `TState extends ...` self-constraint, which TypeScript rejects as
- * circular (TS2313). For safe `T`, `value & unknown` collapses back to `value`,
- * so valid usage is unchanged.
- */
-export type ValidateLocationState<T> = [T] extends [LocationStateSafe<T>] ? unknown : LocationStateUnsafe<"location state must be serializable: React/RSC content, functions, and symbols cannot be stored — pass plain data and render it on arrival">;
-/**
- * Type-safe location state definition
- *
- * Created via createLocationState(), used with Link's state prop
- * and useLocationState() hook.
- */
-export interface LocationStateDefinition<TArgs extends unknown[], TState> {
-    (...args: TArgs): LocationStateEntry;
-    /** Injected by Vite plugin - do not set manually */
-    __rsc_ls_key: string;
-    /** Whether this state auto-clears after first read */
-    readonly __rsc_ls_flash: boolean;
-    /**
-     * Read the current value from history.state.
-     *
-     * Returns undefined during SSR (no `window`). To stay hydration-safe, do
-     * NOT call read() inline during the initial render — the server returns
-     * undefined while the client may have a value preserved in history.state
-     * (e.g. after a hard reload of an entry that earlier called write()),
-     * which causes a hydration mismatch. Call read() inside an event handler
-     * or a useEffect post-mount instead, or use useLocationState() if you
-     * want React to manage subscription/hydration for you.
-     */
-    read(): TState | undefined;
-    /**
-     * Statically write the value into the current history entry under this
-     * definition's key, preserving any other keys already on history.state
-     * (e.g. router bookkeeping, other LocationState slots).
-     *
-     * This is the non-reactive counterpart to read(): it does not dispatch any
-     * event, so components reading via useLocationState() will NOT re-render
-     * until the next navigation/popstate. Use it when you only need the value
-     * to be there on the next read() or on the next mount (including after
-     * back/forward and hard refresh of the same entry).
-     *
-     * Client-only: throws when called on the server (no history available).
-     */
-    write(value: TState & ValidateLocationState<TState>): void;
-    /**
-     * Statically remove this definition's slot from the current history entry,
-     * leaving any other keys on history.state untouched. Idempotent: removing
-     * a slot that isn't present is a no-op.
-     *
-     * Same non-reactive semantics as write(): no event is dispatched, so
-     * useLocationState() readers will NOT re-render until the next navigation.
-     *
-     * Client-only: throws when called on the server (no history available).
-     */
-    delete(): void;
-}
-/**
- * Create a type-safe location state definition
- *
- * The key is auto-injected by the Vite exposeInternalIds plugin as a property
- * based on file path and export name. No manual key required.
- *
- * @param options Optional configuration
- * @returns A typed state definition for use with Link and useLocationState
- *
- * @example
- * ```typescript
- * // Persistent state (survives back/forward)
- * export const ProductState = createLocationState<{ name: string; price: number }>();
- *
- * // Flash state (cleared after first read)
- * export const FlashMessage = createLocationState<{ text: string }>({ flash: true });
- *
- * // Use in Link
- * <Link to="/product/123" state={[ProductState({ name: "Widget", price: 9.99 })]}>
- *
- * // Just-in-time typed state (getter called at click time, not render time).
- * // Must be in a client component — the getter function can't cross the RSC boundary.
- * <Link
- *   to="/product/123"
- *   state={[ProductState(() => ({ name: product.name, price: product.price }))]}
- * >
- *
- * // Read with hook (reactive)
- * const product = useLocationState(ProductState);
- *
- * // Read without hook (snapshot, client-side only)
- * const snap = ProductState.read();
- *
- * // Static write to current history entry (non-reactive, client-side only).
- * // Survives back/forward and hard refresh; useLocationState() readers will
- * // NOT see the new value until the next navigation. Pair with .read() or a
- * // fresh mount.
- * ProductState.write({ name: "Widget", price: 9.99 });
- *
- * // Manually clear the slot (non-reactive, client-side only).
- * ProductState.delete();
- * ```
- */
-export declare function createLocationState<TState>(options?: LocationStateOptions): LocationStateDefinition<[
-    (TState | (() => TState)) & ValidateLocationState<TState>
-], TState>;
-/**
- * Check if a value is a LocationStateEntry
- */
-export declare function isLocationStateEntry(value: unknown): value is LocationStateEntry;
-/**
- * Resolve state entries into a flat object for history.state
- */
-export declare function resolveLocationStateEntries(entries: LocationStateEntry[]): Record<string, unknown>;
-export {};

package/dist/types.backup/browser/react/location-state.d.ts

@@ -1,29 +0,0 @@
-import type { LocationStateDefinition } from "./location-state-shared.js";
-export { createLocationState, isLocationStateEntry, resolveLocationStateEntries, type LocationStateEntry, type LocationStateDefinition, type LocationStateOptions, } from "./location-state-shared.js";
-/**
- * Hook to read location state from history.state
- *
- * Behavior depends on the definition:
- * - Normal state: persists across navigations, reactive to popstate
- * - Flash state (created with { flash: true }): read once, cleared after paint
- *
- * Overloaded:
- * - With definition: Returns typed state from the specific key
- * - With type param only: Returns plain state from history.state.state
- *
- * @example
- * ```typescript
- * // Persistent state
- * const ProductState = createLocationState<{ name: string }>();
- * const state = useLocationState(ProductState);
- *
- * // Flash state (auto-clears after paint)
- * const FlashMsg = createLocationState<{ text: string }>({ flash: true });
- * const flash = useLocationState(FlashMsg);
- *
- * // Plain state access (reads from history.state.state)
- * const state = useLocationState<{ from?: string }>();
- * ```
- */
-export declare function useLocationState<TArgs extends unknown[], TState>(definition: LocationStateDefinition<TArgs, TState>): TState | undefined;
-export declare function useLocationState<T = unknown>(): T | undefined;

package/dist/types.backup/browser/react/mount-context.d.ts

@@ -1,23 +0,0 @@
-import { type Context, type ReactNode } from "react";
-/**
- * Context for the current include() mount path.
- *
- * Each include() wraps its subtree with a MountContext.Provider
- * carrying the URL prefix. Nested includes override the context,
- * so useMount() returns the nearest mount path.
- *
- * Default value "/" means root-level (no include wrapping).
- */
-export declare const MountContext: Context<string>;
-/**
- * Provider wrapper for MountContext.
- *
- * RSC server components cannot use MountContext.Provider directly because
- * .Provider is a property on the context object, not a named export.
- * Client reference proxies on the RSC server return undefined for property
- * access. This wrapper is a proper "use client" export that RSC can reference.
- */
-export declare function MountContextProvider({ value, children, }: {
-    value: string;
-    children: ReactNode;
-}): ReactNode;

package/dist/types.backup/browser/react/nonce-context.d.ts

@@ -1,14 +0,0 @@
-/**
- * Context for CSP nonce propagation to client components during SSR.
- *
- * The SSR renderer wraps the tree with NonceContext.Provider so that
- * client components (e.g. MetaTags) can apply nonces to inline scripts.
- * On the browser side, no provider is needed — the default undefined
- * is correct since CSP nonces are a server-side HTML concern.
- */
-import { type Context } from "react";
-export declare const NonceContext: Context<string | undefined>;
-/**
- * Read the CSP nonce during SSR. Returns undefined on the client.
- */
-export declare function useNonce(): string | undefined;

package/dist/types.backup/browser/react/shallow-equal.d.ts

@@ -1,5 +0,0 @@
-/**
- * Shallow equality check for selector results.
- * Uses Object.is for value comparison (handles NaN and +-0 correctly).
- */
-export declare function shallowEqual<T>(a: T, b: T): boolean;

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

@@ -1,61 +0,0 @@
-import type { TrackedActionState } from "../types.js";
-/**
- * Server action function type
- * Server actions have a $$id property added by the RSC compiler
- */
-export type ServerActionFunction = ((...args: any[]) => Promise<any>) & {
-    $$id?: string;
-};
-/**
- * Hook to track the lifecycle of a specific server action
- *
- * Unlike useNavigation which tracks global navigation state, useAction
- * tracks the state of individual server action invocations.
- *
- * Uses the event controller for reactive state management.
- * State is derived from the inflight actions tracked by the controller.
- *
- * Features:
- * - Tracks action lifecycle: idle → loading → streaming → idle
- * - Captures result/error locally (React handles cleanup)
- * - If multiple actions fire, tracks only the last one
- * - 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.
- *
- * @param action - Either a server action function or a string action name.
- *   - **Function**: Must be directly imported in the client component.
- *     Actions passed as props from server components will throw an error.
- *   - **String**: The exported function name from your "use server" file.
- *     Matches any action ending with "#actionName" (suffix match).
- *
- * @example
- * ```tsx
- * // Option 1: Direct import (precise matching)
- * import { addToCart } from './actions';
- * const actionState = useAction(addToCart);
- *
- * // Option 2: String-based (suffix matching)
- * // Matches "hash#addToCart" or "src/actions.ts#addToCart"
- * const actionState = useAction('addToCart');
- *
- * // With selector for specific values
- * const isLoading = useAction(addToCart, state => state.state === 'loading');
- * const error = useAction(addToCart, state => state.error);
- * ```
- *
- * @note The selector is expected to be stable for a given hook instance.
- * This hook tracks one projection of one action. Changing selector semantics
- * for the same action ID without a new action event is not a supported pattern;
- * use separate useAction() subscriptions if you need different projections.
- *
- * @note Actions passed as props from server components lose their metadata
- * during RSC serialization. Use a string action name or import directly.
- */
-export declare function useAction(action: ServerActionFunction | string): TrackedActionState;
-export declare function useAction<T>(action: ServerActionFunction | string, selector: (state: TrackedActionState) => T): T;
-export type { TrackedActionState };

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

@@ -1,21 +0,0 @@
-import type { Handle } from "../../handle.js";
-/**
- * Hook to access collected handle data.
- *
- * Returns the collected value from all route segments that pushed to this handle.
- * Re-renders when handle data changes (navigation, actions).
- *
- * @param handle - The handle to read
- * @param selector - Optional selector for performance (only re-render when selected value changes)
- *
- * @example
- * ```tsx
- * // Get all breadcrumbs
- * const breadcrumbs = useHandle(Breadcrumbs);
- *
- * // With selector - only re-render when last crumb changes
- * const lastCrumb = useHandle(Breadcrumbs, (data) => data.at(-1));
- * ```
- */
-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;

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

@@ -1,32 +0,0 @@
-/**
- * Client-side hook for mount-aware URL resolution.
- *
- * Returns an href function that automatically prepends the current
- * include() mount prefix. Inside an include("/shop", ...) scope,
- * the returned function resolves local paths relative to /shop.
- *
- * For absolute paths (outside the current mount), use the bare
- * href() function directly instead.
- *
- * @returns A function that prepends the mount prefix to paths
- *
- * @example
- * ```tsx
- * "use client";
- * import { useHref, href } from "@rangojs/router/client";
- *
- * // Inside include("/shop", shopPatterns)
- * function ShopNav() {
- *   const href = useHref();
- *
- *   return (
- *     <>
- *       {// Local paths - auto-prefixed with /shop}
- *       <Link to={href("/cart")}>Cart</Link>
- *       <Link to={href("/product/widget")}>Widget</Link>
- *     </>
- *   );
- * }
- * ```
- */
-export declare function useHref(): (path: `/${string}`) => string;

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

@@ -1,36 +0,0 @@
-import { type Context } from "react";
-/**
- * Context for Link component to provide its destination URL
- * Used by useLinkStatus to determine if this specific link is pending
- */
-export declare const LinkContext: Context<string | null>;
-/**
- * Link status returned by useLinkStatus hook
- */
-export interface LinkStatus {
-    /** Whether navigation to this link's destination is in progress */
-    pending: boolean;
-}
-/**
- * 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.
- *
- * Useful for showing inline loading indicators on individual links.
- *
- * @example
- * ```tsx
- * function LoadingIndicator() {
- *   const { pending } = useLinkStatus();
- *   return pending ? <Spinner /> : null;
- * }
- *
- * // In your component:
- * <Link to="/dashboard">
- *   Dashboard
- *   <LoadingIndicator />
- * </Link>
- * ```
- */
-export declare function useLinkStatus(): LinkStatus;

package/dist/types.backup/browser/react/use-mount.d.ts

@@ -1,24 +0,0 @@
-/**
- * Returns the current include() mount path.
- *
- * Inside `include("/articles", blogPatterns)`, returns "/articles".
- * For nested includes, returns the nearest mount path.
- * At root level (no include), returns "/".
- *
- * @example
- * ```tsx
- * "use client";
- * import { useMount, href } from "@rangojs/router/client";
- *
- * function BlogNav({ slug }: { slug: string }) {
- *   const mount = useMount(); // "/articles"
- *   return (
- *     <>
- *       <Link to={href("/", mount)}>Blog Home</Link>
- *       <Link to={href(`/${slug}`, mount)}>Post</Link>
- *     </>
- *   );
- * }
- * ```
- */
-export declare function useMount(): string;

package/dist/types.backup/browser/react/use-navigation.d.ts

@@ -1,15 +0,0 @@
-import type { PublicNavigationState } from "../types.js";
-/**
- * Hook to access reactive navigation state with optional selector for performance.
- *
- * Returns state only. For actions (push, replace, refresh, prefetch),
- * use useRouter() instead.
- *
- * @example
- * ```tsx
- * const { state, location } = useNavigation();
- * const isLoading = useNavigation(nav => nav.state === 'loading');
- * ```
- */
-export declare function useNavigation(): PublicNavigationState;
-export declare function useNavigation<T>(selector: (state: PublicNavigationState) => T): T;

package/dist/types.backup/browser/react/use-params.d.ts

@@ -1,21 +0,0 @@
-/**
- * Hook to access the current route params.
- *
- * Returns the merged route params from the matched route.
- * Updates when navigation completes, not during pending navigation.
- *
- * @example
- * ```tsx
- * // Route: /products/:productId
- * const params = useParams();
- * // { productId: "123" }
- *
- * // Annotate the expected shape via a generic
- * const { productId } = useParams<{ productId: string }>();
- *
- * // With selector
- * const productId = useParams(p => p.productId);
- * ```
- */
-export declare function useParams<T extends object = Record<string, string | undefined>>(): Readonly<T>;
-export declare function useParams<T>(selector: (params: Record<string, string | undefined>) => T): T;

package/dist/types.backup/browser/react/use-pathname.d.ts

@@ -1,13 +0,0 @@
-/**
- * Hook to access the current pathname.
- *
- * Returns the committed pathname string (excludes search params and hash).
- * Updates when navigation completes, not during pending navigation.
- *
- * @example
- * ```tsx
- * const pathname = usePathname();
- * // "/products/123"
- * ```
- */
-export declare function usePathname(): string;

package/dist/types.backup/browser/react/use-reverse.d.ts

@@ -1,40 +0,0 @@
-import type { LocalReverseFunction } from "../../reverse.js";
-type RouteEntry = string | {
-    readonly path: string;
-};
-type LocalRouteMap = Readonly<Record<string, RouteEntry>>;
-/**
- * Mount-aware reverse function for a locally-imported `routes` map.
- *
- * The `routes` map you pass IS the scope: `reverse("name")` looks the name up
- * in that map (verbatim), prefixes the result with the surrounding `include()`
- * mount path via `useMount()`, and substitutes params — auto-filling from the
- * current matched route's params, with explicit params overriding. A module's
- * components can therefore reverse their own routes without knowing where the
- * module is mounted: include it under any prefix and the URLs resolve correctly.
- *
- * The leading dot is optional and cosmetic: `reverse("post")` and
- * `reverse(".post")` resolve identically. The dot exists only as a readability
- * convention and for parity with `ctx.reverse(".name")` on the server; here the
- * passed map is the scope, so there is no separate global namespace to
- * disambiguate and the dot carries no meaning.
- *
- * @example
- * ```tsx
- * "use client";
- * import { Link, useReverse } from "@rangojs/router/client";
- * import { routes as blogRoutes } from "../urls/blog.gen.js";
- *
- * function BlogNav() {
- *   const reverse = useReverse(blogRoutes);
- *   return (
- *     <>
- *       <Link to={reverse("index")}>Blog</Link>
- *       <Link to={reverse("post", { postId: "hello" })}>Post</Link>
- *     </>
- *   );
- * }
- * ```
- */
-export declare function useReverse<const TRoutes extends LocalRouteMap>(routes: TRoutes): LocalReverseFunction<TRoutes>;
-export {};

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

@@ -1,23 +0,0 @@
-import type { RouterInstance } from "../types.js";
-/**
- * Hook to access router actions (push, replace, refresh, prefetch, back, forward).
- *
- * Returns a STABLE reference that never changes, so components using
- * useRouter() do not re-render on navigation state changes.
- * For reactive navigation state, use useNavigation() instead.
- *
- * Methods read `basename` from the context on each call. It is set once from
- * the initial payload and is stable within a session — a cross-app navigation
- * is a full document load (X-RSC-Reload), so the target app mounts fresh with
- * its own basename.
- *
- * @example
- * ```tsx
- * const router = useRouter();
- * router.push("/products");
- * router.replace("/login", { scroll: false });
- * router.prefetch("/dashboard");
- * router.back();
- * ```
- */
-export declare function useRouter(): RouterInstance;

package/dist/types.backup/browser/react/use-search-params.d.ts

@@ -1,19 +0,0 @@
-import type { ReadonlyURLSearchParams } from "../types.js";
-/**
- * Hook to access the current URL search params.
- *
- * Returns a read-only URLSearchParams object from the committed location.
- * Updates when navigation completes, not during pending navigation.
- *
- * Note: During SSR the search params are not available (the server only sends
- * the pathname). The hook returns empty params during SSR and syncs from
- * the browser URL on mount.
- *
- * @example
- * ```tsx
- * const searchParams = useSearchParams();
- * const query = searchParams.get("q"); // "react"
- * const page = searchParams.get("page"); // "2"
- * ```
- */
-export declare function useSearchParams(): ReadonlyURLSearchParams;

package/dist/types.backup/browser/react/use-segments.d.ts

@@ -1,29 +0,0 @@
-/**
- * Segments state returned by useSegments hook
- */
-export interface SegmentsState {
-    /** URL path segments (e.g., /shop/products/123 → ["shop", "products", "123"]) */
-    path: readonly string[];
-    /** Matched segment IDs in order (layouts and routes only, e.g., ["L0", "L0L1", "L0L1R0"]) */
-    segmentIds: readonly string[];
-    /** Current URL location */
-    location: URL;
-}
-/**
- * Hook to access current route segments with optional selector for performance
- *
- * Provides information about the current URL path and matched route segments.
- * Uses the event controller for reactive state management.
- *
- * @example
- * ```tsx
- * // Get full segments state
- * const { path, segmentIds, location } = useSegments();
- *
- * // Use selector for specific values (better performance)
- * const path = useSegments(s => s.path);
- * const isShopRoute = useSegments(s => s.path[0] === "shop");
- * ```
- */
-export declare function useSegments(): SegmentsState;
-export declare function useSegments<T>(selector: (state: SegmentsState) => T): T;

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

@@ -1,58 +0,0 @@
-type HeaderResult = {
-    url: string;
-} | "blocked" | null;
-/**
- * Extract and validate an RSC response header URL (X-RSC-Reload, X-RSC-Redirect).
- * Returns { url } if valid, "blocked" if present but invalid origin, null if absent.
- */
-export declare function extractRscHeaderUrl(response: Response, header: string): HeaderResult;
-/**
- * Empty 200 response that won't choke Flight parsing.
- * Used when a header URL is blocked by origin validation.
- */
-export declare function emptyResponse(): Response;
-/**
- * Whether an RSC content response carries a server-stamped router identity
- * (`X-RSC-Router-Id`) that DIFFERS from the id this client expects (its own
- * routerId, also sent as `_rsc_rid`). Pre-decode integrity check: lets a caller
- * refuse a foreign app's payload before `createFromFetch` imports its chunks.
- *
- * True ONLY when both the header and the expected id are present and differ. An
- * absent header (control-only reload/redirect responses are not stamped) or an
- * absent expected id (e.g. before the client is seeded) is a pass-through —
- * never a false reject.
- */
-export declare function isForeignRouterId(response: Response, expectedId: string | undefined): boolean;
-/**
- * Handle the X-RSC-Reload control header (server requests a full page reload on
- * a version mismatch). Returns a short-circuit response when the header is
- * present -- emptyResponse() if the URL was blocked by origin validation, or a
- * never-resolving promise while the page reloads -- and null when absent, so
- * the caller continues processing (e.g. the X-RSC-Redirect check). Scoped to
- * X-RSC-Reload only; redirect handling differs between callers.
- */
-export declare function handleReloadHeader(response: Response, opts: {
-    onBlocked: () => void;
-    onReload: (url: string) => void;
-}): Response | Promise<Response> | null;
-/**
- * Tee a response body for RSC parsing and stream completion tracking.
- * Returns a new Response with one branch; the other is consumed to detect
- * 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.
- *
- * If the response has no body, onComplete fires synchronously with `true`
- * (an empty body is a clean, complete stream).
- * If signal is provided, an abort cancels the tracking reader.
- *
- * `silent` suppresses the stream-error log. Prefetch passes it: a speculative,
- * low-priority prefetch that is aborted or never consumed can error its stream
- * benignly, which is not worth surfacing. The fresh-navigation path keeps the
- * log (default), where a stream error reflects a real failed navigation.
- */
-export declare function teeWithCompletion(response: Response, onComplete: (endedCleanly: boolean) => void, signal?: AbortSignal, silent?: boolean): Response;
-export {};