@kitbag/router 0.25.0 → 0.26.1

package/dist/types/hooks.d.ts

@@ -1,5 +1,5 @@
 import { Hooks } from '../models/hooks';
-import { ResolvedRoute, RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
+import { RouterResolvedRouteUnion, ResolvedRouteUnion } from './resolved';
 import { MaybePromise } from './utilities';
 import { Route, Routes } from './route';
 import { RouterReject } from './routerReject';
@@ -8,7 +8,7 @@ import { RouterReplace } from './routerReplace';
 import { Rejection, Rejections } from './rejection';
 import { RouteContext, RouteContextToRejection, RouteContextToRoute } from './routeContext';
 import { RouterAbort } from './routerAbort';
-import { CallbackContextAbort, CallbackContextPush, CallbackContextReject, CallbackContextSuccess } from './callbackContext';
+import { CallbackContextAbort, CallbackContextPush, CallbackContextRedirect, CallbackContextReject, CallbackContextSuccess } from './callbackContext';
 import { RouteUpdate } from './routeUpdate';
 export declare function getHooks(value: Record<string, unknown> | undefined | null): Hooks[];
 export declare function combineHooks(parent: Route, child: Route): Hooks[];
@@ -107,10 +107,10 @@ export type BeforeUpdateHookContext<TRoutes extends Routes = Routes, TRejections
 };
 export type BeforeUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: BeforeUpdateHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddBeforeUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: BeforeUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
-export type BeforeLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = BeforeHookContext<TRouteTo, TRoutes, TRejections> & {
+export type BeforeLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = Omit<BeforeHookContext<TRouteTo, TRoutes, TRejections>, 'update'> & {
     from: ResolvedRouteUnion<TRouteFrom>;
 };
-export type BeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: BeforeLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
+export type BeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo> | null, context: BeforeLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddBeforeLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: BeforeLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
 export type AfterEnterHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AfterHookContext<TRouteTo, TRoutes, TRejections> & {
     from: ResolvedRouteUnion<TRouteFrom> | null;
@@ -122,19 +122,19 @@ export type AfterUpdateHookContext<TRoutes extends Routes = Routes, TRejections
 };
 export type AfterUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: AfterUpdateHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddAfterUpdateHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: AfterUpdateHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
-export type AfterLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = AfterHookContext<TRouteTo, TRoutes, TRejections> & {
+export type AfterLeaveHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = Omit<AfterHookContext<TRouteTo, TRoutes, TRejections>, 'update'> & {
     from: ResolvedRouteUnion<TRouteFrom>;
 };
-export type AfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: AfterLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
+export type AfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo> | null, context: AfterLeaveHookContext<TRoutes, TRejections, TRouteTo, TRouteFrom>) => MaybePromise<void>;
 export type AddAfterLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = (hook: AfterLeaveHook<TRoutes, TRejections, TRouteTo, TRouteFrom>) => HookRemove;
-export type BeforeHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject | CallbackContextAbort;
+export type BeforeHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextRedirect | CallbackContextReject | CallbackContextAbort;
 export type AfterHookResponse = CallbackContextSuccess | CallbackContextPush | CallbackContextReject;
 export type BeforeHookRunner = <TRoutes extends Routes>(context: {
-    to: RouterResolvedRouteUnion<TRoutes>;
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
 }) => Promise<BeforeHookResponse>;
 export type AfterHookRunner = <TRoutes extends Routes>(context: {
-    to: RouterResolvedRouteUnion<TRoutes>;
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
 }) => Promise<AfterHookResponse>;
 export type RejectionHookContext<TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number], TRouteFrom extends Route = TRoutes[number]> = {
@@ -147,19 +147,18 @@ export type RejectionHookRunner<TRejection extends Rejection = Rejection, TRoute
     to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
 }) => void;
-export type ErrorHookContext<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
-    to: RouterResolvedRouteUnion<TRoutes>;
+export type ErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
     source: 'props' | 'loader' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
