@kitbag/router 0.25.0 → 0.26.1

package/dist/main.d.ts

@@ -35,8 +35,10 @@ export { LoaderDataAccessError } from './errors/loaderDataAccessError';
 export { LoaderNameConflict } from './errors/loaderNameConflict';
 export { MetaPropertyConflict } from './errors/metaPropertyConflict';
 export { NavigationAbandonedError } from './errors/navigationAbandonedError';
+export { PayloadValueError } from './errors/payloadValueError';
 export { RouterNotInstalledError } from './errors/routerNotInstalledError';
 export { UseRouteInvalidError } from './errors/useRouteInvalidError';
+export { SsrOptionRequiredError } from './errors/ssrOptionRequiredError';
 export { createRoute } from './services/createRoute';
 export { createRejection } from './services/createRejection';
 export { createExternalRoute } from './services/createExternalRoute';

package/dist/services/addLoader.d.ts

@@ -1,3 +1,4 @@
+import { AnyPayloadTransformer } from './payload';
 import { PrefetchConfig } from '../types/prefetch';
 import { CreatedRouteOptions, Route } from '../types/route';
 import { AnyFunction } from '../types/utilities';
@@ -9,6 +10,7 @@ export declare const DEFAULT_LOADER_NAME = "default";
 type LoaderOptions = {
     name?: string;
     prefetch?: PrefetchConfig;
+    transformer?: AnyPayloadTransformer;
 };
 /**
  * The runtime arguments accepted by `addLoader`.
@@ -23,6 +25,7 @@ type Loader = {
     name: string;
     load: AnyFunction;
     prefetch: PrefetchConfig | undefined;
+    transformer: AnyPayloadTransformer | undefined;
 };
 export declare function toLoader(load: AnyFunction, options: LoaderOptions | undefined): Loader;
 /**
@@ -31,7 +34,7 @@ export declare function toLoader(load: AnyFunction, options: LoaderOptions | und
  * Matches are `markRaw` so that making a route reactive does not turn its loaders into reactive proxies.
  * Spreading a match drops that, so the rebuilt one is marked again.
  */
-export declare function addLoaderToMatch(match: CreatedRouteOptions, { name, load, prefetch }: Loader): CreatedRouteOptions;
+export declare function addLoaderToMatch(match: CreatedRouteOptions, { name, load, prefetch, transformer }: Loader): CreatedRouteOptions;
 /**
  * A route's data combines the loaders of every match, so a name an ancestor already uses would be
  * ambiguous. Adding a loader the route itself already has is an override, and allowed.

package/dist/services/addView.d.ts

@@ -1,4 +1,5 @@
 import { Component } from 'vue';
+import { AnyPayloadTransformer } from './payload';
 import { PropsGetter } from '../types/createRouteOptions';
 import { PrefetchConfig } from '../types/prefetch';
 import { CreatedRouteOptions, Route } from '../types/route';
@@ -10,6 +11,7 @@ type ViewOptions = {
     name?: string;
     props?: PropsGetter;
     prefetch?: PrefetchConfig;
+    transformer?: AnyPayloadTransformer;
 };
 /**
  * The runtime arguments accepted by `addView`.
@@ -25,6 +27,7 @@ type View = {
     component: Component;
     props: PropsGetter | undefined;
     prefetch: PrefetchConfig | undefined;
+    transformer: AnyPayloadTransformer | undefined;
 };
 export declare function toView(component: Component, options: ViewOptions | undefined): View;
 /**
@@ -33,5 +36,5 @@ export declare function toView(component: Component, options: ViewOptions | unde
  * Matches are `markRaw` so that making a route reactive does not turn its components into reactive
  * proxies. Spreading a match drops that, so the rebuilt one is marked again.
  */
-export declare function addViewToMatch(match: CreatedRouteOptions, { name, component, props, prefetch }: View): CreatedRouteOptions;
+export declare function addViewToMatch(match: CreatedRouteOptions, { name, component, props, prefetch, transformer }: View): CreatedRouteOptions;
 export {};

