@kimesh/router-runtime 0.2.23 → 0.2.24

package/dist/{index-9xJk3v3Z.d.mts → index-Bi0AaYQy.d.mts}

@@ -134,6 +134,63 @@ interface FullContext extends KimeshContext {
  * Injection key for Kimesh context
  */
 declare const KIMESH_CONTEXT_KEY: InjectionKey<FullContext>;
+/**
+ * Context passed to beforeLoad function
+ */
+interface BeforeLoadContextFull<TParams = Record<string, string>> {
+  /** Route params extracted from URL */
+  params: TParams;
+  /** Validated search/query params */
+  search: Record<string, unknown>;
+  /** Current app context (built-in + user-defined) */
+  context: FullContext;
+  /** AbortSignal for cancellation */
+  signal: AbortSignal;
+}
+/**
+ * Before load function type
+ * Used to augment context for child routes
+ */
+type BeforeLoadFn<TParams = Record<string, string>, TReturn extends Record<string, unknown> = Record<string, unknown>> = (ctx: BeforeLoadContextFull<TParams>) => TReturn | Promise<TReturn>;
+/**
+ * Pending component configuration for routes
+ */
+interface PendingConfig {
+  /**
+   * Component to show while route is loading
+   * @example
+   * pendingComponent: () => import('./DashboardSkeleton.vue')
+   */
+  pendingComponent?: () => Promise<{
+    default: Component;
+  }>;
+  /**
+   * Milliseconds to wait before showing pending component
+   * Prevents flash of loading state for fast loads
+   * @default 200
+   */
+  pendingMs?: number;
+  /**
+   * Minimum milliseconds to show pending component once visible
+   * Prevents jarring quick flash of loading state
+   * @default 500
+   */
+  pendingMinMs?: number;
+}
+/**
+ * Context accumulated from parent routes' beforeLoad functions
+ * This is merged into FullContext during navigation
+ */
+interface RouteContext {
+  /** Marker to identify route-accumulated context */
+  __routeContext?: true;
+  /** Additional properties from beforeLoad functions */
+  [key: string]: unknown;
+}
+/**
+ * Augmented context with route-level additions
+ */
+type AugmentedContext<TBeforeLoad extends Record<string, unknown> = Record<string, unknown>> = FullContext & TBeforeLoad;
 /**
  * Param value types for route parameters
  */
@@ -223,13 +280,13 @@ interface KimeshApp {
 /**
  * Loader context passed to loader functions
  */
-interface LoaderContext<TParams = Record<string, string>, TSearch = Record<string, unknown>> {
+interface LoaderContext<TParams = Record<string, string>, TSearch = Record<string, unknown>, TRouteContext extends Record<string, unknown> = {}> {
   /** Route params (e.g., { postId: '123' }) */
   params: TParams;
   /** Validated search/query params */
   search: TSearch;
-  /** App context (built-in + user-defined) */
-  context: FullContext;
+  /** App context (built-in + user-defined + route-accumulated) */
+  context: FullContext & TRouteContext;
   /** AbortSignal for cancellation */
   signal: AbortSignal;
 }
@@ -349,7 +406,7 @@ type InlineRouteMiddleware<TParams = Record<string, string>> = (to: RouteLocatio
 /**
  * File route options
  */
-interface FileRouteOptions<TMeta = unknown, TParams = Record<string, string>, TSearch = Record<string, unknown>, TLoaderData = unknown> {
+interface FileRouteOptions<TMeta = unknown, TParams = Record<string, string>, TSearch = Record<string, unknown>, TLoaderData = unknown, TBeforeLoadReturn extends Record<string, unknown> = Record<string, unknown>> extends PendingConfig {
   /** Route meta */
   meta?: TMeta;
   /** Loader function - runs before navigation completes */
@@ -379,7 +436,7 @@ interface FileRouteOptions<TMeta = unknown, TParams = Record<string, string>, TS
    */
   middleware?: string | InlineRouteMiddleware<TParams> | Array<string | InlineRouteMiddleware<TParams>>;
   /** Before load hook (runs after middleware) */
-  beforeLoad?: (ctx: BeforeLoadContext) => Promise<void> | void;
+  beforeLoad?: BeforeLoadFn<TParams, TBeforeLoadReturn>;
   /**
    * Route-level head configuration
    *
@@ -447,17 +504,19 @@ interface BeforeLoadContext {
 /**
  * Route definition returned by createFileRoute
  */
-interface RouteDefinition<TPath extends string = string, TMeta = unknown, TParams = Record<string, string>, TSearch = Record<string, unknown>, TLoaderData = unknown> {
+interface RouteDefinition<TPath extends string = string, TMeta = unknown, TParams = Record<string, string>, TSearch = Record<string, unknown>, TLoaderData = unknown> extends PendingConfig {
   path: TPath;
   meta?: TMeta;
   loader?: LoaderFn<TParams, TSearch, TLoaderData>;
   validateSearch?: SearchSchema<TSearch>;
   middleware?: string | InlineRouteMiddleware<TParams> | Array<string | InlineRouteMiddleware<TParams>>;
-  beforeLoad?: (ctx: BeforeLoadContext) => Promise<void> | void;
+  beforeLoad?: BeforeLoadFn<TParams>;
   head?: RouteHeadFn<TParams, TLoaderData> | RouteHeadConfig;
   transition?: boolean | TransitionProps;
   viewTransition?: boolean | 'always';
   keepalive?: boolean | KeepAliveProps;
+  /** Internal: marks this as a layout route */
+  __isLayout?: boolean;
 }
 declare module 'vue-router' {
   interface RouteMeta {
@@ -467,6 +526,20 @@ declare module 'vue-router' {
     __kimeshError?: unknown;
     /** Source layer name for layer-aware features */
     __kimeshLayer?: string;
+    /** Marks this route as a layout */
+    __kimeshIsLayout?: boolean;
+    /** Has pending component */
+    __kimeshHasPending?: boolean;
+    /** Pending delay in ms */
+    __kimeshPendingMs?: number;
+    /** Minimum pending duration in ms */
+    __kimeshPendingMinMs?: number;
+    /** Has beforeLoad function */
+    __kimeshHasBeforeLoad?: boolean;
+    /** Has head configuration */
+    __kimeshHasHead?: boolean;
+    /** Head is a function (vs static) */
+    __kimeshHeadIsFunction?: boolean;
   }
 }
 //#endregion
@@ -646,6 +719,52 @@ declare const queryPlugin: KimeshRuntimePlugin<QueryPluginOptions>;
  */
 declare function getCorePlugins(): KimeshRuntimePlugin<Record<string, unknown>>[];
 //#endregion
+//#region src/plugins/head.d.ts
+/**
+ * Head plugin options
+ */
+interface HeadPluginOptions {
+  /** Default title when no route title is set */
+  defaultTitle?: string;
+  /** Global title template (can be overridden by routes) */
+  titleTemplate?: string | ((title: string) => string);
+  /** Whether to merge layout head with page head */
+  mergeLayoutHead?: boolean;
+}
+/**
+ * Merge two head configurations
+ * Page head takes priority over layout head
+ */
+declare function mergeHeadConfigs(layoutHead: RouteHeadConfig | undefined, pageHead: RouteHeadConfig | undefined): RouteHeadConfig;
+/**
+ * Apply title template to title
+ */
+declare function applyTitleTemplate(title: string | undefined, template: string | ((title: string) => string) | undefined, defaultTitle?: string): string;
+/**
+ * Collect head configurations from matched routes
+ */
+declare function collectRouteHeads(route: RouteLocationNormalizedLoaded, kimeshApp: KimeshAppContext): RouteHeadConfig[];
+/**
+ * Merge all route heads into final config
+ */
+declare function mergeAllRouteHeads(heads: RouteHeadConfig[]): RouteHeadConfig;
+/**
+ * Apply head config to document (native DOM)
+ */
+declare function applyHeadConfigNative(config: RouteHeadConfig, options?: HeadPluginOptions): void;
+/**
+ * Create the head plugin
+ */
+declare function createHeadPlugin(options?: HeadPluginOptions): {
+  install(app: App, {
+    router,
+    kimeshApp
+  }: {
+    router: Router;
+    kimeshApp: KimeshAppContext;
+  }): void;
+};
+//#endregion
 //#region src/components/KmOutlet.d.ts
 /**
  * KmOutlet - Router view wrapper component
@@ -896,6 +1015,8 @@ declare const KmDeferred: vue13.DefineComponent<vue13.ExtractPropTypes<{
 //#region src/guards/loader-guard.d.ts
 interface LoaderGuardOptions {
   onError?: (error: Error, to: RouteLocationNormalized) => void;
+  /** Kimesh app context for storing loader data */
+  appContext?: KimeshAppContext;
 }
 /**
  * Create the loader navigation guard
@@ -906,6 +1027,7 @@ declare function createLoaderGuard(context: FullContext, options?: LoaderGuardOp
  */
 declare function installLoaderGuard(router: Router, context: FullContext, options?: {
   onError?: (error: Error, to: RouteLocationNormalized) => void;
+  appContext?: KimeshAppContext;
 }): () => void;
 //#endregion
 //#region src/composables/use-search.d.ts
@@ -1201,6 +1323,76 @@ declare function useNavigationGuard(guard: BeforeNavigationHandler): () => void;
  */
 declare function useAfterNavigation(callback: AfterNavigationHandler): () => void;
 //#endregion
+//#region src/composables/use-loader-data.d.ts
+/**
+ * Get loader data for the current route
+ */
+declare function useLoaderData<T = unknown>(): ComputedRef<T>;
+/**
+ * Get loader data from a specific route by path
+ */
+declare function useMatchLoaderData<T = unknown>(routePath: string): ComputedRef<T | undefined>;
+/**
+ * Get loader data from parent layout(s)
+ */
+declare function useLayoutData<T = unknown>(): ComputedRef<T | undefined>;
+/**
+ * Get all loader data from the route hierarchy
+ */
+declare function useRouteLoaderData(): ComputedRef<Record<string, unknown>>;
+//#endregion
+//#region src/types/layout.d.ts
+/**
+ * Layout loader data access result
+ */
+interface LayoutLoaderData<T = unknown> {
+  /** Loader data from the layout */
+  data: T;
+  /** Whether data is still loading */
+  isLoading: boolean;
+  /** Error if loader failed */
+  error: Error | null;
+}
+/**
+ * Match loader data access options
+ */
+interface UseMatchLoaderDataOptions {
+  /**
+   * Route path to get loader data from
+   * @example '/_dashboard' or '/posts'
+   */
+  routePath: string;
+}
+/**
+ * Layout route metadata for internal use
+ */
+interface LayoutRouteMeta {
+  /** This route is a layout */
+  __isLayout: true;
+  /** Pending component for this layout */
+  __pendingComponent?: () => Promise<{
+    default: Component;
+  }>;
+  /** Pending delay in ms */
+  __pendingMs?: number;
+  /** Minimum pending duration in ms */
+  __pendingMinMs?: number;
+  /** Context additions from beforeLoad */
+  __contextAdditions?: Record<string, unknown>;
+}
+/**
+ * Loader data storage key format
+ */
+type LoaderDataKey = `__loaderData:${string}`;
+/**
+ * Create a loader data storage key
+ */
+declare function createLoaderDataKey(routePath: string): LoaderDataKey;
+/**
+ * Type guard for layout route meta
+ */
+declare function isLayoutRouteMeta(meta: unknown): meta is LayoutRouteMeta;
+//#endregion
 //#region src/middleware/types.d.ts
 /**
  * Navigation redirect configuration
@@ -1459,4 +1651,4 @@ declare function createMiddlewareExecutor(appContext: KimeshAppContext): {
   executeChain(middlewares: RouteMiddleware[], context: MiddlewareContext): Promise<void | false | NavigationRedirect>;
 };
 //#endregion
-export { UseSearchReturn as $, RouteParams as $t, NavigateToOptions as A, ExtractRouteParams as At, STATE_KEY_PREFIX as B, LoaderFn as Bt, KnownMiddleware as C, createFileRoute as Ct, MiddlewareRegistry as D, createKimeshApp as Dt, MiddlewareOption as E, KIMESH_APP_CONTEXT_KEY as Et, NavigationErrorContext as F, InlineRouteMiddleware as Ft, tryUseKimeshApp as G, RouteDefinition as Gt, getKmStateKeys as H, ParamValueOneOrMore as Ht, NavigationMiddlewareOptions as I, KIMESH_CONTEXT_KEY as It, useRuntimeConfig as J, RouteHeadFn as Jt, useKimeshApp as K, RouteHeadConfig as Kt, useAfterNavigation as L, KimeshApp as Lt, RouteMiddleware as M, FullContext as Mt, TypedRouteMiddleware as N, HasParams as Nt, MiddlewareRegistryEntry as O, BeforeLoadContext as Ot, NavigationContext as P, InlineMiddlewareContext as Pt, useReactiveParams as Q, RouteNames as Qt, useNavigationGuard as R, KimeshContext as Rt, KimeshMiddlewareNames as S, useKimeshContext as St, MiddlewareDefinition as T, CreateKimeshAppOptionsExtended as Tt, hasKmState as U, ParamValueZeroOrMore as Ut, clearKmState as V, ParamValue as Vt, useState as W, ParamValueZeroOrOne as Wt, useNavigate as X, RouteLocationRaw as Xt, NavigateOptions as Y, RouteInfoByName as Yt, useParams as Z, RouteNamedMap as Zt, createMiddlewarePlugin as _, getPluginHooks as _t, RouteRecordRaw$1 as a, KimeshRuntimeHooks as an, KmLink as at, defineKimeshMiddleware as b, isKimeshRuntimePlugin as bt, onBeforeRouteUpdate as c, KimeshRuntimePluginMeta as cn, QueryPluginOptions as ct, useRouter$1 as d, NavigationErrorHookContext as dn, routerPlugin as dt, RouteParamsRaw as en, useSearch as et, createMiddlewareExecutor as f, NavigationHookContext as fn, applyPlugin as ft, MiddlewarePluginOptions as g, defineKimeshRuntimePlugin as gt, createMiddlewareContext as h, KIMESH_PLUGIN_INDICATOR as ht, RouteLocationNormalizedLoaded$1 as i, KimeshAppContext as in, KmDeferred as it, NavigationRedirect as j, FileRouteOptions as jt, MiddlewareResult as k, CreateKimeshAppOptions as kt, useLink as l, KimeshRuntimePluginResult as ln, getCorePlugins as lt, executeMiddlewareChain as m, applyPluginsWithParallel as mt, NavigationHookAfter as n, RouteRecordInfo as nn, createLoaderGuard as nt, Router$1 as o, KimeshRuntimePlugin as on, KmLinkProps as ot, executeMiddleware as p, RuntimeConfigPublic as pn, applyPlugins as pt, RuntimeConfig as q, RouteHeadContext as qt, RouteLocationNormalized$1 as r, SearchSchema as rn, installLoaderGuard as rt, onBeforeRouteLeave as s, KimeshRuntimePluginDefinition as sn, KmOutlet as st, NavigationGuard as t, RoutePath as tn, LoaderGuardOptions as tt, useRoute$1 as u, NavigationAfterHookContext as un, queryPlugin as ut, middlewarePlugin as v, getPluginMeta as vt, MiddlewareContext as w, defineRoute as wt, navigateTo as x, defineContext as xt, abortNavigation as y, getPluginName as yt, useNavigationMiddleware as z, LoaderContext as zt };
+export { hasKmState as $, HasParams as $t, NavigateToOptions as A, KimeshRuntimePluginMeta as An, applyPlugins as At, useLayoutData as B, createFileRoute as Bt, KnownMiddleware as C, RoutePath as Cn, mergeAllRouteHeads as Ct, MiddlewareRegistry as D, KimeshRuntimeHooks as Dn, queryPlugin as Dt, MiddlewareOption as E, KimeshAppContext as En, getCorePlugins as Et, LayoutRouteMeta as F, RuntimeConfigPublic as Fn, getPluginMeta as Ft, NavigationErrorContext as G, AugmentedContext as Gt, useMatchLoaderData as H, CreateKimeshAppOptionsExtended as Ht, LoaderDataKey as I, getPluginName as It, useNavigationGuard as J, BeforeLoadFn as Jt, NavigationMiddlewareOptions as K, BeforeLoadContext as Kt, UseMatchLoaderDataOptions as L, isKimeshRuntimePlugin as Lt, RouteMiddleware as M, NavigationAfterHookContext as Mn, KIMESH_PLUGIN_INDICATOR as Mt, TypedRouteMiddleware as N, NavigationErrorHookContext as Nn, defineKimeshRuntimePlugin as Nt, MiddlewareRegistryEntry as O, KimeshRuntimePlugin as On, routerPlugin as Ot, LayoutLoaderData as P, NavigationHookContext as Pn, getPluginHooks as Pt, getKmStateKeys as Q, FullContext as Qt, createLoaderDataKey as R, defineContext as Rt, KimeshMiddlewareNames as S, RouteParamsRaw as Sn, createHeadPlugin as St, MiddlewareDefinition as T, SearchSchema as Tn, QueryPluginOptions as Tt, useRouteLoaderData as U, KIMESH_APP_CONTEXT_KEY as Ut, useLoaderData as V, defineRoute as Vt, NavigationContext as W, createKimeshApp as Wt, STATE_KEY_PREFIX as X, ExtractRouteParams as Xt, useNavigationMiddleware as Y, CreateKimeshAppOptions as Yt, clearKmState as Z, FileRouteOptions as Zt, createMiddlewarePlugin as _, RouteInfoByName as _n, KmOutlet as _t, RouteRecordRaw$1 as a, LoaderContext as an, NavigateOptions as at, defineKimeshMiddleware as b, RouteNames as bn, applyTitleTemplate as bt, onBeforeRouteUpdate as c, ParamValueOneOrMore as cn, useReactiveParams as ct, useRouter$1 as d, PendingConfig as dn, LoaderGuardOptions as dt, InlineMiddlewareContext as en, useState as et, createMiddlewareExecutor as f, RouteContext as fn, createLoaderGuard as ft, MiddlewarePluginOptions as g, RouteHeadFn as gn, KmLinkProps as gt, createMiddlewareContext as h, RouteHeadContext as hn, KmLink as ht, RouteLocationNormalizedLoaded$1 as i, KimeshContext as in, useRuntimeConfig as it, NavigationRedirect as j, KimeshRuntimePluginResult as jn, applyPluginsWithParallel as jt, MiddlewareResult as k, KimeshRuntimePluginDefinition as kn, applyPlugin as kt, useLink as l, ParamValueZeroOrMore as ln, UseSearchReturn as lt, executeMiddlewareChain as m, RouteHeadConfig as mn, KmDeferred as mt, NavigationHookAfter as n, KIMESH_CONTEXT_KEY as nn, useKimeshApp as nt, Router$1 as o, LoaderFn as on, useNavigate as ot, executeMiddleware as p, RouteDefinition as pn, installLoaderGuard as pt, useAfterNavigation as q, BeforeLoadContextFull as qt, RouteLocationNormalized$1 as r, KimeshApp as rn, RuntimeConfig as rt, onBeforeRouteLeave as s, ParamValue as sn, useParams as st, NavigationGuard as t, InlineRouteMiddleware as tn, tryUseKimeshApp as tt, useRoute$1 as u, ParamValueZeroOrOne as un, useSearch as ut, middlewarePlugin as v, RouteLocationRaw as vn, HeadPluginOptions as vt, MiddlewareContext as w, RouteRecordInfo as wn, mergeHeadConfigs as wt, navigateTo as x, RouteParams as xn, collectRouteHeads as xt, abortNavigation as y, RouteNamedMap as yn, applyHeadConfigNative as yt, isLayoutRouteMeta as z, useKimeshContext as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as UseSearchReturn, $t as RouteParams, A as NavigateToOptions, At as ExtractRouteParams, B as STATE_KEY_PREFIX, Bt as LoaderFn, C as KnownMiddleware, Ct as createFileRoute, Dt as createKimeshApp, E as MiddlewareOption, Et as KIMESH_APP_CONTEXT_KEY, F as NavigationErrorContext, Ft as InlineRouteMiddleware, G as tryUseKimeshApp, Gt as RouteDefinition, H as getKmStateKeys, Ht as ParamValueOneOrMore, I as NavigationMiddlewareOptions, It as KIMESH_CONTEXT_KEY, J as useRuntimeConfig, Jt as RouteHeadFn, K as useKimeshApp, Kt as RouteHeadConfig, L as useAfterNavigation, Lt as KimeshApp, M as RouteMiddleware, Mt as FullContext, N as TypedRouteMiddleware, Nt as HasParams, Ot as BeforeLoadContext, P as NavigationContext, Pt as InlineMiddlewareContext, Q as useReactiveParams, Qt as RouteNames, R as useNavigationGuard, Rt as KimeshContext, S as KimeshMiddlewareNames, St as useKimeshContext, T as MiddlewareDefinition, Tt as CreateKimeshAppOptionsExtended, U as hasKmState, Ut as ParamValueZeroOrMore, V as clearKmState, Vt as ParamValue, W as useState, Wt as ParamValueZeroOrOne, X as useNavigate, Xt as RouteLocationRaw, Y as NavigateOptions, Yt as RouteInfoByName, Z as useParams, Zt as RouteNamedMap, _ as createMiddlewarePlugin, _t as getPluginHooks, a as RouteRecordRaw, an as KimeshRuntimeHooks, at as KmLink, b as defineKimeshMiddleware, bt as isKimeshRuntimePlugin, c as onBeforeRouteUpdate, cn as KimeshRuntimePluginMeta, ct as QueryPluginOptions, d as useRouter, dn as NavigationErrorHookContext, dt as routerPlugin, en as RouteParamsRaw, et as useSearch, f as createMiddlewareExecutor, fn as NavigationHookContext, ft as applyPlugin, g as MiddlewarePluginOptions, gt as defineKimeshRuntimePlugin, h as createMiddlewareContext, ht as KIMESH_PLUGIN_INDICATOR, i as RouteLocationNormalizedLoaded, in as KimeshAppContext, it as KmDeferred, j as NavigationRedirect, jt as FileRouteOptions, k as MiddlewareResult, kt as CreateKimeshAppOptions, l as useLink, ln as KimeshRuntimePluginResult, lt as getCorePlugins, mt as applyPluginsWithParallel, n as NavigationHookAfter, nn as RouteRecordInfo, nt as createLoaderGuard, o as Router, on as KimeshRuntimePlugin, ot as KmLinkProps, pn as RuntimeConfigPublic, pt as applyPlugins, q as RuntimeConfig, qt as RouteHeadContext, r as RouteLocationNormalized, rn as SearchSchema, rt as installLoaderGuard, s as onBeforeRouteLeave, sn as KimeshRuntimePluginDefinition, st as KmOutlet, t as NavigationGuard, tn as RoutePath, tt as LoaderGuardOptions, u as useRoute, un as NavigationAfterHookContext, ut as queryPlugin, v as middlewarePlugin, vt as getPluginMeta, w as MiddlewareContext, wt as defineRoute, x as navigateTo, xt as defineContext, y as abortNavigation, yt as getPluginName, z as useNavigationMiddleware, zt as LoaderContext } from "./index-9xJk3v3Z.mjs";
-export { BeforeLoadContext, CreateKimeshAppOptions, CreateKimeshAppOptionsExtended, ExtractRouteParams, FileRouteOptions, FullContext, HasParams, InlineMiddlewareContext, InlineRouteMiddleware, KIMESH_APP_CONTEXT_KEY, KIMESH_CONTEXT_KEY, KIMESH_PLUGIN_INDICATOR, KimeshApp, KimeshAppContext, KimeshContext, KimeshMiddlewareNames, KimeshRuntimeHooks, KimeshRuntimePlugin, KimeshRuntimePluginDefinition, KimeshRuntimePluginMeta, KimeshRuntimePluginResult, KmDeferred, KmLink, KmLinkProps, KmOutlet, KnownMiddleware, LoaderContext, LoaderFn, LoaderGuardOptions, MiddlewareContext, MiddlewareDefinition, MiddlewareOption, MiddlewarePluginOptions, MiddlewareResult, NavigateOptions, NavigateToOptions, NavigationAfterHookContext, NavigationContext, NavigationErrorContext, NavigationErrorHookContext, NavigationGuard, NavigationHookAfter, NavigationHookContext, NavigationMiddlewareOptions, NavigationRedirect, ParamValue, ParamValueOneOrMore, ParamValueZeroOrMore, ParamValueZeroOrOne, QueryPluginOptions, RouteDefinition, RouteHeadConfig, RouteHeadContext, RouteHeadFn, RouteInfoByName, RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteLocationRaw, RouteMiddleware, RouteNamedMap, RouteNames, RouteParams, RouteParamsRaw, RoutePath, RouteRecordInfo, RouteRecordRaw, Router, RuntimeConfig, RuntimeConfigPublic, STATE_KEY_PREFIX, SearchSchema, TypedRouteMiddleware, UseSearchReturn, abortNavigation, applyPlugin, applyPlugins, applyPluginsWithParallel, clearKmState, createFileRoute, createKimeshApp, createLoaderGuard, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineContext, defineKimeshMiddleware, defineKimeshRuntimePlugin, defineRoute, getCorePlugins, getKmStateKeys, getPluginHooks, getPluginMeta, getPluginName, hasKmState, installLoaderGuard, isKimeshRuntimePlugin, middlewarePlugin, navigateTo, onBeforeRouteLeave, onBeforeRouteUpdate, queryPlugin, routerPlugin, tryUseKimeshApp, useAfterNavigation, useKimeshApp, useKimeshContext, useLink, useNavigate, useNavigationGuard, useNavigationMiddleware, useParams, useReactiveParams, useRoute, useRouter, useRuntimeConfig, useSearch, useState };
+import { $ as hasKmState, $t as HasParams, A as NavigateToOptions, An as KimeshRuntimePluginMeta, At as applyPlugins, B as useLayoutData, Bt as createFileRoute, C as KnownMiddleware, Cn as RoutePath, Ct as mergeAllRouteHeads, Dn as KimeshRuntimeHooks, Dt as queryPlugin, E as MiddlewareOption, En as KimeshAppContext, Et as getCorePlugins, F as LayoutRouteMeta, Fn as RuntimeConfigPublic, Ft as getPluginMeta, G as NavigationErrorContext, Gt as AugmentedContext, H as useMatchLoaderData, Ht as CreateKimeshAppOptionsExtended, I as LoaderDataKey, It as getPluginName, J as useNavigationGuard, Jt as BeforeLoadFn, K as NavigationMiddlewareOptions, Kt as BeforeLoadContext, L as UseMatchLoaderDataOptions, Lt as isKimeshRuntimePlugin, M as RouteMiddleware, Mn as NavigationAfterHookContext, Mt as KIMESH_PLUGIN_INDICATOR, N as TypedRouteMiddleware, Nn as NavigationErrorHookContext, Nt as defineKimeshRuntimePlugin, On as KimeshRuntimePlugin, Ot as routerPlugin, P as LayoutLoaderData, Pn as NavigationHookContext, Pt as getPluginHooks, Q as getKmStateKeys, Qt as FullContext, R as createLoaderDataKey, Rt as defineContext, S as KimeshMiddlewareNames, Sn as RouteParamsRaw, St as createHeadPlugin, T as MiddlewareDefinition, Tn as SearchSchema, Tt as QueryPluginOptions, U as useRouteLoaderData, Ut as KIMESH_APP_CONTEXT_KEY, V as useLoaderData, Vt as defineRoute, W as NavigationContext, Wt as createKimeshApp, X as STATE_KEY_PREFIX, Xt as ExtractRouteParams, Y as useNavigationMiddleware, Yt as CreateKimeshAppOptions, Z as clearKmState, Zt as FileRouteOptions, _ as createMiddlewarePlugin, _n as RouteInfoByName, _t as KmOutlet, a as RouteRecordRaw, an as LoaderContext, at as NavigateOptions, b as defineKimeshMiddleware, bn as RouteNames, bt as applyTitleTemplate, c as onBeforeRouteUpdate, cn as ParamValueOneOrMore, ct as useReactiveParams, d as useRouter, dn as PendingConfig, dt as LoaderGuardOptions, en as InlineMiddlewareContext, et as useState, f as createMiddlewareExecutor, fn as RouteContext, ft as createLoaderGuard, g as MiddlewarePluginOptions, gn as RouteHeadFn, gt as KmLinkProps, h as createMiddlewareContext, hn as RouteHeadContext, ht as KmLink, i as RouteLocationNormalizedLoaded, in as KimeshContext, it as useRuntimeConfig, j as NavigationRedirect, jn as KimeshRuntimePluginResult, jt as applyPluginsWithParallel, k as MiddlewareResult, kn as KimeshRuntimePluginDefinition, kt as applyPlugin, l as useLink, ln as ParamValueZeroOrMore, lt as UseSearchReturn, mn as RouteHeadConfig, mt as KmDeferred, n as NavigationHookAfter, nn as KIMESH_CONTEXT_KEY, nt as useKimeshApp, o as Router, on as LoaderFn, ot as useNavigate, pn as RouteDefinition, pt as installLoaderGuard, q as useAfterNavigation, qt as BeforeLoadContextFull, r as RouteLocationNormalized, rn as KimeshApp, rt as RuntimeConfig, s as onBeforeRouteLeave, sn as ParamValue, st as useParams, t as NavigationGuard, tn as InlineRouteMiddleware, tt as tryUseKimeshApp, u as useRoute, un as ParamValueZeroOrOne, ut as useSearch, v as middlewarePlugin, vn as RouteLocationRaw, vt as HeadPluginOptions, w as MiddlewareContext, wn as RouteRecordInfo, wt as mergeHeadConfigs, x as navigateTo, xn as RouteParams, xt as collectRouteHeads, y as abortNavigation, yn as RouteNamedMap, yt as applyHeadConfigNative, z as isLayoutRouteMeta, zt as useKimeshContext } from "./index-Bi0AaYQy.mjs";
+export { AugmentedContext, BeforeLoadContext, BeforeLoadContextFull, BeforeLoadFn, CreateKimeshAppOptions, CreateKimeshAppOptionsExtended, ExtractRouteParams, FileRouteOptions, FullContext, HasParams, HeadPluginOptions, InlineMiddlewareContext, InlineRouteMiddleware, KIMESH_APP_CONTEXT_KEY, KIMESH_CONTEXT_KEY, KIMESH_PLUGIN_INDICATOR, KimeshApp, KimeshAppContext, KimeshContext, KimeshMiddlewareNames, KimeshRuntimeHooks, KimeshRuntimePlugin, KimeshRuntimePluginDefinition, KimeshRuntimePluginMeta, KimeshRuntimePluginResult, KmDeferred, KmLink, KmLinkProps, KmOutlet, KnownMiddleware, LayoutLoaderData, LayoutRouteMeta, LoaderContext, LoaderDataKey, LoaderFn, LoaderGuardOptions, MiddlewareContext, MiddlewareDefinition, MiddlewareOption, MiddlewarePluginOptions, MiddlewareResult, NavigateOptions, NavigateToOptions, NavigationAfterHookContext, NavigationContext, NavigationErrorContext, NavigationErrorHookContext, NavigationGuard, NavigationHookAfter, NavigationHookContext, NavigationMiddlewareOptions, NavigationRedirect, ParamValue, ParamValueOneOrMore, ParamValueZeroOrMore, ParamValueZeroOrOne, PendingConfig, QueryPluginOptions, RouteContext, RouteDefinition, RouteHeadConfig, RouteHeadContext, RouteHeadFn, RouteInfoByName, RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteLocationRaw, RouteMiddleware, RouteNamedMap, RouteNames, RouteParams, RouteParamsRaw, RoutePath, RouteRecordInfo, RouteRecordRaw, Router, RuntimeConfig, RuntimeConfigPublic, STATE_KEY_PREFIX, SearchSchema, TypedRouteMiddleware, UseMatchLoaderDataOptions, UseSearchReturn, abortNavigation, applyHeadConfigNative, applyPlugin, applyPlugins, applyPluginsWithParallel, applyTitleTemplate, clearKmState, collectRouteHeads, createFileRoute, createHeadPlugin, createKimeshApp, createLoaderDataKey, createLoaderGuard, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineContext, defineKimeshMiddleware, defineKimeshRuntimePlugin, defineRoute, getCorePlugins, getKmStateKeys, getPluginHooks, getPluginMeta, getPluginName, hasKmState, installLoaderGuard, isKimeshRuntimePlugin, isLayoutRouteMeta, mergeAllRouteHeads, mergeHeadConfigs, middlewarePlugin, navigateTo, onBeforeRouteLeave, onBeforeRouteUpdate, queryPlugin, routerPlugin, tryUseKimeshApp, useAfterNavigation, useKimeshApp, useKimeshContext, useLayoutData, useLink, useLoaderData, useMatchLoaderData, useNavigate, useNavigationGuard, useNavigationMiddleware, useParams, useReactiveParams, useRoute, useRouteLoaderData, useRouter, useRuntimeConfig, useSearch, useState };

package/dist/index.mjs

@@ -1,22 +1,121 @@
-import { a as KIMESH_PLUGIN_INDICATOR, c as getPluginMeta, i as createMiddlewareContext, l as getPluginName, n as middlewarePlugin, o as defineKimeshRuntimePlugin, s as getPluginHooks, t as createMiddlewarePlugin, u as isKimeshRuntimePlugin } from "./plugin-BfxCqV0B.mjs";
+import { a as KIMESH_PLUGIN_INDICATOR, c as getPluginMeta, i as createMiddlewareContext, l as getPluginName, n as middlewarePlugin, o as defineKimeshRuntimePlugin, s as getPluginHooks, t as createMiddlewarePlugin, u as isKimeshRuntimePlugin } from "./plugin-0r5-meph.mjs";
 import { a as defineKimeshMiddleware, i as abortNavigation, o as navigateTo, t as createMiddlewareExecutor } from "./middleware-DdlzhfiB.mjs";
 import { KeepAlive, Suspense, Transition, computed, createApp, defineComponent, h, inject, isRef, nextTick, onErrorCaptured, reactive, ref, toRef } from "vue";
 import { RouterLink, RouterView, createRouter, createWebHashHistory, createWebHistory, onBeforeRouteLeave, onBeforeRouteUpdate, useLink, useRoute, useRoute as useRoute$1, useRouter, useRouter as useRouter$1 } from "vue-router";
 import { QueryClient, VueQueryPlugin } from "@tanstack/vue-query";
 import { createHooks } from "hookable";
 
-//#region src/guards/loader-guard.ts
+//#region src/types/layout.ts
 /**
-* Safely parse input with schema, returning input on failure
+* Create a loader data storage key
 */
-function safeParse(schema, input) {
-	try {
-		return schema.parse(input);
-	} catch {
-		return input;
+function createLoaderDataKey(routePath) {
+	return `__loaderData:${routePath}`;
+}
+/**
+* Type guard for layout route meta
+*/
+function isLayoutRouteMeta(meta) {
+	return typeof meta === "object" && meta !== null && "__isLayout" in meta;
+}
+
+//#endregion
+//#region src/composables/use-loader-data.ts
+/**
+* @kimesh/router-runtime - useLoaderData composable
+*
+* Access loader data from the current route or parent layouts.
+*/
+const LOADER_DATA_PREFIX = "__loaderData:";
+function useKimeshAppRequired(composableName) {
+	const kimeshApp = inject(KIMESH_APP_CONTEXT_KEY);
+	if (!kimeshApp) throw new Error(`[kimesh] ${composableName} must be used within a Kimesh app`);
+	return kimeshApp;
+}
+/**
+* Get loader data for the current route
+*/
+function useLoaderData() {
+	const route = useRoute$1();
+	const kimeshApp = useKimeshAppRequired("useLoaderData");
+	return computed(() => {
+		const key = createLoaderDataKey(route.path);
+		return kimeshApp._state[key];
+	});
+}
+/**
+* Get loader data from a specific route by path
+*/
+function useMatchLoaderData(routePath) {
+	const kimeshApp = useKimeshAppRequired("useMatchLoaderData");
+	return computed(() => {
+		const key = createLoaderDataKey(routePath);
+		return kimeshApp._state[key];
+	});
+}
+/**
+* Get loader data from parent layout(s)
+*/
+function useLayoutData() {
+	const route = useRoute$1();
+	const kimeshApp = useKimeshAppRequired("useLayoutData");
+	return computed(() => {
+		const parentLayout = findParentLayout(route);
+		if (!parentLayout) return void 0;
+		const key = createLoaderDataKey(parentLayout.path);
+		return kimeshApp._state[key];
+	});
+}
+/**
+* Get all loader data from the route hierarchy
+*/
+function useRouteLoaderData() {
+	const route = useRoute$1();
+	const kimeshApp = useKimeshAppRequired("useRouteLoaderData");
+	return computed(() => {
+		const result = {};
+		for (const matched of route.matched) {
+			const key = createLoaderDataKey(matched.path);
+			if (kimeshApp._state[key] !== void 0) result[matched.path] = kimeshApp._state[key];
+		}
+		return result;
+	});
+}
+/**
+* Find the parent layout route in matched routes
+*/
+function findParentLayout(route) {
+	const currentIndex = route.matched.length - 1;
+	for (let i = currentIndex - 1; i >= 0; i--) {
+		const matched = route.matched[i];
+		if (matched.meta?.__kimeshIsLayout) return matched;
 	}
+	return null;
 }
 /**
+* Store loader data for a route
+* Used internally by loader guard
+*/
+function storeLoaderData(kimeshApp, routePath, data) {
+	const key = createLoaderDataKey(routePath);
+	kimeshApp._state[key] = data;
+}
+/**
+* Clear loader data for routes not in the new matched routes
+* Used internally during navigation
+*/
+function clearStaleLoaderData(kimeshApp, newMatchedPaths) {
+	const keysToDelete = [];
+	for (const key of Object.keys(kimeshApp._state)) if (key.startsWith(LOADER_DATA_PREFIX)) {
+		const routePath = key.slice(13);
+		if (!newMatchedPaths.has(routePath)) keysToDelete.push(key);
+	}
+	for (const key of keysToDelete) delete kimeshApp._state[key];
+}
+
+//#endregion
+//#region src/guards/loader-guard.ts
+/**
 * Validate search params using the provided schema
 */
 function validateSearchParams(query, schema) {
@@ -24,12 +123,16 @@ function validateSearchParams(query, schema) {
 	if (schema.safeParse) {
 		const result = schema.safeParse(query);
 		if (result.success && result.data !== void 0) return result.data;
-		return safeParse(schema, {});
 	}
-	const parsed = safeParse(schema, query);
-	if (parsed !== query) return parsed;
-	const defaults = safeParse(schema, {});
-	return defaults !== query ? defaults : query;
+	try {
+		return schema.parse(query);
+	} catch {
+		try {
+			return schema.parse({});
+		} catch {
+			return query;
+		}
+	}
 }
 /**
 * Collect loaders from matched route records
@@ -40,12 +143,28 @@ function collectLoaders(to) {
 		const routeDef = record.meta?.__kimesh;
 		if (routeDef?.loader) loaders.push({
 			loader: routeDef.loader,
-			routeDef
+			routeDef,
+			routeRecord: record
 		});
 	}
 	return loaders;
 }
 /**
+* Collect beforeLoad functions from matched route records (in order)
+*/
+function collectBeforeLoads(to) {
+	const beforeLoads = [];
+	for (const record of to.matched) {
+		const routeDef = record.meta?.__kimesh;
+		if (routeDef?.beforeLoad) beforeLoads.push({
+			beforeLoad: routeDef.beforeLoad,
+			routeDef,
+			routeRecord: record
+		});
+	}
+	return beforeLoads;
+}
+/**
 * Check if error is an AbortError
 */
 function isAbortError(error) {
@@ -55,20 +174,45 @@ function isAbortError(error) {
 * Create the loader navigation guard
 */
 function createLoaderGuard(context, options = {}) {
-	const { onError } = options;
+	const { onError, appContext } = options;
 	return async function loaderGuard(to, _from, abortController) {
+		const beforeLoads = collectBeforeLoads(to);
 		const loaders = collectLoaders(to);
-		if (loaders.length === 0) return;
-		await Promise.all(loaders.map(async ({ loader, routeDef }) => {
+		if (appContext) clearStaleLoaderData(appContext, new Set(to.matched.map((r) => r.path)));
+		if (beforeLoads.length === 0 && loaders.length === 0) return;
+		let accumulatedContext = { ...context };
+		for (const { beforeLoad, routeDef } of beforeLoads) {
+			const search = validateSearchParams(to.query, routeDef.validateSearch);
+			try {
+				const result = await beforeLoad({
+					params: to.params,
+					search,
+					context: accumulatedContext,
+					signal: abortController.signal
+				});
+				if (result && typeof result === "object") accumulatedContext = {
+					...accumulatedContext,
+					...result
+				};
+			} catch (error) {
+				if (isAbortError(error)) throw error;
+				console.error("[kimesh] beforeLoad error:", error);
+				onError?.(error, to);
+				to.meta.__kimeshError = error;
+				return;
+			}
+		}
+		await Promise.all(loaders.map(async ({ loader, routeDef, routeRecord }) => {
 			const search = validateSearchParams(to.query, routeDef.validateSearch);
 			const loaderContext = {
 				params: to.params,
 				search,
-				context,
+				context: accumulatedContext,
 				signal: abortController.signal
 			};
 			try {
-				await loader(loaderContext);
+				const data = await loader(loaderContext);
+				if (appContext && data !== void 0) storeLoaderData(appContext, routeRecord.path, data);
 			} catch (error) {
 				if (isAbortError(error)) throw error;
 				console.error("[kimesh] Loader error:", error);
@@ -89,7 +233,10 @@ function installLoaderGuard(router, context, options) {
 	});
 	const removeBeforeResolve = router.beforeResolve(async (to, from) => {
 		if (!abortController) abortController = new AbortController();
-		const guard = createLoaderGuard(context, { onError: options?.onError });
+		const guard = createLoaderGuard(context, {
+			onError: options?.onError,
+			appContext: options?.appContext
+		});
 		try {
 			await guard(to, from, abortController);
 		} catch (error) {
@@ -247,7 +394,6 @@ async function createKimeshApp(options) {
 		routes,
 		scrollBehavior
 	});
-	const removeLoaderGuard = installLoaderGuard(router, fullContext, { onError: (error, to) => console.error(`[Kimesh] Loader error for ${to.path}:`, error) });
 	const vueApp = createApp({ render: () => h(rootComponent) });
 	const hooks = createHooks();
 	const appContext = {
@@ -271,6 +417,10 @@ async function createKimeshApp(options) {
 			return vueApp.runWithContext(fn);
 		}
 	};
+	const removeLoaderGuard = installLoaderGuard(router, fullContext, {
+		onError: (error, to) => console.error(`[Kimesh] Loader error for ${to.path}:`, error),
+		appContext
+	});
 	if (plugins.length > 0) await applyPlugins(appContext, plugins);
 	await hooks.callHook("app:created", vueApp);
 	vueApp.provide(KIMESH_CONTEXT_KEY, fullContext);
@@ -589,11 +739,161 @@ const viewTransitionsPlugin = defineKimeshRuntimePlugin({
 });
 
 //#endregion
-//#region src/components/KmOutlet.ts
+//#region src/plugins/head.ts
+/**
+* Merge two head configurations
+* Page head takes priority over layout head
+*/
+function mergeHeadConfigs(layoutHead, pageHead) {
+	if (!layoutHead && !pageHead) return {};
+	if (!layoutHead) return pageHead;
+	if (!pageHead) return layoutHead;
+	return {
+		title: pageHead.title ?? layoutHead.title,
+		titleTemplate: pageHead.titleTemplate ?? layoutHead.titleTemplate,
+		meta: mergeMetaTags(layoutHead.meta, pageHead.meta),
+		link: mergeLinkTags(layoutHead.link, pageHead.link),
+		script: [...layoutHead.script || [], ...pageHead.script || []],
+		style: [...layoutHead.style || [], ...pageHead.style || []],
+		htmlAttrs: {
+			...layoutHead.htmlAttrs,
+			...pageHead.htmlAttrs
+		},
+		bodyAttrs: {
+			...layoutHead.bodyAttrs,
+			...pageHead.bodyAttrs
+		}
+	};
+}
+/**
+* Generic tag merger with deduplication
+*/
+function mergeTagsWithDedup(layoutTags, pageTags, getKey) {
+	if (!layoutTags && !pageTags) return void 0;
+	if (!layoutTags) return pageTags;
+	if (!pageTags) return layoutTags;
+	const tagMap = /* @__PURE__ */ new Map();
+	for (const tag of layoutTags) tagMap.set(getKey(tag), tag);
+	for (const tag of pageTags) tagMap.set(getKey(tag), tag);
+	return Array.from(tagMap.values());
+}
+/**
+* Merge meta tags with deduplication
+*/
+function mergeMetaTags(layoutMeta, pageMeta) {
+	return mergeTagsWithDedup(layoutMeta, pageMeta, getMetaKey);
+}
+/**
+* Get unique key for a meta tag
+*/
+function getMetaKey(tag) {
+	if (tag.name) return `name:${tag.name}`;
+	if (tag.property) return `property:${tag.property}`;
+	if (tag.charset) return "charset";
+	if (tag["http-equiv"]) return `http-equiv:${tag["http-equiv"]}`;
+	return JSON.stringify(tag);
+}
+/**
+* Merge link tags with deduplication
+*/
+function mergeLinkTags(layoutLink, pageLink) {
+	return mergeTagsWithDedup(layoutLink, pageLink, getLinkKey);
+}
 /**
-* Check if View Transitions API is supported
+* Get unique key for a link tag
 */
-const supportsViewTransitions = () => typeof document !== "undefined" && "startViewTransition" in document;
+function getLinkKey(tag) {
+	if (tag.rel === "canonical") return "canonical";
+	if (tag.rel === "icon" && tag.sizes) return `icon:${tag.sizes}`;
+	if (tag.hreflang) return `alternate:${tag.hreflang}`;
+	return `${tag.rel}:${tag.href}`;
+}
+/**
+* Apply title template to title
+*/
+function applyTitleTemplate(title, template, defaultTitle) {
+	const resolvedTitle = title ?? defaultTitle ?? "";
+	if (!template) return resolvedTitle;
+	if (typeof template === "function") return template(resolvedTitle);
+	return template.replace(/%s/g, resolvedTitle);
+}
+/**
+* Collect head configurations from matched routes
+*/
+function collectRouteHeads(route, kimeshApp) {
+	const heads = [];
+	for (const matched of route.matched) {
+		const routeDef = matched.meta?.__kimesh;
+		if (!routeDef?.head) continue;
+		const loaderDataKey = createLoaderDataKey(matched.path);
+		const loaderData = kimeshApp._state[loaderDataKey];
+		const headContext = {
+			params: route.params,
+			loaderData,
+			route
+		};
+		let headConfig;
+		if (typeof routeDef.head === "function") headConfig = routeDef.head(headContext);
+		else headConfig = routeDef.head;
+		heads.push(headConfig);
+	}
+	return heads;
+}
+/**
+* Merge all route heads into final config
+*/
+function mergeAllRouteHeads(heads) {
+	if (heads.length === 0) return {};
+	if (heads.length === 1) return heads[0];
+	return heads.reduce((merged, current) => mergeHeadConfigs(merged, current), {});
+}
+/**
+* Apply head config to document (native DOM)
+*/
+function applyHeadConfigNative(config, options = {}) {
+	const finalTitle = applyTitleTemplate(config.title, config.titleTemplate ?? options.titleTemplate, options.defaultTitle);
+	if (finalTitle) document.title = finalTitle;
+	if (config.meta) for (const meta of config.meta) updateMetaTag(meta);
+	if (config.htmlAttrs) {
+		for (const [key, value] of Object.entries(config.htmlAttrs)) if (value !== void 0) document.documentElement.setAttribute(key, value);
+	}
+	if (config.bodyAttrs) {
+		for (const [key, value] of Object.entries(config.bodyAttrs)) if (value !== void 0) document.body.setAttribute(key, value);
+	}
+}
+/**
+* Update or create a meta tag
+*/
+function updateMetaTag(meta) {
+	let selector;
+	if (meta.name) selector = `meta[name="${meta.name}"]`;
+	else if (meta.property) selector = `meta[property="${meta.property}"]`;
+	else if (meta.charset) selector = "meta[charset]";
+	else if (meta["http-equiv"]) selector = `meta[http-equiv="${meta["http-equiv"]}"]`;
+	else return;
+	let element = document.head.querySelector(selector);
+	if (!element) {
+		element = document.createElement("meta");
+		document.head.appendChild(element);
+	}
+	for (const [key, value] of Object.entries(meta)) if (value !== void 0) element.setAttribute(key, value);
+}
+/**
+* Create the head plugin
+*/
+function createHeadPlugin(options = {}) {
+	return { install(app, { router, kimeshApp }) {
+		router.afterEach((to) => {
+			applyHeadConfigNative(mergeAllRouteHeads(collectRouteHeads(to, kimeshApp)), options);
+		});
+	} };
+}
+
+//#endregion
+//#region src/components/KmOutlet.ts
+function supportsViewTransitions() {
+	return typeof document !== "undefined" && "startViewTransition" in document;
+}
 /**
 * KmOutlet - Router view wrapper component
 * Renders the matched route component with optional transitions and keepalive
@@ -1138,7 +1438,11 @@ function clearKmState(keys) {
 	const app = tryUseKimeshApp();
 	if (!app?._state) return;
 	const allStateKeys = getKmStateKeys();
-	const keysToDelete = keys === void 0 ? allStateKeys : typeof keys === "function" ? allStateKeys.filter(keys) : Array.isArray(keys) ? keys : [keys];
+	let keysToDelete;
+	if (keys === void 0) keysToDelete = allStateKeys;
+	else if (typeof keys === "function") keysToDelete = allStateKeys.filter(keys);
+	else if (Array.isArray(keys)) keysToDelete = keys;
+	else keysToDelete = [keys];
 	for (const key of keysToDelete) {
 		const prefixedKey = STATE_KEY_PREFIX + key;
 		if (prefixedKey in app._state) delete app._state[prefixedKey];
@@ -1239,4 +1543,4 @@ function useAfterNavigation(callback) {
 }
 
 //#endregion
-export { KIMESH_APP_CONTEXT_KEY, KIMESH_CONTEXT_KEY, KIMESH_PLUGIN_INDICATOR, KmDeferred, KmLink, KmOutlet, STATE_KEY_PREFIX, abortNavigation, applyPlugin, applyPlugins, applyPluginsWithParallel, clearKmState, createFileRoute, createKimeshApp, createLoaderGuard, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineContext, defineKimeshMiddleware, defineKimeshRuntimePlugin, defineRoute, getCorePlugins, getKmStateKeys, getPluginHooks, getPluginMeta, getPluginName, hasKmState, installLoaderGuard, isKimeshRuntimePlugin, middlewarePlugin, navigateTo, onBeforeRouteLeave, onBeforeRouteUpdate, queryPlugin, routerPlugin, tryUseKimeshApp, useAfterNavigation, useKimeshApp, useKimeshContext, useLink, useNavigate, useNavigationGuard, useNavigationMiddleware, useParams, useReactiveParams, useRoute, useRouter, useRuntimeConfig, useSearch, useState };
+export { KIMESH_APP_CONTEXT_KEY, KIMESH_CONTEXT_KEY, KIMESH_PLUGIN_INDICATOR, KmDeferred, KmLink, KmOutlet, STATE_KEY_PREFIX, abortNavigation, applyHeadConfigNative, applyPlugin, applyPlugins, applyPluginsWithParallel, applyTitleTemplate, clearKmState, collectRouteHeads, createFileRoute, createHeadPlugin, createKimeshApp, createLoaderDataKey, createLoaderGuard, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineContext, defineKimeshMiddleware, defineKimeshRuntimePlugin, defineRoute, getCorePlugins, getKmStateKeys, getPluginHooks, getPluginMeta, getPluginName, hasKmState, installLoaderGuard, isKimeshRuntimePlugin, isLayoutRouteMeta, mergeAllRouteHeads, mergeHeadConfigs, middlewarePlugin, navigateTo, onBeforeRouteLeave, onBeforeRouteUpdate, queryPlugin, routerPlugin, tryUseKimeshApp, useAfterNavigation, useKimeshApp, useKimeshContext, useLayoutData, useLink, useLoaderData, useMatchLoaderData, useNavigate, useNavigationGuard, useNavigationMiddleware, useParams, useReactiveParams, useRoute, useRouteLoaderData, useRouter, useRuntimeConfig, useSearch, useState };

package/dist/middleware/index.d.mts

@@ -1,2 +1,2 @@
-import { A as NavigateToOptions, C as KnownMiddleware, D as MiddlewareRegistry, E as MiddlewareOption, M as RouteMiddleware, N as TypedRouteMiddleware, O as MiddlewareRegistryEntry, S as KimeshMiddlewareNames, T as MiddlewareDefinition, _ as createMiddlewarePlugin, b as defineKimeshMiddleware, f as createMiddlewareExecutor, g as MiddlewarePluginOptions, h as createMiddlewareContext, j as NavigationRedirect, k as MiddlewareResult, m as executeMiddlewareChain, p as executeMiddleware, v as middlewarePlugin, w as MiddlewareContext, x as navigateTo, y as abortNavigation } from "../index-9xJk3v3Z.mjs";
+import { A as NavigateToOptions, C as KnownMiddleware, D as MiddlewareRegistry, E as MiddlewareOption, M as RouteMiddleware, N as TypedRouteMiddleware, O as MiddlewareRegistryEntry, S as KimeshMiddlewareNames, T as MiddlewareDefinition, _ as createMiddlewarePlugin, b as defineKimeshMiddleware, f as createMiddlewareExecutor, g as MiddlewarePluginOptions, h as createMiddlewareContext, j as NavigationRedirect, k as MiddlewareResult, m as executeMiddlewareChain, p as executeMiddleware, v as middlewarePlugin, w as MiddlewareContext, x as navigateTo, y as abortNavigation } from "../index-Bi0AaYQy.mjs";
 export { KimeshMiddlewareNames, KnownMiddleware, MiddlewareContext, MiddlewareDefinition, MiddlewareOption, MiddlewarePluginOptions, MiddlewareRegistry, MiddlewareRegistryEntry, MiddlewareResult, NavigateToOptions, NavigationRedirect, RouteMiddleware, TypedRouteMiddleware, abortNavigation, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };

package/dist/middleware/index.mjs

@@ -1,4 +1,4 @@
-import { i as createMiddlewareContext, n as middlewarePlugin, t as createMiddlewarePlugin } from "../plugin-BfxCqV0B.mjs";
+import { i as createMiddlewareContext, n as middlewarePlugin, t as createMiddlewarePlugin } from "../plugin-0r5-meph.mjs";
 import { a as defineKimeshMiddleware, i as abortNavigation, n as executeMiddleware, o as navigateTo, r as executeMiddlewareChain, t as createMiddlewareExecutor } from "../middleware-DdlzhfiB.mjs";
 
 export { abortNavigation, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };

package/dist/middleware/plugin.d.mts

@@ -1,2 +1,2 @@
-import { _ as createMiddlewarePlugin, g as MiddlewarePluginOptions, v as middlewarePlugin } from "../index-9xJk3v3Z.mjs";
+import { _ as createMiddlewarePlugin, g as MiddlewarePluginOptions, v as middlewarePlugin } from "../index-Bi0AaYQy.mjs";
 export { MiddlewarePluginOptions, createMiddlewarePlugin, middlewarePlugin as default, middlewarePlugin };

package/dist/middleware/plugin.mjs

@@ -1,3 +1,3 @@
-import { n as middlewarePlugin, r as plugin_default, t as createMiddlewarePlugin } from "../plugin-BfxCqV0B.mjs";
+import { n as middlewarePlugin, r as plugin_default, t as createMiddlewarePlugin } from "../plugin-0r5-meph.mjs";
 
 export { createMiddlewarePlugin, plugin_default as default, middlewarePlugin };

package/dist/{plugin-BfxCqV0B.mjs → plugin-0r5-meph.mjs}

@@ -171,36 +171,31 @@ async function extractRouteMiddleware(route, namedMiddleware) {
 	return normalizeMiddleware(middlewareOption, namedMiddleware);
 }
 /**
+* Load named middleware by name
+*/
+async function loadNamedMiddleware(name, namedMiddleware) {
+	const loader = namedMiddleware[name];
+	if (!loader) {
+		if (__KIMESH_DEV__) console.warn(`[Kimesh] Unknown middleware: ${name}`);
+		return null;
+	}
+	return loader();
+}
+/**
 * Normalize middleware to array of functions
 */
 async function normalizeMiddleware(middleware, namedMiddleware) {
-	const result = [];
 	if (typeof middleware === "string") {
-		const loader = namedMiddleware[middleware];
-		if (!loader) {
-			if (__KIMESH_DEV__) console.warn(`[Kimesh] Unknown middleware: ${middleware}`);
-			return [];
-		}
-		const mw = await loader();
-		result.push(mw);
-		return result;
-	}
-	if (typeof middleware === "function") {
-		result.push(middleware);
-		return result;
-	}
-	if (Array.isArray(middleware)) {
-		for (const item of middleware) if (typeof item === "string") {
-			const loader = namedMiddleware[item];
-			if (!loader) {
-				if (__KIMESH_DEV__) console.warn(`[Kimesh] Unknown middleware: ${item}`);
-				continue;
-			}
-			const mw = await loader();
-			result.push(mw);
-		} else if (typeof item === "function") result.push(item);
-		return result;
+		const mw = await loadNamedMiddleware(middleware, namedMiddleware);
+		return mw ? [mw] : [];
 	}
+	if (typeof middleware === "function") return [middleware];
+	if (!Array.isArray(middleware)) return [];
+	const result = [];
+	for (const item of middleware) if (typeof item === "string") {
+		const mw = await loadNamedMiddleware(item, namedMiddleware);
+		if (mw) result.push(mw);
+	} else if (typeof item === "function") result.push(item);
 	return result;
 }
 var plugin_default = middlewarePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimesh/router-runtime",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "Runtime router for Kimesh framework",
   "repository": {
     "type": "git",