-    update: RouteUpdate<ResolvedRoute<TRoute>>;
 };
-export type ErrorHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (error: unknown, context: ErrorHookContext<TRoute, TRoutes, TRejections>) => void;
-export type AddErrorHook<TRoute extends Route = Route, TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: ErrorHook<TRoute, TRoutes, TRejections>) => HookRemove;
+export type ErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (error: unknown, context: ErrorHookContext<TRoutes, TRejections>) => void;
+export type AddErrorHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: ErrorHook<TRoutes, TRejections>) => HookRemove;
 export type ErrorHookRunnerContext<TRoutes extends Routes = Routes> = {
-    to: RouterResolvedRouteUnion<TRoutes>;
+    to: RouterResolvedRouteUnion<TRoutes> | null;
     from: RouterResolvedRouteUnion<TRoutes> | null;
     source: 'props' | 'loader' | 'hook';
 };

package/dist/types/paramTypes.d.ts

@@ -1,5 +1,4 @@
-import { ValibotSchemaLike } from '../services/valibot';
-import { ZodSchemaLike } from '../services/zod';
+import { ArkTypeSchemaLike, ValibotSchemaLike, ZodSchemaLike } from '../services/standardSchema';
 export type ParamExtras = {
     invalid: (message?: string) => never;
 };
@@ -11,4 +10,4 @@ export type ParamGetSet<T = any> = {
     defaultValue?: T;
 };
 export type LiteralParam = string | number | boolean;
-export type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | ZodSchemaLike | ValibotSchemaLike | LiteralParam;
+export type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | ZodSchemaLike | ValibotSchemaLike | ArkTypeSchemaLike | LiteralParam;

package/dist/types/params.d.ts

@@ -33,7 +33,7 @@ export type ExtractParamName<TParam extends PropertyKey> = TParam extends string
  * @template TParam - The parameter type.
  * @returns The extracted type, or 'string' as a fallback.
  */
-export type ExtractParamType<TParam extends Param> = Param extends TParam ? unknown : TParam extends ParamGetSet<infer Type> ? Type : TParam extends DateConstructor ? Date : TParam extends JSON ? unknown : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TParam> : TParam extends LiteralParam ? TParam : string;
+export type ExtractParamType<TParam extends Param> = Param extends TParam ? unknown : TParam extends ParamGetSet<infer Type> ? Type : TParam extends DateConstructor ? Date : TParam extends JSON ? unknown : TParam extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TParam> : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends LiteralParam ? TParam : string;
 export type ParamIsOptional<TParam extends string> = TParam extends `?${string}` ? true : false;
 export type ParamIsGreedy<TParam extends string> = TParam extends `${string}*` ? true : false;
 export type ParamIsOptionalOrHasDefault<TParamName extends string, TParam extends Param | undefined> = ParamIsOptional<TParamName> extends true ? true : TParam extends Required<ParamGetSet> ? true : false;

package/dist/types/redirects.d.ts

@@ -1,5 +1,6 @@
 import { ResolvedRouteUnion } from './resolved';
 import { Route, Routes } from './route';
+import { RedirectStatus } from './router';
 import { RouterReplace } from './routerReplace';
 import { UrlParamsReading, UrlParamsWriting } from './url';
 import { AllPropertiesAreOptional, MaybePromise } from './utilities';
@@ -18,12 +19,19 @@ type RedirectHookContext<TRoutes extends Routes> = {
 };
 export type RedirectHook<TRoutes extends Routes = Routes, TRouteTo extends Route = TRoutes[number]> = (to: ResolvedRouteUnion<TRouteTo>, context: RedirectHookContext<TRoutes>) => MaybePromise<void>;
 export type RouteRedirectCallback<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = (params: UrlParamsReading<TRouteFrom>) => UrlParamsWriting<TRouteTo>;