package/dist/services/arktype.spec-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/arktype.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/createActivityTracker.d.ts

@@ -0,0 +1,6 @@
+export type ActivityTracker = {
+    add: (...work: Promise<unknown>[]) => void;
+    wrap: <TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>) => (...args: TArgs) => Promise<TResult>;
+    idle: () => Promise<void>;
+};
+export declare function createActivityTracker(): ActivityTracker;

package/dist/services/createActivityTracker.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/createCurrentRejection.d.ts

@@ -1,11 +1,8 @@
 import { Rejection, RouterRejection } from '../types/rejection';
-import { ComputedRef } from 'vue';
-import { ResolvedRoute } from '../types/resolved';
 type RejectionUpdate = (rejection: Rejection) => void;
 type RejectionClear = () => void;
 type CurrentRejectionContext = {
     currentRejection: RouterRejection;
-    currentRejectionRoute: ComputedRef<ResolvedRoute | null>;
     updateRejection: RejectionUpdate;
     clearRejection: RejectionClear;
 };

package/dist/services/createNavigationIds.d.ts

@@ -0,0 +1,6 @@
+export type NavigationIds = {
+    getNavigationId: () => string;
+    isCurrentNavigationId: (id: string) => boolean;
+    stopNavigationIds: () => void;
+};
+export declare function createNavigationIds(): NavigationIds;

package/dist/services/createNavigationIds.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/createNavigationStores.d.ts

@@ -3,9 +3,9 @@ import { ResolvedRoute } from '../types/resolved';
 /**
  * Which store the rendered route reads from, and which one the next navigation will adopt.
  *
- * A navigation gets its own store so the one it replaces can be disposed outright. A followed link stages
- * the store it prefetched into, which the navigation it triggers picks up — staged rather than handed over
- * directly because a link is followed before that navigation starts.
+ * A navigation gets its own store so the one it replaces can be disposed outright. A store built ahead of
+ * a navigation is staged for it to pick up — staged rather than handed over directly because it is built
+ * before that navigation starts.
  */
 export type NavigationStores = {
     /**
@@ -13,10 +13,15 @@ export type NavigationStores = {
      */
     current: () => DataStore;
     /**
-     * Parks a followed link's store for the navigation it triggered. A store already parked is disposed,
-     * since following a second link before the first navigation arrives abandons the first.
+     * Parks a store for the next navigation. A store already parked is disposed, since staging a second
+     * store before a navigation arrives abandons the first.
      */
     stage: (store: DataStore) => void;
+    /**
+     * The staged store, created when nothing was staged, so a navigation can compute into it ahead of
+     * adopting it.
+     */
+    staged: () => DataStore;
     /**
      * Swaps in the staged store, or a fresh one, and hands back the store being replaced for disposal.
      */

package/dist/services/createRejection.d.ts

@@ -1,8 +1,4 @@
 import { RejectionHooks } from '../types/hooks';
-import { Rejection } from '../types/rejection';
-import { Component } from 'vue';
+import { Rejection, RejectionOptions } from '../types/rejection';
 import { RouteSetTitle } from '../types/routeTitle';
-export declare function createRejection<TType extends string>(options: {
-    type: TType;
-    component?: Component;
-}): Rejection<TType> & RejectionHooks<TType> & RouteSetTitle;
+export declare function createRejection<TType extends string>(options: RejectionOptions<TType>): Rejection<TType> & RejectionHooks<TType> & RouteSetTitle;

package/dist/services/createRejection.spec-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/createRejection.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/createRouteHooks.d.ts

@@ -11,7 +11,7 @@ type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[]
     onAfterRouteEnter: AddAfterEnterHook<TRoutes, TRejections>;
     onAfterRouteUpdate: AddAfterUpdateHook<TRoutes, TRejections>;
     onAfterRouteLeave: AddAfterLeaveHook<TRoutes, TRejections>;
-    onError: AddErrorHook<TRoutes[number], TRoutes, TRejections>;
+    onError: AddErrorHook<TRoutes, TRejections>;
     onRejection: AddRejectionHook<ExtractRejectionTypes<TRejections>, TRoutes>;
     store: Hooks;
 };

