@kimesh/router-runtime 0.2.40 → 0.2.41

package/dist/{executor-CRRUmoFz.d.mts → index-B0Xt0G76.d.mts}

@@ -1,7 +1,7 @@
 import * as vue from "vue";
 import { App, Component, ComputedRef, InjectionKey, KeepAliveProps, MaybeRefOrGetter, PropType, Ref, TransitionProps, VNode } from "vue";
 import * as vue_router0 from "vue-router";
-import { LocationQueryValue, NavigationFailure, RouteLocationNormalized, RouteLocationNormalizedLoaded, RouteRecordRaw, Router } from "vue-router";
+import { LocationQueryValue, NavigationFailure, NavigationGuard, NavigationHookAfter, RouteLocationNormalized, RouteLocationNormalized as RouteLocationNormalized$1, RouteLocationNormalizedLoaded, RouteLocationNormalizedLoaded as RouteLocationNormalizedLoaded$1, RouteRecordRaw, RouteRecordRaw as RouteRecordRaw$1, Router, Router as Router$1, onBeforeRouteLeave, onBeforeRouteUpdate, useLink, useRoute as useRoute$1, useRouter as useRouter$1 } from "vue-router";
 import { QueryClient, QueryClientConfig } from "@tanstack/vue-query";
 import { Hookable } from "hookable";
 
@@ -1748,6 +1748,49 @@ declare function navigateTo(to: NavigationRedirect, options?: NavigateToOptions)
  */
 declare function abortNavigation(reason?: string | Error): false;
 //#endregion