+export type RouteRedirectOptions = {
+    /**
+     * The http status a server responds with for this redirect when server rendering. Defaults to the
+     * router's `redirectStatus`.
+     */
+    status?: RedirectStatus;
+};
 /**
  * This type is purposely wide to prevent type errors in RouteRedirectFrom where the TRouteTo generic cannot be inferred.
  */
-export type RouteRedirect = (to: Route, callback?: (params: any) => any) => void;
-export type RedirectToArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [to: TRouteTo, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>] : [to: TRouteTo, params: RouteRedirectCallback<TRouteTo, TRouteFrom>];
+export type RouteRedirect = (to: Route, callback?: (params: any) => any, options?: RouteRedirectOptions) => void;
+export type RedirectToArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [to: TRouteTo, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions] : [to: TRouteTo, params: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions];
 export type RouteRedirectTo<TRouteFrom extends Route = Route> = <TRouteTo extends Route>(...args: RedirectToArgs<TRouteTo, TRouteFrom>) => void;
-export type RedirectFromArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [from: TRouteFrom, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>] : [from: TRouteFrom, params: RouteRedirectCallback<TRouteTo, TRouteFrom>];
+export type RedirectFromArgs<TRouteTo extends Route = Route, TRouteFrom extends Route = Route> = AllPropertiesAreOptional<UrlParamsWriting<TRouteTo>> extends true ? [from: TRouteFrom, params?: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions] : [from: TRouteFrom, params: RouteRedirectCallback<TRouteTo, TRouteFrom>, options?: RouteRedirectOptions];
 export type RouteRedirectFrom<TRouteTo extends Route = Route> = <TRouteFrom extends Route>(...args: RedirectFromArgs<TRouteTo, TRouteFrom>) => void;
 export {};

package/dist/types/rejection.d.ts

@@ -1,10 +1,14 @@
-import { Ref } from 'vue';
+import { Component, Ref } from 'vue';
 import { Route } from './route';
 import { Router } from './router';
 import { RouterReject } from './routerReject';
 import { Hooks } from '../models/hooks';
-export declare const BUILT_IN_REJECTION_TYPES: readonly ["NotFound"];
-export type BuiltInRejectionType = (typeof BUILT_IN_REJECTION_TYPES)[number];
+import { GetTitleCallback } from './routeTitle';
+export declare const BUILT_IN_REJECTIONS: {
+    readonly NotFound: 404;
+};
+export type BuiltInRejectionType = keyof typeof BUILT_IN_REJECTIONS;
+export declare const NOT_FOUND_REJECTION_TYPE = "NotFound";
 export type RouterRejection<T extends Rejection = Rejection> = Ref<T | null>;
 export type RouterRejections<TRouter extends Router> = TRouter['reject'] extends RouterReject<infer TRejections extends Rejection[]> ? TRejections[number] : never;
 export declare const IS_REJECTION_SYMBOL: unique symbol;