package/dist/services/createRouteValueStore.d.ts

@@ -1,9 +1,10 @@
-import { PrefetchConfigs, PrefetchStrategy } from '../types/prefetch';
 import { ResolvedRoute, WithData } from '../types/resolved';
 import { HasVueAppStore } from './createVueAppStore';
 import { CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from '../types/callbackContext';
+import { DataKind } from './createNavigationStores';
 import { PropsResult } from '../utilities/props';
 import { MaybePromise } from '../types/utilities';
+import { ComputationFilter } from './getComputations';
 /**
  * A navigation that was superseded before its values settled. The navigation that replaced it owns the
  * outcome, so this one reports that it went nowhere rather than a success it never had.
@@ -21,30 +22,61 @@ export type RouteValueResponses = {
     loaders: Promise<RouteValueResponse>;
 };
 /**
- * A link's own bucket of prefetched values, handed to the current navigation when the link is followed and
- * discarded otherwise.
+ * A store of a route's values, whichever store that is.
  */
-export type PrefetchStore = {
+export type ValueStore = {
     /**
-     * Computes props for views whose prefetch option matches the given strategy.
+     * Computes the route's values, or only those the filter keeps, and reports how they settle.
      */
-    prefetch: (strategy: PrefetchStrategy, route: ResolvedRoute, configs: PrefetchConfigs) => void;
+    compute: (route: ResolvedRoute, filter?: ComputationFilter) => RouteValueResponses;
     /**
-     * Stages the prefetched store for the next navigation to adopt.
+     * Adopts values that already settled, in place of running their getters.
      */
-    commit: () => void;
+    fill: (route: ResolvedRoute, values: RouteValue[]) => void;
+};
+/**
+ * A store kept apart from the navigation until it is staged, so values can be computed ahead of a
+ * navigation that may never come.
+ */
+export type DetachedStore = ValueStore & {
     /**
-     * Abandons what was prefetched and starts over, for a link that now points somewhere else.
+     * Becomes the staged store, replacing whatever was staged, and starts over empty.
+     */
+    stage: () => void;
+    /**
+     * Abandons what was computed and starts over.
      */
     reset: () => void;
     /**
-     * Abandons what was prefetched, for a link that is gone.
+     * Abandons what was computed.
      */
     dispose: () => void;
 };
+/**
+ * A value the store holds for a route: which computation it belongs to, and what it resolved to.
+ */
+export type RouteValue = {
+    kind: DataKind;
+    depth: number;
+    name: string;
+    value: unknown;
+};
 export type RouteValueStore = HasVueAppStore & {
-    createPrefetchStore: () => PrefetchStore;
-    setRouteValues: (route: ResolvedRoute) => RouteValueResponses;
+    createDetachedStore: () => DetachedStore;
+    /**
+     * The store the next navigation adopts, created when nothing is staged. Values computed into it ahead of
+     * the navigation are found under way when the navigation commits, while the rendered route keeps reading
+     * its own store meanwhile.
+     */
+    staged: () => ValueStore;
+    /**
+     * Makes the staged store current and computes whatever the route still lacks.
+     */
+    commit: (route: ResolvedRoute) => RouteValueResponses;
+    /**
+     * The values currently settled in the store.
+     */
+    getValues: (route: ResolvedRoute) => RouteValue[];
     getProps: (id: string, name: string, route: ResolvedRoute) => MaybePromise<PropsResult>;
     /**
      * What a route exposes as `data`. Resolved per read rather than captured, so it stays correct as

package/dist/services/createRouteValueStore.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/createRouterCallbackContext.d.ts

@@ -17,6 +17,6 @@ type RouterCallbackContext<TRoutes extends Routes = Routes, TRejections extends
     abort: CallbackContextAbort;
 };
 export declare function createRouterCallbackContext<TRoutes extends Routes, TRejections extends Rejections>({ to }: {
-    to: ResolvedRoute;
+    to: ResolvedRoute | null;
 }): RouterCallbackContext<TRoutes, TRejections>;
 export {};

package/dist/services/createRouterHistory.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/createServerRedirect.d.ts

@@ -0,0 +1,14 @@
+import { RedirectStatus, RenderRedirect } from '../types/router';
+type ServerRedirect = {
+    /**
+     * Captures a redirect as the render's response. A server responds per redirect hop, so only the first
+     * is kept: the browser follows it, and the next request takes it from there.
+     */
+    setServerRedirect: (status: RedirectStatus, location: string) => void;
+    /**
+     * The redirect the render captured, or undefined when it has not redirected.
+     */
+    getServerRedirect: () => RenderRedirect | undefined;
+};
+export declare function createServerRedirect(): ServerRedirect;
+export {};

package/dist/services/createServerRedirect.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/getComputations.d.ts

@@ -0,0 +1,40 @@
+import { PrefetchConfig } from '../types/prefetch';
+import { ResolvedRoute } from '../types/resolved';
+import { CreatedRouteOptions } from '../types/route';
+import { DataKind } from './createNavigationStores';
+import { AnyPayloadTransformer } from './payload';
+import { AnyFunction } from '../types/utilities';
+/**
+ * Something a route computes: a view's props getter, or a loader. Both are a named callback belonging to
+ * one match, so both are stored the same way — what differs is only what waits on them.
+ */
+export type Computation = {
+    kind: DataKind;
+    id: string;
+    name: string;
+    depth: number;
+    key: string;
+    run: AnyFunction;
+    routePrefetch: PrefetchConfig | undefined;
+    prefetch: PrefetchConfig | undefined;
+    transformer: AnyPayloadTransformer | undefined;
+};
+/**
+ * Where a value lives, which is all that is needed to read it back out of a store.
+ */
+export type ValueLocation = {
+    kind: DataKind;
+    id: string;
+    name: string;
+};
+/**
+ * Decides which of a route's computations to compute.
+ */
+export type ComputationFilter = (computation: Computation) => boolean;
+export declare function getComputations(route: ResolvedRoute): Computation[];
+/**
+ * Only views with a getter, since a view with none is never computed and waiting on it would never settle.
+ */
+export declare function propsLocations(match: CreatedRouteOptions): ValueLocation[];
+export declare function loaderLocations(match: CreatedRouteOptions): ValueLocation[];
+export declare function isKind(kind: DataKind): (computation: Computation) => boolean;

package/dist/services/getGlobalRouteHooks.d.ts

@@ -1,4 +1,4 @@
 import { ResolvedRoute } from '../types/resolved';
 import { Hooks } from '../models/hooks';
-export declare function getGlobalBeforeHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;
-export declare function getGlobalAfterHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;
+export declare function getGlobalBeforeHooks(to: ResolvedRoute | null, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;
+export declare function getGlobalAfterHooks(to: ResolvedRoute | null, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;

package/dist/services/getInitialUrl.d.ts

@@ -1 +1,2 @@
-export declare function getInitialUrl(initialUrl?: string): string;
+import { RouterHistoryMode } from './createRouterHistory';
+export declare function getInitialUrl(initialUrl?: string, mode?: RouterHistoryMode): string;

package/dist/services/getRouteHooks.d.ts

@@ -1,4 +1,4 @@
 import { ResolvedRoute } from '../types/resolved';
 import { Hooks } from '../models/hooks';
-export declare function getBeforeHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): Hooks;
-export declare function getAfterHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): Hooks;
+export declare function getBeforeHooksFromRoutes(to: ResolvedRoute | null, from: ResolvedRoute | null): Hooks;
+export declare function getAfterHooksFromRoutes(to: ResolvedRoute | null, from: ResolvedRoute | null): Hooks;

package/dist/services/getRoutesForRouter.d.ts

@@ -18,7 +18,9 @@ export declare function getRoutesForRouter(routes: Routes | Routes[], plugins?:
         prefetch?: import('../main').PrefetchConfig;
         context: import('../types/routeContext').RouteContext[];
     } & RouteInternal)[];
-    rejections: (Rejection & RejectionInternal)[];
+    rejections: (Pick<import('../types/rejection').RejectionOptions<string>, "type" | "status"> & {
+        getTitle: import('../types/routeTitle').GetTitleCallback;
+    } & RejectionInternal)[];
     getRouteByName: (type: string) => Route | undefined;
     getRejectionByType: {
         (type: BuiltInRejectionType): (Rejection & RejectionInternal);

package/dist/services/hooks.d.ts

@@ -1,6 +1,6 @@
 import { HookLifecycle } from '../types/hooks';
 import { ResolvedRoute } from '../types/resolved';
-type RouteHookCondition = (to: ResolvedRoute, from: ResolvedRoute | null, depth: number) => boolean;
+type RouteHookCondition = (to: ResolvedRoute | null, from: ResolvedRoute | null, depth: number) => boolean;
 export declare const isRouteEnter: RouteHookCondition;
 export declare const isRouteLeave: RouteHookCondition;
 export declare const isRouteUpdate: RouteHookCondition;

package/dist/services/payload.d.ts

@@ -0,0 +1,86 @@
+import { DataKind } from './createNavigationStores';
+import { RouteValue } from './createRouteValueStore';
+import { PayloadValueError } from '../errors/payloadValueError';
+import { ResolvedRoute } from '../types/resolved';
+export declare const PAYLOAD_ELEMENT_ID = "kitbag-payload";
+/**
+ * The payload as a script tag to embed in the document a server sends.
+ *
+ * `<` is escaped so nothing in the payload can close the tag early, and the two unicode line separators
+ * because they terminate a line in javascript source. All three are json unicode escapes, so `JSON.parse`
+ * gives back exactly what went in.
+ */
+export declare function payloadToScript(payload: RouterPayload): string;
+export type TransformerOptions<TValue = unknown> = {
+    /**
+     * Transforms a value across the server render payload: `stringify` writes the value into the payload
+     * on the server, and `parse` reads it back on the client during hydration. Declare one for any value
+     * json cannot carry faithfully, such as a `Map`, `Set`, or `Date`, so the client adopts the same
+     * value the server rendered with. Defaults to json.
+     */
+    transformer?: PayloadTransformer<TValue>;
+};
+export type PayloadTransformer<TValue = unknown> = {
+    /**
+     * Turns a value into a string for the payload.
+     */
+    stringify: (value: TValue) => string;
+    /**
+     * Turns a string from the payload back into a value.
+     */
+    parse: (encoded: string) => TValue;
+};
+/**
+ * A transformer whose value type has been erased. Every loader's and view's transformer is stored in
+ * one record, so a stored one is typed for some value the record no longer names — `unknown` would
+ * claim it accepts anything, which a typed stringify does not.
+ */
+export type AnyPayloadTransformer = PayloadTransformer<any>;
+export declare const jsonTransformer: PayloadTransformer;
+export type PayloadValue = {
+    kind: DataKind;
+    depth: number;
+    name: string;
+    encoded: string;
+};
+export type RouterPayload = SuccessPayload | RejectPayload;
+type SuccessPayload = {
+    kind: 'success';
+    /**
+     * The url the server rendered.
+     */
+    url: string;
+    values: PayloadValue[];
+};
+type RejectPayload = {
+    kind: 'reject';
+    /**
+     * The url the server rendered.
+     */
+    url: string;
+    /**
+     * The type of the rejection the server rendered.
+     */
+    rejection: string;
+};
+export declare function isRouterPayload(value: unknown): value is RouterPayload;
+/**
+ * The payload a server embedded in the document, or undefined when this is not a hydration.
+ */
+export declare function getHydratingPayload(): RouterPayload | undefined;
+type EncodedPayloadValues = {
+    values: PayloadValue[];
+    failures: PayloadValueError[];
+};
+/**
+ * Encodes settled values for the payload, each through its own stringifier or the fallback. A value that
+ * cannot be encoded is warned about, reported as a failure, and left out, so the client computes it again.
+ */
+export declare function encodePayloadValues(route: ResolvedRoute, values: RouteValue[], fallback?: PayloadTransformer): EncodedPayloadValues;
+/**
+ * Decodes payload values for the store to adopt, each through its own stringifier or the fallback. A
+ * value that is missing from the payload or that cannot be read is warned about and left out, so its
+ * getter runs again.
+ */
+export declare function decodePayloadValues(route: ResolvedRoute, values: PayloadValue[], fallback?: PayloadTransformer): RouteValue[];
+export {};

package/dist/services/payload.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/standardSchema.d.ts

@@ -0,0 +1,21 @@
+import { ParamGetSet } from '../types/paramTypes';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+export interface ZodSchemaLike extends StandardSchemaV1<any> {
+    parse: (input: any) => any;
+    def: {
+        type: string;
+    };
+}
+export interface ValibotSchemaLike extends StandardSchemaV1<any> {
+    type: string;
+}
+export interface ArkTypeSchemaLike extends StandardSchemaV1<any> {
+    extends: (def: string) => boolean;
+    branches: readonly ArkTypeSchemaLike[];
+}
+export type StandardSchemaLike = ZodSchemaLike | ValibotSchemaLike | ArkTypeSchemaLike;
+export declare function isZodSchema(value: unknown): value is ZodSchemaLike;
+export declare function isValibotSchema(value: unknown): value is ValibotSchemaLike;
+export declare function isArkTypeSchema(value: unknown): value is ArkTypeSchemaLike;
+export declare function isStandardSchema(value: unknown): value is StandardSchemaLike;
+export declare function createStandardSchemaParam<T>(schema: StandardSchemaLike): ParamGetSet<T>;

package/dist/services/urlParser.d.ts

@@ -14,6 +14,11 @@ type UrlPartsInput = {
 };
 export declare function stringifyUrl(parts: UrlPartsInput): UrlString;
 export declare function parseUrl(value: string): UrlParts;
+/**
+ * Ignores host, and sorts query params because the router reorders them when it separates declared
+ * params from the rest.
+ */
+export declare function isSameUrl(left: string, right: string): boolean;
 export declare function updateUrl(url: string, updates: UrlPartsInput): UrlString;
 export declare function updateUrl(url: Partial<UrlParts>, updates: UrlPartsInput): UrlParts;
 export {};

package/dist/tests/hydration.browser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/render.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/addLoader.d.ts

@@ -1,5 +1,6 @@
 import { RouteWithMethods } from './routeWithMethods';
 import { PrefetchConfig } from './prefetch';
+import { TransformerOptions } from '../services/payload';
 import { ResolvedRoute } from './resolved';
 import { CreatedRouteOptions, Route } from './route';
 import { RouteCallbackContext } from './routeCallbackContext';
@@ -19,7 +20,7 @@ export type LoaderGetter<TRoute extends Route = Route> = (route: ResolvedRoute<T
  *
  * @template TName - The loader's name, inferred from the `name` option.
  */
-export type AddLoaderOptions<TName extends string | undefined = string> = {
+export type AddLoaderOptions<TName extends string | undefined = string, TValue = unknown> = TransformerOptions<TValue> & {
     /**
      * The name of the loader, which is the key its data is exposed under on the route. Defaults to the
      * unnamed loader, whose data is exposed as the route's data directly.
@@ -64,6 +65,6 @@ export type RouteAddLoader<TUrl extends Url = Url, TMatches extends CreatedRoute
      * @param load - The loader callback. Receives the resolved route and a context object.
      * @param options - The loader's `name` and `prefetch` config.
      */
-    addLoader: <const TName extends string | undefined = undefined, const TGetter extends LoaderGetter<Route<TUrl, TMatches>> = LoaderGetter<Route<TUrl, TMatches>>>(load: TGetter, options?: AddLoaderOptions<TName>) => AddLoaderReturn<TUrl, TMatches, AddLoaderLoaders<CurrentMatchLoaders<TMatches>, TName, ReturnType<TGetter>>>;
+    addLoader: <const TName extends string | undefined = undefined, const TGetter extends LoaderGetter<Route<TUrl, TMatches>> = LoaderGetter<Route<TUrl, TMatches>>>(load: TGetter, options?: AddLoaderOptions<TName, Awaited<ReturnType<TGetter>>>) => AddLoaderReturn<TUrl, TMatches, AddLoaderLoaders<CurrentMatchLoaders<TMatches>, TName, ReturnType<TGetter>>>;
 };
 export {};

package/dist/types/addView.d.ts

@@ -6,6 +6,7 @@ import { CreatedRouteOptions, Route } from './route';
 import { RouteCallbackContext } from './routeCallbackContext';
 import { RouteWithMethods } from './routeWithMethods';
 import { PrefetchConfig } from './prefetch';
+import { TransformerOptions } from '../services/payload';
 import { RouteView, RouteViews } from './routeViews';
 import { Url } from './url';
 import { AnyFunction, Identity, LastInArray, MaybePromise } from './utilities';
@@ -31,7 +32,7 @@ type NewViewProps<TRoute extends Route, TComponent extends Component, TGetter ex
  * @template TName - The view's name, inferred from the `name` option.
  * @template TGetter - The view's props getter, inferred from the `props` option.
  */
-export type AddViewOptions<TName extends string | undefined = string, TGetter = PropsGetter> = {
+export type AddViewOptions<TName extends string | undefined = string, TGetter = PropsGetter> = TransformerOptions<PayloadValueOf<TGetter>> & {
     /**
      * The name of the view, rendered by `<router-view name="..." />`. Defaults to the unnamed view.
      */
@@ -46,6 +47,10 @@ export type AddViewOptions<TName extends string | undefined = string, TGetter =
      */
     prefetch?: PrefetchConfig;
 };
+/**
+ * What a getter resolves to, which is what its payload options carry.
+ */
+type PayloadValueOf<TGetter> = TGetter extends (...args: any[]) => any ? Awaited<ReturnType<TGetter>> : unknown;
 /**
  * {@link AddViewOptions} with `props` promoted to required. Only reached for components that have
  * required props — everything else uses {@link AddViewOptions}, where `props` stays optional, so a view
@@ -54,7 +59,7 @@ export type AddViewOptions<TName extends string | undefined = string, TGetter =
  * Spelled out rather than intersected with {@link AddViewOptions} so that the literal `name` still
  * infers through the conditional args tuple.
  */
-type AddViewOptionsWithRequiredProps<TName extends string | undefined, TGetter> = {
+type AddViewOptionsWithRequiredProps<TName extends string | undefined, TGetter> = TransformerOptions<PayloadValueOf<TGetter>> & {
     name?: TName;
     props: TGetter;
     prefetch?: PrefetchConfig;

package/dist/types/callbackContext.d.ts

@@ -1,3 +1,4 @@
+import { RedirectStatus } from './router';
 import { RouterPush } from './routerPush';
 export type CallbackContextSuccess = {
     status: 'SUCCESS';
@@ -6,6 +7,14 @@ export type CallbackContextPush = {
     status: 'PUSH';
     to: Parameters<RouterPush>;
 };
+export type CallbackContextRedirect = {
+    status: 'REDIRECT';
+    to: Parameters<RouterPush>;
+    /**
+     * The status the redirect declared, or undefined to use the router's `redirectStatus`.
+     */
+    redirectStatus: RedirectStatus | undefined;
+};
 export type CallbackContextReject = {
     status: 'REJECT';
     type: string;