+//#region src/middleware/plugin.d.ts
+/**
+ * Options for middleware plugin
+ */
+interface MiddlewarePluginOptions {
+  /** Global middleware array */
+  globalMiddleware?: RouteMiddleware[];
+  /** Named middleware registry (lazy loaders) */
+  namedMiddleware?: Record<string, () => Promise<RouteMiddleware>>;
+}
+/**
+ * Create middleware plugin with provided registry
+ *
+ * @example
+ * ```ts
+ * import { globalMiddleware, namedMiddleware } from '#kimesh/middleware'
+ *
+ * const plugin = createMiddlewarePlugin({
+ *   globalMiddleware,
+ *   namedMiddleware,
+ * })
+ * ```
+ */
+declare function createMiddlewarePlugin(options?: MiddlewarePluginOptions): KimeshRuntimePlugin<{
+  middleware: {
+    globalCount: number;
+    namedCount: number;
+  };
+}>;
+/**
+ * Middleware runtime plugin (legacy - no-op stub)
+ *
+ * @deprecated Use createMiddlewarePlugin() with explicit registry instead.
+ * This export is kept for backward compatibility but does nothing.
+ * The kit generates middleware-plugin.mjs that uses createMiddlewarePlugin.
+ */
+declare const middlewarePlugin: KimeshRuntimePlugin<{
+  middleware: {
+    globalCount: number;
+    namedCount: number;
+  };
+}>;
+//#endregion
 //#region src/middleware/context.d.ts
 /**
  * Create middleware execution context
@@ -1778,4 +1821,4 @@ declare function createMiddlewareExecutor(appContext: KimeshAppContext): {
   executeChain(middlewares: RouteMiddleware[], context: MiddlewareContext): Promise<void | false | NavigationRedirect>;
 };
 //#endregion
-export { useNavigate as $, LoaderFn as $t, useRouteQuery as A, NavigationHookContext as An, isKimeshRuntimePlugin as At, useAfterNavigation as B, BeforeLoadContextFull as Bt, LoaderDataKey as C, KimeshRuntimeHooks as Cn, applyPlugins as Ct, RouteQueryTransform as D, KimeshRuntimePluginResult as Dn, getPluginHooks as Dt, isLayoutRouteMeta as E, KimeshRuntimePluginMeta as En, defineKimeshRuntimePlugin as Et, useMatchLoaderData as F, CreateKimeshAppOptionsExtended as Ft, getKmStateKeys as G, FullContext as Gt, useNavigationMiddleware as H, CreateKimeshAppOptions as Ht, useRouteLoaderData as I, KIMESH_APP_CONTEXT_KEY as It, tryUseKimeshApp as J, InlineRouteMiddleware as Jt, hasKmState as K, HasParams as Kt, NavigationContext as L, createKimeshApp as Lt, useRouteQueryNumber as M, useKimeshContext as Mt, useLayoutData as N, createFileRoute as Nt, RouteQueryValueRaw as O, NavigationAfterHookContext as On, getPluginMeta as Ot, useLoaderData as P, defineRoute as Pt, NavigateOptions as Q, LoaderContext as Qt, NavigationErrorContext as R, AugmentedContext as Rt, LayoutRouteMeta as S, KimeshAppContext as Sn, applyPlugin as St, createLoaderDataKey as T, KimeshRuntimePluginDefinition as Tn, KIMESH_PLUGIN_INDICATOR as Tt, STATE_KEY_PREFIX as U, ExtractRouteParams as Ut, useNavigationGuard as V, BeforeLoadFn as Vt, clearKmState as W, FileRouteOptions as Wt, RuntimeConfig as X, KimeshApp as Xt, useKimeshApp as Y, KIMESH_CONTEXT_KEY as Yt, useRuntimeConfig as Z, KimeshContext as Zt, MiddlewareResult as _, RouteRecordInfo as _n, mergeHeadConfigs as _t, NavigateToOptions as a, RouteContext as an, createLoaderGuard as at, TypedRouteMiddleware as b, TypedRedirectDynamic as bn, queryPlugin as bt, defineKimeshMiddleware as c, RouteHeadContext as cn, KmLink as ct, KnownMiddleware as d, RouteLocationRaw as dn, HeadPluginOptions as dt, ParamValue as en, useParams as et, MiddlewareContext as f, RouteNamedMap as fn, applyHeadConfigNative as ft, MiddlewareRegistryEntry as g, RoutePath as gn, mergeAllRouteHeads as gt, MiddlewareRegistry as h, RouteParamsRaw as hn, createHeadPlugin as ht, createMiddlewareContext as i, PendingConfig as in, LoaderGuardOptions as it, useRouteQueryBoolean as j, RuntimeConfigPublic as jn, defineContext as jt, UseRouteQueryOptions as k, NavigationErrorHookContext as kn, getPluginName as kt, navigateTo as l, RouteHeadFn as ln, KmLinkProps as lt, MiddlewareOption as m, RouteParams as mn, collectRouteHeads as mt, executeMiddleware as n, ParamValueZeroOrMore as nn, UseSearchReturn as nt, TypedNavigateToOptions as o, RouteDefinition as on, installLoaderGuard as ot, MiddlewareDefinition as p, RouteNames as pn, applyTitleTemplate as pt, useState as q, InlineMiddlewareContext as qt, executeMiddlewareChain as r, ParamValueZeroOrOne as rn, useSearch as rt, abortNavigation as s, RouteHeadConfig as sn, KmDeferred as st, createMiddlewareExecutor as t, ParamValueOneOrMore as tn, useReactiveParams as tt, KimeshMiddlewareNames as u, RouteInfoByName as un, KmOutlet as ut, NavigationRedirect as v, SearchSchema as vn, QueryPluginOptions as vt, UseMatchLoaderDataOptions as w, KimeshRuntimePlugin as wn, applyPluginsWithParallel as wt, LayoutLoaderData as x, TypedRedirectStatic as xn, routerPlugin as xt, RouteMiddleware as y, TypedNavigationRedirect as yn, getCorePlugins as yt, NavigationMiddlewareOptions as z, BeforeLoadContext as zt };
+export { NavigationMiddlewareOptions as $, BeforeLoadContext as $t, MiddlewareRegistryEntry as A, RoutePath as An, mergeAllRouteHeads as At, isLayoutRouteMeta as B, KimeshRuntimePluginMeta as Bn, defineKimeshRuntimePlugin as Bt, navigateTo as C, RouteHeadFn as Cn, KmLinkProps as Ct, MiddlewareDefinition as D, RouteNames as Dn, applyTitleTemplate as Dt, MiddlewareContext as E, RouteNamedMap as En, applyHeadConfigNative as Et, LayoutLoaderData as F, TypedRedirectStatic as Fn, routerPlugin as Ft, useRouteQueryBoolean as G, RuntimeConfigPublic as Gn, defineContext as Gt, RouteQueryValueRaw as H, NavigationAfterHookContext as Hn, getPluginMeta as Ht, LayoutRouteMeta as I, KimeshAppContext as In, applyPlugin as It, useLoaderData as J, defineRoute as Jt, useRouteQueryNumber as K, useKimeshContext as Kt, LoaderDataKey as L, KimeshRuntimeHooks as Ln, applyPlugins as Lt, NavigationRedirect as M, SearchSchema as Mn, QueryPluginOptions as Mt, RouteMiddleware as N, TypedNavigationRedirect as Nn, getCorePlugins as Nt, MiddlewareOption as O, RouteParams as On, collectRouteHeads as Ot, TypedRouteMiddleware as P, TypedRedirectDynamic as Pn, queryPlugin as Pt, NavigationErrorContext as Q, AugmentedContext as Qt, UseMatchLoaderDataOptions as R, KimeshRuntimePlugin as Rn, applyPluginsWithParallel as Rt, defineKimeshMiddleware as S, RouteHeadContext as Sn, KmLink as St, KnownMiddleware as T, RouteLocationRaw as Tn, HeadPluginOptions as Tt, UseRouteQueryOptions as U, NavigationErrorHookContext as Un, getPluginName as Ut, RouteQueryTransform as V, KimeshRuntimePluginResult as Vn, getPluginHooks as Vt, useRouteQuery as W, NavigationHookContext as Wn, isKimeshRuntimePlugin as Wt, useRouteLoaderData as X, KIMESH_APP_CONTEXT_KEY as Xt, useMatchLoaderData as Y, CreateKimeshAppOptionsExtended as Yt, NavigationContext as Z, createKimeshApp as Zt, createMiddlewarePlugin as _, ParamValueZeroOrOne as _n, useSearch as _t, RouteRecordRaw$1 as a, FullContext as an, getKmStateKeys as at, TypedNavigateToOptions as b, RouteDefinition as bn, installLoaderGuard as bt, onBeforeRouteUpdate as c, InlineRouteMiddleware as cn, tryUseKimeshApp as ct, useRouter$1 as d, KimeshContext as dn, useRuntimeConfig as dt, BeforeLoadContextFull as en, useAfterNavigation as et, createMiddlewareExecutor as f, LoaderContext as fn, NavigateOptions as ft, MiddlewarePluginOptions as g, ParamValueZeroOrMore as gn, UseSearchReturn as gt, createMiddlewareContext as h, ParamValueOneOrMore as hn, useReactiveParams as ht, RouteLocationNormalizedLoaded$1 as i, FileRouteOptions as in, clearKmState as it, MiddlewareResult as j, RouteRecordInfo as jn, mergeHeadConfigs as jt, MiddlewareRegistry as k, RouteParamsRaw as kn, createHeadPlugin as kt, useLink as l, KIMESH_CONTEXT_KEY as ln, useKimeshApp as lt, executeMiddlewareChain as m, ParamValue as mn, useParams as mt, NavigationHookAfter as n, CreateKimeshAppOptions as nn, useNavigationMiddleware as nt, Router$1 as o, HasParams as on, hasKmState as ot, executeMiddleware as p, LoaderFn as pn, useNavigate as pt, useLayoutData as q, createFileRoute as qt, RouteLocationNormalized$1 as r, ExtractRouteParams as rn, STATE_KEY_PREFIX as rt, onBeforeRouteLeave as s, InlineMiddlewareContext as sn, useState as st, NavigationGuard as t, BeforeLoadFn as tn, useNavigationGuard as tt, useRoute$1 as u, KimeshApp as un, RuntimeConfig as ut, middlewarePlugin as v, PendingConfig as vn, LoaderGuardOptions as vt, KimeshMiddlewareNames as w, RouteInfoByName as wn, KmOutlet as wt, abortNavigation as x, RouteHeadConfig as xn, KmDeferred as xt, NavigateToOptions as y, RouteContext as yn, createLoaderGuard as yt, createLoaderDataKey as z, KimeshRuntimePluginDefinition as zn, KIMESH_PLUGIN_INDICATOR as zt };

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -1,7 +1,5 @@
-import { a as getPluginMeta, i as getPluginHooks, n as KIMESH_PLUGIN_INDICATOR, o as getPluginName, r as defineKimeshRuntimePlugin, s as isKimeshRuntimePlugin, t as createMiddlewareContext } from "./context-Dm4fd4Um.mjs";
-import { a as defineKimeshMiddleware, i as abortNavigation, o as navigateTo, t as createMiddlewareExecutor } from "./executor-DghrGTKE.mjs";
-import middlewarePlugin, { createMiddlewarePlugin } from "./middleware/plugin.mjs";
-import "./middleware/index.mjs";
+import { a as defineKimeshRuntimePlugin, c as getPluginName, i as KIMESH_PLUGIN_INDICATOR, l as isKimeshRuntimePlugin, n as middlewarePlugin, o as getPluginHooks, r as createMiddlewareContext, s as getPluginMeta, t as createMiddlewarePlugin } from "./plugin-ppRzW7AM.mjs";
+import { a as defineKimeshMiddleware, i as abortNavigation, o as navigateTo, t as createMiddlewareExecutor } from "./middleware-DvCiATAB.mjs";
 import { KeepAlive, Suspense, Transition, computed, createApp, customRef, defineComponent, getCurrentInstance, h, inject, isRef, nextTick, onErrorCaptured, onScopeDispose, reactive, ref, toRef, toValue, watch } from "vue";
 import { RouterLink, RouterView, createRouter, createWebHashHistory, createWebHistory, onBeforeRouteLeave, onBeforeRouteUpdate, routeLocationKey, routerKey, useLink, useRoute, useRoute as useRoute$1, useRouter, useRouter as useRouter$1 } from "vue-router";
 import { QueryClient, VueQueryPlugin } from "@tanstack/vue-query";

package/dist/middleware/index.d.mts

@@ -1,3 +1,2 @@
-import { _ as MiddlewareResult, a as NavigateToOptions, b as TypedRouteMiddleware, c as defineKimeshMiddleware, d as KnownMiddleware, f as MiddlewareContext, g as MiddlewareRegistryEntry, h as MiddlewareRegistry, i as createMiddlewareContext, l as navigateTo, m as MiddlewareOption, n as executeMiddleware, o as TypedNavigateToOptions, p as MiddlewareDefinition, r as executeMiddlewareChain, s as abortNavigation, t as createMiddlewareExecutor, u as KimeshMiddlewareNames, v as NavigationRedirect, y as RouteMiddleware } from "../executor-CRRUmoFz.mjs";
-import middlewarePlugin, { MiddlewarePluginOptions, createMiddlewarePlugin } from "./plugin.mjs";
-export { type KimeshMiddlewareNames, type KnownMiddleware, type MiddlewareContext, type MiddlewareDefinition, type MiddlewareOption, type MiddlewarePluginOptions, type MiddlewareRegistry, type MiddlewareRegistryEntry, type MiddlewareResult, type NavigateToOptions, type NavigationRedirect, type RouteMiddleware, type TypedNavigateToOptions, type TypedRouteMiddleware, abortNavigation, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };
+import { A as MiddlewareRegistryEntry, C as navigateTo, D as MiddlewareDefinition, E as MiddlewareContext, M as NavigationRedirect, N as RouteMiddleware, O as MiddlewareOption, P as TypedRouteMiddleware, S as defineKimeshMiddleware, T as KnownMiddleware, _ as createMiddlewarePlugin, b as TypedNavigateToOptions, f as createMiddlewareExecutor, g as MiddlewarePluginOptions, h as createMiddlewareContext, j as MiddlewareResult, k as MiddlewareRegistry, m as executeMiddlewareChain, p as executeMiddleware, v as middlewarePlugin, w as KimeshMiddlewareNames, x as abortNavigation, y as NavigateToOptions } from "../index-B0Xt0G76.mjs";
+export { KimeshMiddlewareNames, KnownMiddleware, MiddlewareContext, MiddlewareDefinition, MiddlewareOption, MiddlewarePluginOptions, MiddlewareRegistry, MiddlewareRegistryEntry, MiddlewareResult, NavigateToOptions, NavigationRedirect, RouteMiddleware, TypedNavigateToOptions, TypedRouteMiddleware, abortNavigation, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };

package/dist/middleware/index.mjs

@@ -1,5 +1,4 @@
-import { t as createMiddlewareContext } from "../context-Dm4fd4Um.mjs";
-import { a as defineKimeshMiddleware, i as abortNavigation, n as executeMiddleware, o as navigateTo, r as executeMiddlewareChain, t as createMiddlewareExecutor } from "../executor-DghrGTKE.mjs";
-import middlewarePlugin, { createMiddlewarePlugin } from "./plugin.mjs";
+import { n as middlewarePlugin, r as createMiddlewareContext, t as createMiddlewarePlugin } from "../plugin-ppRzW7AM.mjs";
+import { a as defineKimeshMiddleware, i as abortNavigation, n as executeMiddleware, o as navigateTo, r as executeMiddlewareChain, t as createMiddlewareExecutor } from "../middleware-DvCiATAB.mjs";
 
 export { abortNavigation, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };

package/dist/middleware/plugin.d.mts

@@ -1,47 +1,2 @@
-import { wn as KimeshRuntimePlugin, y as RouteMiddleware } from "../executor-CRRUmoFz.mjs";
-import "../index.mjs";
-
-//#region src/middleware/plugin.d.ts
-/**
- * Options for middleware plugin
- */
-interface MiddlewarePluginOptions {
-  /** Global middleware array */
-  globalMiddleware?: RouteMiddleware[];
-  /** Named middleware registry (lazy loaders) */
-  namedMiddleware?: Record<string, () => Promise<RouteMiddleware>>;
-}
-/**
- * Create middleware plugin with provided registry
- *
- * @example
- * ```ts
- * import { globalMiddleware, namedMiddleware } from '#kimesh/middleware'
- *
- * const plugin = createMiddlewarePlugin({
- *   globalMiddleware,
- *   namedMiddleware,
- * })
- * ```
- */
-declare function createMiddlewarePlugin(options?: MiddlewarePluginOptions): KimeshRuntimePlugin<{
-  middleware: {
-    globalCount: number;
-    namedCount: number;
-  };
-}>;
-/**
- * Middleware runtime plugin (legacy - no-op stub)
- *
- * @deprecated Use createMiddlewarePlugin() with explicit registry instead.
- * This export is kept for backward compatibility but does nothing.
- * The kit generates middleware-plugin.mjs that uses createMiddlewarePlugin.
- */
-declare const middlewarePlugin: KimeshRuntimePlugin<{
-  middleware: {
-    globalCount: number;
-    namedCount: number;
-  };
-}>;
-//#endregion
+import { _ as createMiddlewarePlugin, g as MiddlewarePluginOptions, v as middlewarePlugin } from "../index-B0Xt0G76.mjs";
 export { MiddlewarePluginOptions, createMiddlewarePlugin, middlewarePlugin as default, middlewarePlugin };