@@ -18,11 +22,27 @@ export type RejectionInternal = {
  * Represents an immutable array of Rejection instances.
  */
 export type Rejections = readonly Rejection[];
-export type Rejection<TType extends string = string> = {
+export type RejectionOptions<TType extends string = string> = {
     /**
      * The type of rejection.
      */
     type: TType;
+    /**
+     * The component rendered while this rejection is in effect.
+     */
+    component?: Component;
+    /**
+     * The http status a server should respond with while this rejection is in effect. 404 for something
+     * missing, 401 or 403 for something gated, 503 for something temporary. Defaults to the router's
+     * `rejectStatus`.
+     */
+    status?: number;
+};
+export type Rejection<TType extends string = string> = Pick<RejectionOptions<TType>, 'type' | 'status'> & {
+    /**
+     * Returns the title of the rejection from its `setTitle` callback.
+     */
+    getTitle: GetTitleCallback;
 };
 export type RejectionType<TRejections extends Rejections | undefined> = unknown extends TRejections ? never : Rejections extends TRejections ? string : undefined extends TRejections ? string : TRejections extends Rejections ? TRejections[number]['type'] : never;
 export type ExtractRejections<T> = T extends {

package/dist/types/resolved.d.ts

@@ -3,6 +3,7 @@ import { LastInArray } from './utilities';
 import { ExtractRouteStateParamsAsOptional } from './state';
 import { UrlString } from './urlString';
 import { UrlParamsReading } from './url';
+import { GetTitleCallback } from './routeTitle';
 /**
  * The match a route resolved to, which is the last of its matches. Falls back to the wide match type when
  * the matches are not a concrete tuple, so an unregistered router stays assignable.
@@ -51,9 +52,10 @@ export type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
      */
     hash: string;
     /**
-     * Title of the route.
+     * Returns the title of the route from its `setTitle` callback, or from the closest parent route that
+     * defines one.
      */
-    title: Promise<string | undefined>;
+    getTitle: GetTitleCallback;
 }>;
 /**
  * A resolved route whose loaders' data is available. Only the route being navigated to has data: a route

package/dist/types/routeLoaders.d.ts

@@ -1,3 +1,4 @@
+import { AnyPayloadTransformer } from '../services/payload';
 import { PrefetchConfig } from './prefetch';
 import { AnyFunction } from './utilities';
 /**
@@ -9,6 +10,7 @@ import { AnyFunction } from './utilities';
 export type RouteLoader<TData = unknown> = {
     load: AnyFunction<TData>;
     prefetch?: PrefetchConfig;
+    transformer?: AnyPayloadTransformer;
 };
 /**
  * The loaders for a single route, keyed by loader name (the unnamed loader under 'default').

package/dist/types/routeTitle.d.ts

@@ -1,9 +1,10 @@
 import { ResolvedRoute, ResolvedRouteUnion } from './resolved';
 import { Route } from './route';
 import { MaybePromise } from './utilities';
+export type GetTitleCallback = () => Promise<string | undefined>;
 export type SetRouteTitleContext = {
     from: ResolvedRoute;
-    getParentTitle: () => Promise<string | undefined>;
+    getParentTitle: GetTitleCallback;
 };
 export type SetRouteTitleCallback<TRoute extends Route = Route> = (to: ResolvedRouteUnion<TRoute>, context: SetRouteTitleContext) => MaybePromise<string>;
 export type GetRouteTitle<TRoute extends Route = Route> = (to: ResolvedRouteUnion<TRoute>) => Promise<string | undefined>;

package/dist/types/routeViews.d.ts

@@ -1,3 +1,4 @@
+import { AnyPayloadTransformer } from '../services/payload';
 import { Component } from 'vue';
 import { PrefetchConfig } from './prefetch';
 import { AnyFunction } from './utilities';
@@ -11,6 +12,7 @@ export type RouteView<TProps = undefined> = {
     component?: Component;
     props?: AnyFunction<TProps>;
     prefetch?: PrefetchConfig;
+    transformer?: AnyPayloadTransformer;
 };
 /**
  * The views for a single route, keyed by view name (the unnamed view under 'default'). Indexed by depth in

package/dist/types/router.d.ts

@@ -1,5 +1,6 @@
 import { App, InjectionKey, Ref } from 'vue';
 import { RouterHistoryMode } from '../services/createRouterHistory';
+import { TransformerOptions } from '../services/payload';
 import { RouterRoute } from './routerRoute';
 import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook, AddRejectionHook } from './hooks';
 import { PrefetchConfig } from './prefetch';
@@ -12,16 +13,22 @@ import { RouterReject } from './routerReject';
 import { RouterPlugin } from './routerPlugin';
 import { RoutesName } from './routesMap';
 import { ExtractRejections, ExtractRejectionTypes, Rejections, BuiltInRejectionType } from './rejection';
+import { PayloadValueError } from '../errors/payloadValueError';
 /**
  * Options to initialize a {@link Router} instance.
  */
-export type RouterOptions = {
+export type RouterOptions = TransformerOptions & {
     /**
      * Initial URL for the router to use. Required if using Node environment. Defaults to window.location when using browser.
      *
      * @default window.location.toString()
      */
     initialUrl?: string;
+    /**
+     * Marks the router as rendering on a server, so every navigation is part of the server render from
+     * the moment the router is created. Required to call `render`.
+     */
+    ssr?: boolean;
     /**
      * Specifies the history mode for the router, such as "browser", "memory", or "hash".
      *
@@ -47,6 +54,19 @@ export type RouterOptions = {
      * @default true
      */
     removeTrailingSlashes?: boolean;
+    /**
+     * The status `render` responds with for a normalized url or a route redirect that does not declare
+     * its own.
+     *
+     * @default 302
+     */
+    redirectStatus?: RedirectStatus;
+    /**
+     * The status `render` responds with for a rejection that does not declare its own.
+     *
+     * @default 200
+     */
+    rejectStatus?: number;
     /**
      * When false, createRouterAssets must be used for component and hooks. Assets exported by the library
      * will not work with the created router instance.
@@ -55,6 +75,67 @@ export type RouterOptions = {
      */
     isGlobalRouter?: boolean;
 };
+/**
+ * What a server should respond with for what the router rendered. `location` exists only on a redirect,
+ * so narrowing on it is what proves a `Location` header is available.
+ */
+export type ServerRenderResponse = RenderSuccess | RenderReject | RenderRedirect;
+export type RenderSuccess = {
+    kind: 'success';
+    /**
+     * Suggested http status.
+     */
+    status: number;
+    /**
+     * A script tag to embed in the document sent to the client, so it adopts what this render settled on
+     * rather than working it out again.
+     */
+    payload: string;
+    /**
+     * The title of the route that rendered, for the document sent to the client.
+     */
+    title: string | undefined;
+    /**
+     * Values that could not be encoded into the payload. Each was left out, so the client computes it
+     * again, which can cause a hydration mismatch. Returned so a server can log or inspect them.
+     */
+    failures: PayloadValueError[];
+};
+export type RenderReject = {
+    kind: 'reject';
+    /**
+     * Suggested http status.
+     */
+    status: number;
+    /**
+     * The type of rejection in effect.
+     */
+    rejection: string;
+    /**
+     * A script tag to embed in the document sent to the client, so it adopts this rejection rather than
+     * working it out again.
+     */
+    payload: string;
+    /**
+     * The title of the rejection that rendered, for the document sent to the client.
+     */
+    title: string | undefined;
+};
+export type RenderRedirect = {
+    kind: 'redirect';
+    /**
+     * Suggested http status.
+     */
+    status: RedirectStatus;
+    /**
+     * Value for the `Location` header.
+     */
+    location: string;
+};
+/**
+ * The statuses the router reports for a redirect.
+ */
+export type RedirectStatus = 301 | 302;
 export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions = any, TPlugin extends RouterPlugin = any> = {
     /**
      * Installs the router into a Vue application instance.
@@ -129,7 +210,7 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      * Registers a hook to be called when an error occurs.
      * If the hook returns true, the error is considered handled and the other hooks are not run. If all hooks return false the error is rethrown
      */
-    onError: AddErrorHook<TRoutes[number] | TPlugin['routes'][number], TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
+    onError: AddErrorHook<TRoutes | TPlugin['routes'], ExtractRejections<TOptions> | ExtractRejections<TPlugin>>;
     /**
      * Registers a hook to be called when a rejection occurs.
      */
@@ -151,7 +232,18 @@ export type Router<TRoutes extends Routes = any, TOptions extends RouterOptions
      */
     started: Ref<boolean>;
     /**
-     * Stops the router and teardown any listeners.
+     * Resolves once the router has nothing left to render: every prop and loader has settled, following
+     * any navigation one of them caused, so this waits for the next *full* render rather than for one
+     * navigation. Resolves with what a server should respond with.
+     *
+     * Awaiting `push` only waits for the route to commit; this also waits for its data.
+     *
+     * Requires the router to be created with the `ssr` option, and throws `SsrOptionRequiredError`
+     * without it.
+     */
+    render: () => Promise<ServerRenderResponse>;
+    /**
+     * Stops the router. Tears down the history listener and ignores any navigation still in flight or started afterwards.
      */
     stop: () => void;
     /**

package/dist/types/routerPlugin.d.ts

@@ -43,11 +43,15 @@ type PluginAfterRouteHookContext<TRoutes extends Routes, TRejections extends Rej
     replace: RouterReplace<TRoutes>;
 };
 export type PluginBeforeRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute, context: PluginBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+export type PluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute | null, context: PluginBeforeRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+type AddPluginBeforeRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: PluginBeforeRouteLeaveHook<TRoutes, TRejections>) => HookRemove;
+export type PluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute | null, context: PluginAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
+type AddPluginAfterRouteLeaveHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (hook: PluginAfterRouteLeaveHook<TRoutes, TRejections>) => HookRemove;
 export type PluginAfterRouteHook<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = (to: ResolvedRoute, context: PluginAfterRouteHookContext<TRoutes, TRejections>) => MaybePromise<void>;
 type AddPluginBeforeRouteHook<TRoutes extends Routes, TRejections extends Rejections> = (hook: PluginBeforeRouteHook<TRoutes, TRejections>) => HookRemove;
 type AddPluginAfterRouteHook<TRoutes extends Routes, TRejections extends Rejections> = (hook: PluginAfterRouteHook<TRoutes, TRejections>) => HookRemove;
 export type PluginErrorHookContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
-    to: ResolvedRoute;
+    to: ResolvedRoute | null;
     from: ResolvedRoute | null;
     source: 'props' | 'loader' | 'hook' | 'component';
     reject: RouterReject<TRejections>;
@@ -64,7 +68,7 @@ export type PluginRouteHooks<TRoutes extends Routes = Routes, TRejections extend
     /**
      * Registers a global hook to be called before a route is left.
      */
-    onBeforeRouteLeave: AddPluginBeforeRouteHook<TRoutes, TRejections>;
+    onBeforeRouteLeave: AddPluginBeforeRouteLeaveHook<TRoutes, TRejections>;
     /**
      * Registers a global hook to be called before a route is updated.
      */
@@ -76,7 +80,7 @@ export type PluginRouteHooks<TRoutes extends Routes = Routes, TRejections extend
     /**
      * Registers a global hook to be called after a route is left.
      */
-    onAfterRouteLeave: AddPluginAfterRouteHook<TRoutes, TRejections>;
+    onAfterRouteLeave: AddPluginAfterRouteLeaveHook<TRoutes, TRejections>;
     /**
      * Registers a global hook to be called after a route is updated.
      */

package/dist/types/routerReject.d.ts

@@ -1,2 +1,15 @@
 import { BuiltInRejectionType, Rejections, RejectionType } from './rejection';
+import { ResolvedRoute } from './resolved';
 export type RouterReject<TRejections extends Rejections | undefined> = <TSource extends (RejectionType<TRejections> | BuiltInRejectionType)>(type: TSource) => void;
+/**
+ * The routes a rejection happened between, which rejection hooks are given.
+ */
+export type RejectContext = {
+    to?: ResolvedRoute | null;
+    from?: ResolvedRoute | null;
+};
+/**
+ * Reject as the router itself calls it, which may name any rejection type and supply the routes the
+ * rejection happened between. The router exposes {@link RouterReject} instead.
+ */
+export type RouterRejectInternal<TRejections extends Rejections | undefined> = RouterReject<TRejections> & ((type: string, context?: RejectContext) => void);

package/dist/types/routerRoute.d.ts

@@ -35,7 +35,7 @@ export type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
     /**
      * Title of the route.
      */
-    readonly title: TRoute['title'];
+    readonly getTitle: TRoute['getTitle'];
     /**
      * What the route's loaders resolve to, keyed by loader name. A route whose only loader is unnamed
      * exposes that loader's data here directly.

package/dist/types/serverRenderResponse.spec-d.d.ts

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

package/dist/utilities/components.d.ts

@@ -1,6 +1,18 @@
 import { Component } from 'vue';
+import { ResolvedRoute } from '../types/resolved';
+import { CreatedRouteOptions } from '../types/route';
+import { RouteView } from '../types/routeViews';
 type ComponentWithAsyncLoader = Component & {
-    __asyncLoader: () => void;
+    __asyncLoader: () => Promise<unknown>;
 };
 export declare function isAsyncComponent(component: Component): component is ComponentWithAsyncLoader;
+/**
+ * Decides which of a route's views to load.
+ */
+export type AsyncComponentFilter = (match: CreatedRouteOptions, view: RouteView<unknown>) => boolean;
+/**
+ * Loads the async components a route renders, or only those the filter keeps, so they are ready to render
+ * synchronously.
+ */
+export declare function loadAsyncComponents(route: ResolvedRoute, filter?: AsyncComponentFilter): Promise<unknown>;
 export {};

package/dist/utilities/setDocumentTitle.d.ts

@@ -1,2 +1 @@
-import { ResolvedRoute } from '../types/resolved';
-export declare function setDocumentTitle(to: ResolvedRoute | null): void;
+export declare function setDocumentTitle(title: string | undefined): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kitbag/router",
   "private": false,
-  "version": "0.25.0",
+  "version": "0.26.1",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/kitbagjs/router/issues"
@@ -45,31 +45,26 @@
   "devDependencies": {
     "@kitbag/eslint-config": "1.0.6",
     "@vitejs/plugin-vue": "^6.0.8",
-    "@vue/language-core": "^3.3.9",
-    "@vue/test-utils": "^2.4.11",
+    "@vue/language-core": "^3.3.11",
+    "@vue/test-utils": "^2.5.0",
+    "arktype": "^2.2.3",
     "eslint": "^9.39.5",
-    "globals": "^17.9.0",
-    "happy-dom": "^20.11.2",
+    "globals": "^17.12.0",
+    "happy-dom": "^20.14.3",
     "typedoc": "^0.28.20",
-    "typedoc-plugin-markdown": "^4.12.0",
-    "typedoc-vitepress-theme": "^1.1.3",
+    "typedoc-plugin-markdown": "^4.13.0",
+    "typedoc-vitepress-theme": "^1.1.4",
     "typescript": "^6.0.3",
     "valibot": "^1.0.0",
     "vite": "^8.2.0",
     "vite-plugin-dts": "^5.0.3",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.10",
+    "vitest": "^5.0.0",
     "vue-tsc": "^3.3.8",
     "zod": "4.0.0"
   },
   "peerDependencies": {
-    "vue": "^3.5.0",
-    "zod": "4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "zod": {
-      "optional": true
-    }
+    "vue": "^3.5.0"
   },
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",

package/dist/services/valibot.d.ts

@@ -1,7 +0,0 @@
-import { Param, ParamGetSet } from '../types/paramTypes';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-export interface ValibotSchemaLike extends StandardSchemaV1<any> {
-    type: string;
-}
-export declare function isValibotParam(value: Param): value is ValibotSchemaLike;
-export declare function createValibotParam<T>(schema: ValibotSchemaLike): ParamGetSet<T>;

package/dist/services/zod.d.ts

@@ -1,11 +0,0 @@
-import { ParamGetSet } from '../types/paramTypes';
-import { Routes } from '../types/route';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { ZodType } from 'zod';
-export interface ZodSchemaLike extends StandardSchemaV1<any> {
-    parse: (input: any) => any;
-}
-export declare function zodParamsDetected(routes: Routes): boolean;
-export declare function initZod(): Promise<void>;
-export declare function isZodParam(value: unknown): value is ZodType;
-export declare function createZodParam<T>(schema: ZodType<T>): ParamGetSet<T>;