package/dist/middleware/plugin.mjs

@@ -1,118 +1,3 @@
-import { r as defineKimeshRuntimePlugin, t as createMiddlewareContext } from "../context-Dm4fd4Um.mjs";
+import { n as middlewarePlugin, t as createMiddlewarePlugin } from "../plugin-ppRzW7AM.mjs";
 
-//#region src/middleware/plugin.ts
-/**
-* @kimesh/router-runtime - Middleware Plugin
-*
-* Runtime plugin that integrates middleware execution with Vue Router.
-* Executes middleware in router.beforeEach guard.
-*
-* This plugin receives middleware registry from options instead of importing
-* virtual modules, avoiding Vite pre-bundling issues.
-*/
-/**
-* Create middleware plugin with provided registry
-*
-* @example
-* ```ts
-* import { globalMiddleware, namedMiddleware } from '#kimesh/middleware'
-*
-* const plugin = createMiddlewarePlugin({
-*   globalMiddleware,
-*   namedMiddleware,
-* })
-* ```
-*/
-function createMiddlewarePlugin(options = {}) {
-	const globalMiddleware = options.globalMiddleware || [];
-	const namedMiddleware = options.namedMiddleware || {};
-	const hasRegisteredMiddleware = globalMiddleware.length > 0 || Object.keys(namedMiddleware).length > 0;
-	return defineKimeshRuntimePlugin({
-		name: "kimesh:middleware",
-		enforce: "pre",
-		setup(appContext) {
-			if (__KIMESH_DEV__ && hasRegisteredMiddleware) console.info(`[Kimesh] Middleware loaded: ${globalMiddleware.length} global, ${Object.keys(namedMiddleware).length} named`);
-			appContext.router.beforeEach(async (to, from) => {
-				const context = createMiddlewareContext(to, from, appContext);
-				for (const middleware of globalMiddleware) {
-					if (__KIMESH_DEV__) console.debug("[Kimesh] Executing global middleware");
-					const result = await appContext.runWithContext(() => middleware(to, from, context));
-					if (result !== void 0) return convertResult(result);
-				}
-				const routeMiddleware = await extractRouteMiddleware(to, namedMiddleware);
-				if (routeMiddleware.length === 0) return true;
-				if (__KIMESH_DEV__) console.debug(`[Kimesh] Executing ${routeMiddleware.length} route middleware`);
-				for (const middleware of routeMiddleware) {
-					const result = await appContext.runWithContext(() => middleware(to, from, context));
-					if (result !== void 0) return convertResult(result);
-				}
-				return true;
-			});
-			return { provide: { middleware: {
-				globalCount: globalMiddleware.length,
-				namedCount: Object.keys(namedMiddleware).length
-			} } };
-		}
-	});
-}
-/**
-* Middleware runtime plugin (legacy - no-op stub)
-*
-* @deprecated Use createMiddlewarePlugin() with explicit registry instead.
-* This export is kept for backward compatibility but does nothing.
-* The kit generates middleware-plugin.mjs that uses createMiddlewarePlugin.
-*/
-const middlewarePlugin = createMiddlewarePlugin({});
-/**
-* Convert middleware result to Vue Router format
-*/
-function convertResult(result) {
-	if (result === false) return false;
-	if (result && typeof result === "object") return {
-		path: result.path,
-		name: result.name,
-		params: result.params,
-		query: result.query,
-		replace: result.replace
-	};
-	return true;
-}
-/**
-* Extract route middleware from route definition
-*/
-async function extractRouteMiddleware(route, namedMiddleware) {
-	const middlewareOption = route.meta?.middleware || route.meta?.__kimesh?.middleware;
-	if (!middlewareOption) return [];
-	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) {
-	if (typeof middleware === "string") {
-		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;
-}
-
-//#endregion
 export { createMiddlewarePlugin, middlewarePlugin as default, middlewarePlugin };

package/dist/plugin-ppRzW7AM.mjs

@@ -0,0 +1,204 @@
+//#region src/runtime-plugin.ts
+const KIMESH_PLUGIN_INDICATOR = "__kimesh_plugin";
+/**
+* Define a Kimesh runtime plugin
+*
+* @example Function-style plugin
+* ```ts
+* export default defineKimeshRuntimePlugin((app) => {
+*   const analytics = new AnalyticsService()
+*   app.router.afterEach((to) => analytics.trackPageView(to.path))
+*   return { provide: { analytics } }
+* })
+* ```
+*
+* @example Object-style plugin with hooks
+* ```ts
+* export default defineKimeshRuntimePlugin({
+*   name: 'my-plugin',
+*   enforce: 'pre',
+*   hooks: {
+*     'app:mounted': () => console.log('App mounted!')
+*   },
+*   setup(app) {
+*     return { provide: { myService: new MyService() } }
+*   }
+* })
+* ```
+*/
+function defineKimeshRuntimePlugin(plugin) {
+	if (typeof plugin === "function") {
+		plugin[KIMESH_PLUGIN_INDICATOR] = true;
+		return plugin;
+	}
+	const { name, enforce, order, dependsOn, parallel, hooks, setup } = plugin;
+	const pluginFn = setup ?? (() => {});
+	pluginFn[KIMESH_PLUGIN_INDICATOR] = true;
+	pluginFn._name = name;
+	pluginFn.meta = {
+		name,
+		enforce,
+		order,
+		dependsOn,
+		parallel
+	};
+	pluginFn.hooks = hooks;
+	return pluginFn;
+}
+/**
+* Check if a value is a Kimesh runtime plugin
+*/
+function isKimeshRuntimePlugin(value) {
+	return typeof value === "function" && value[KIMESH_PLUGIN_INDICATOR] === true;
+}
+/**
+* Get plugin metadata
+*/
+function getPluginMeta(plugin) {
+	return plugin.meta ?? {};
+}
+/**
+* Get plugin name
+*/
+function getPluginName(plugin) {
+	return plugin._name ?? plugin.meta?.name ?? "anonymous";
+}
+/**
+* Get plugin hooks
+*/
+function getPluginHooks(plugin) {
+	return plugin.hooks;
+}
+
+//#endregion
+//#region src/middleware/context.ts
+/**
+* Create middleware execution context
+*/
+function createMiddlewareContext(to, from, appContext) {
+	return {
+		to,
+		from,
+		router: appContext.router,
+		app: appContext,
+		data: {}
+	};
+}
+
+//#endregion
+//#region src/middleware/plugin.ts
+/**
+* @kimesh/router-runtime - Middleware Plugin
+*
+* Runtime plugin that integrates middleware execution with Vue Router.
+* Executes middleware in router.beforeEach guard.
+*
+* This plugin receives middleware registry from options instead of importing
+* virtual modules, avoiding Vite pre-bundling issues.
+*/
+/**
+* Create middleware plugin with provided registry
+*
+* @example
+* ```ts
+* import { globalMiddleware, namedMiddleware } from '#kimesh/middleware'
+*
+* const plugin = createMiddlewarePlugin({
+*   globalMiddleware,
+*   namedMiddleware,
+* })
+* ```
+*/
+function createMiddlewarePlugin(options = {}) {
+	const globalMiddleware = options.globalMiddleware || [];
+	const namedMiddleware = options.namedMiddleware || {};
+	const hasRegisteredMiddleware = globalMiddleware.length > 0 || Object.keys(namedMiddleware).length > 0;
+	return defineKimeshRuntimePlugin({
+		name: "kimesh:middleware",
+		enforce: "pre",
+		setup(appContext) {
+			if (__KIMESH_DEV__ && hasRegisteredMiddleware) console.info(`[Kimesh] Middleware loaded: ${globalMiddleware.length} global, ${Object.keys(namedMiddleware).length} named`);
+			appContext.router.beforeEach(async (to, from) => {
+				const context = createMiddlewareContext(to, from, appContext);
+				for (const middleware of globalMiddleware) {
+					if (__KIMESH_DEV__) console.debug("[Kimesh] Executing global middleware");
+					const result = await appContext.runWithContext(() => middleware(to, from, context));
+					if (result !== void 0) return convertResult(result);
+				}
+				const routeMiddleware = await extractRouteMiddleware(to, namedMiddleware);
+				if (routeMiddleware.length === 0) return true;
+				if (__KIMESH_DEV__) console.debug(`[Kimesh] Executing ${routeMiddleware.length} route middleware`);
+				for (const middleware of routeMiddleware) {
+					const result = await appContext.runWithContext(() => middleware(to, from, context));
+					if (result !== void 0) return convertResult(result);
+				}
+				return true;
+			});
+			return { provide: { middleware: {
+				globalCount: globalMiddleware.length,
+				namedCount: Object.keys(namedMiddleware).length
+			} } };
+		}
+	});
+}
+/**
+* Middleware runtime plugin (legacy - no-op stub)
+*
+* @deprecated Use createMiddlewarePlugin() with explicit registry instead.
+* This export is kept for backward compatibility but does nothing.
+* The kit generates middleware-plugin.mjs that uses createMiddlewarePlugin.
+*/
+const middlewarePlugin = createMiddlewarePlugin({});
+/**
+* Convert middleware result to Vue Router format
+*/
+function convertResult(result) {
+	if (result === false) return false;
+	if (result && typeof result === "object") return {
+		path: result.path,
+		name: result.name,
+		params: result.params,
+		query: result.query,
+		replace: result.replace
+	};
+	return true;
+}
+/**
+* Extract route middleware from route definition
+*/
+async function extractRouteMiddleware(route, namedMiddleware) {
+	const middlewareOption = route.meta?.middleware || route.meta?.__kimesh?.middleware;
+	if (!middlewareOption) return [];
+	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) {
+	if (typeof middleware === "string") {
+		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;
+}
+
+//#endregion
+export { defineKimeshRuntimePlugin as a, getPluginName as c, KIMESH_PLUGIN_INDICATOR as i, isKimeshRuntimePlugin as l, middlewarePlugin as n, getPluginHooks as o, createMiddlewareContext as r, getPluginMeta as s, createMiddlewarePlugin as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimesh/router-runtime",
-  "version": "0.2.40",
+  "version": "0.2.41",
   "description": "Runtime router for Kimesh framework",
   "repository": {
     "type": "git",
@@ -42,13 +42,13 @@
     "vue-router": "^4.6.4"
   },
   "devDependencies": {
-    "@tanstack/vue-query": "^5.92.6",
+    "@tanstack/vue-query": "^5.92.9",
     "@types/node": "^25.0.8",
-    "tsdown": "^0.20.0-beta.3",
+    "tsdown": "^0.20.3",
     "typescript": "^5.9.3",
     "vitest": "^4.0.17",
     "vue": "^3.5.29",
-    "vue-tsc": "^3.2.2"
+    "vue-tsc": "^3.2.5"
   },
   "peerDependencies": {
     "@tanstack/vue-query": "^5.0.0",

package/dist/context-Dm4fd4Um.mjs

@@ -1,89 +0,0 @@
-//#region src/runtime-plugin.ts
-const KIMESH_PLUGIN_INDICATOR = "__kimesh_plugin";
-/**
-* Define a Kimesh runtime plugin
-*
-* @example Function-style plugin
-* ```ts
-* export default defineKimeshRuntimePlugin((app) => {
-*   const analytics = new AnalyticsService()
-*   app.router.afterEach((to) => analytics.trackPageView(to.path))
-*   return { provide: { analytics } }
-* })
-* ```
-*
-* @example Object-style plugin with hooks
-* ```ts
-* export default defineKimeshRuntimePlugin({
-*   name: 'my-plugin',
-*   enforce: 'pre',
-*   hooks: {
-*     'app:mounted': () => console.log('App mounted!')
-*   },
-*   setup(app) {
-*     return { provide: { myService: new MyService() } }
-*   }
-* })
-* ```
-*/
-function defineKimeshRuntimePlugin(plugin) {
-	if (typeof plugin === "function") {
-		plugin[KIMESH_PLUGIN_INDICATOR] = true;
-		return plugin;
-	}
-	const { name, enforce, order, dependsOn, parallel, hooks, setup } = plugin;
-	const pluginFn = setup ?? (() => {});
-	pluginFn[KIMESH_PLUGIN_INDICATOR] = true;
-	pluginFn._name = name;
-	pluginFn.meta = {
-		name,
-		enforce,
-		order,
-		dependsOn,
-		parallel
-	};
-	pluginFn.hooks = hooks;
-	return pluginFn;
-}
-/**
-* Check if a value is a Kimesh runtime plugin
-*/
-function isKimeshRuntimePlugin(value) {
-	return typeof value === "function" && value[KIMESH_PLUGIN_INDICATOR] === true;
-}
-/**
-* Get plugin metadata
-*/
-function getPluginMeta(plugin) {
-	return plugin.meta ?? {};
-}
-/**
-* Get plugin name
-*/
-function getPluginName(plugin) {
-	return plugin._name ?? plugin.meta?.name ?? "anonymous";
-}
-/**
-* Get plugin hooks
-*/
-function getPluginHooks(plugin) {
-	return plugin.hooks;
-}
-
-//#endregion
-//#region src/middleware/context.ts
-/**
-* Create middleware execution context
-*/
-function createMiddlewareContext(to, from, appContext) {
-	return {
-		to,
-		from,
-		router: appContext.router,
-		app: appContext,
-		data: {}
-	};
-}
-
-//#endregion
-export { getPluginMeta as a, getPluginHooks as i, KIMESH_PLUGIN_INDICATOR as n, getPluginName as o, defineKimeshRuntimePlugin as r, isKimeshRuntimePlugin as s, createMiddlewareContext as t };