@kimesh/router-runtime 0.2.10 → 0.2.11-nightly.20260127015259

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

@@ -13,7 +13,7 @@ interface KimeshRuntimePluginMeta {
   /** Plugin name for debugging */
   name?: string;
   /** Execution order: pre runs first, post runs last */
-  enforce?: "pre" | "default" | "post";
+  enforce?: 'pre' | 'default' | 'post';
   /** Numeric order for fine-grained control */
   order?: number;
   /** Wait for these plugins to complete first */
@@ -44,17 +44,17 @@ interface NavigationAfterHookContext extends NavigationHookContext {
  * Runtime hooks available in Kimesh app lifecycle
  */
 interface KimeshRuntimeHooks {
-  "app:created": (app: App) => void | Promise<void>;
-  "app:beforeMount": (app: App) => void | Promise<void>;
-  "app:mounted": (app: App) => void | Promise<void>;
-  "app:error": (err: unknown) => void | Promise<void>;
-  "page:start": () => void | Promise<void>;
-  "page:finish": () => void | Promise<void>;
-  "page:transition:finish": () => void | Promise<void>;
-  "page:view-transition:start": (transition: ViewTransition) => void | Promise<void>;
-  "navigate:before": (context: NavigationHookContext) => void | false | Promise<void | false>;
-  "navigate:after": (context: NavigationAfterHookContext) => void | Promise<void>;
-  "navigate:error": (context: NavigationErrorHookContext) => void | Promise<void>;
+  'app:created': (app: App) => void | Promise<void>;
+  'app:beforeMount': (app: App) => void | Promise<void>;
+  'app:mounted': (app: App) => void | Promise<void>;
+  'app:error': (err: unknown) => void | Promise<void>;
+  'page:start': () => void | Promise<void>;
+  'page:finish': () => void | Promise<void>;
+  'page:transition:finish': () => void | Promise<void>;
+  'page:view-transition:start': (transition: ViewTransition) => void | Promise<void>;
+  'navigate:before': (context: NavigationHookContext) => void | false | Promise<void | false>;
+  'navigate:after': (context: NavigationAfterHookContext) => void | Promise<void>;
+  'navigate:error': (context: NavigationErrorHookContext) => void | Promise<void>;
 }
 /**
  * Runtime config shape (public values only, no SSR)
@@ -195,9 +195,9 @@ interface CreateKimeshAppOptions {
   /** Base URL for router */
   base?: string;
   /** History mode */
-  history?: "hash" | "web";
+  history?: 'hash' | 'web';
   /** Scroll behavior */
-  scrollBehavior?: Router["options"]["scrollBehavior"];
+  scrollBehavior?: Router['options']['scrollBehavior'];
   /** Query client configuration */
   queryClientConfig?: QueryClientConfig;
   /** Custom context (user-defined) */
@@ -273,7 +273,7 @@ interface RouteHeadConfig {
     property?: string;
     content?: string;
     charset?: string;
-    "http-equiv"?: string;
+    'http-equiv'?: string;
     [key: string]: string | undefined;
   }>;
   /** Link tags */
@@ -308,7 +308,7 @@ interface RouteHeadConfig {
   /** HTML attributes */
   htmlAttrs?: {
     lang?: string;
-    dir?: "ltr" | "rtl" | "auto";
+    dir?: 'ltr' | 'rtl' | 'auto';
     class?: string;
     [key: string]: string | undefined;
   };
@@ -421,7 +421,7 @@ interface FileRouteOptions<TMeta = unknown, TParams = Record<string, string>, TS
    * viewTransition: 'always' // always use view transitions
    * ```
    */
-  viewTransition?: boolean | "always";
+  viewTransition?: boolean | 'always';
   /**
    * KeepAlive configuration for route component
    *
@@ -456,10 +456,10 @@ interface RouteDefinition<TPath extends string = string, TMeta = unknown, TParam
   beforeLoad?: (ctx: BeforeLoadContext) => Promise<void> | void;
   head?: RouteHeadFn<TParams, TLoaderData> | RouteHeadConfig;
   transition?: boolean | TransitionProps;
-  viewTransition?: boolean | "always";
+  viewTransition?: boolean | 'always';
   keepalive?: boolean | KeepAliveProps;
 }
-declare module "vue-router" {
+declare module 'vue-router' {
   interface RouteMeta {
     /** Kimesh route definition with loader */
     __kimesh?: RouteDefinition;
@@ -968,7 +968,7 @@ declare function useReactiveParams<T extends string = RouteNames>(): ComputedRef
  * Navigation options - requires params if route has them
  * Allows both named routes (with autocomplete) and raw string paths
  */
-type NavigateOptions<T extends string = RouteNames> = T extends RouteNames ? (HasParams<T> extends true ? {
+type NavigateOptions<T extends string = RouteNames> = T extends RouteNames ? HasParams<T> extends true ? {
   to: T;
   params: RouteParamsRaw<T>;
   replace?: boolean;
@@ -980,7 +980,7 @@ type NavigateOptions<T extends string = RouteNames> = T extends RouteNames ? (Ha
   to: T;
   params?: Record<string, string | number>;
   replace?: boolean;
-}) : {
+} : {
   to: T;
   params?: Record<string, string | number>;
   replace?: boolean;
@@ -1132,9 +1132,9 @@ interface NavigationErrorContext {
   to: RouteLocationNormalized;
   from: RouteLocationNormalized;
 }
-type BeforeNavigationHandler = KimeshRuntimeHooks["navigate:before"];
-type AfterNavigationHandler = KimeshRuntimeHooks["navigate:after"];
-type ErrorNavigationHandler = KimeshRuntimeHooks["navigate:error"];
+type BeforeNavigationHandler = KimeshRuntimeHooks['navigate:before'];
+type AfterNavigationHandler = KimeshRuntimeHooks['navigate:after'];
+type ErrorNavigationHandler = KimeshRuntimeHooks['navigate:error'];
 /**
  * Options for useNavigationMiddleware
  */
@@ -1388,14 +1388,39 @@ declare function abortNavigation(reason?: string | Error): false;
 //#endregion
 //#region src/middleware/plugin.d.ts
 /**
- * @kimesh/router-runtime - Middleware Plugin
+ * 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
  *
- * Runtime plugin that integrates middleware execution with Vue Router.
- * Executes middleware in router.beforeEach guard.
+ * @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
- * Registers with Vue Router and executes middleware on navigation
+ * 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: {
@@ -1434,4 +1459,4 @@ declare function createMiddlewareExecutor(appContext: KimeshAppContext): {
   executeChain(middlewares: RouteMiddleware[], context: MiddlewareContext): Promise<void | false | NavigationRedirect>;
 };
 //#endregion
-export { LoaderGuardOptions as $, RoutePath as $t, RouteMiddleware as A, FullContext as At, getKmStateKeys as B, ParamValueOneOrMore as Bt, MiddlewareDefinition as C, CreateKimeshAppOptionsExtended as Ct, MiddlewareResult as D, CreateKimeshAppOptions as Dt, MiddlewareRegistryEntry as E, BeforeLoadContext as Et, useAfterNavigation as F, KimeshApp as Ft, RuntimeConfig as G, RouteHeadContext as Gt, useState as H, ParamValueZeroOrOne as Ht, useNavigationGuard as I, KimeshContext as It, useNavigate as J, RouteLocationRaw as Jt, useRuntimeConfig as K, RouteHeadFn as Kt, useNavigationMiddleware as L, LoaderContext as Lt, NavigationContext as M, InlineMiddlewareContext as Mt, NavigationErrorContext as N, InlineRouteMiddleware as Nt, NavigateToOptions as O, ExtractRouteParams as Ot, NavigationMiddlewareOptions as P, KIMESH_CONTEXT_KEY as Pt, useSearch as Q, RouteParamsRaw as Qt, STATE_KEY_PREFIX as R, LoaderFn as Rt, MiddlewareContext as S, defineRoute as St, MiddlewareRegistry as T, createKimeshApp as Tt, tryUseKimeshApp as U, RouteDefinition as Ut, hasKmState as V, ParamValueZeroOrMore as Vt, useKimeshApp as W, RouteHeadConfig as Wt, useReactiveParams as X, RouteNames as Xt, useParams as Y, RouteNamedMap as Yt, UseSearchReturn as Z, RouteParams as Zt, abortNavigation as _, getPluginName as _t, RouteRecordRaw$1 as a, KimeshRuntimePluginDefinition as an, KmOutlet as at, KimeshMiddlewareNames as b, useKimeshContext as bt, onBeforeRouteUpdate as c, NavigationAfterHookContext as cn, queryPlugin as ct, useRouter$1 as d, RuntimeConfigPublic as dn, applyPlugins as dt, RouteRecordInfo as en, createLoaderGuard as et, createMiddlewareExecutor as f, applyPluginsWithParallel as ft, middlewarePlugin as g, getPluginMeta as gt, createMiddlewareContext as h, getPluginHooks as ht, RouteLocationNormalizedLoaded$1 as i, KimeshRuntimePlugin as in, KmLinkProps as it, TypedRouteMiddleware as j, HasParams as jt, NavigationRedirect as k, FileRouteOptions as kt, useLink as l, NavigationErrorHookContext as ln, routerPlugin as lt, executeMiddlewareChain as m, defineKimeshRuntimePlugin as mt, NavigationHookAfter as n, KimeshAppContext as nn, KmDeferred as nt, Router$1 as o, KimeshRuntimePluginMeta as on, QueryPluginOptions as ot, executeMiddleware as p, KIMESH_PLUGIN_INDICATOR as pt, NavigateOptions as q, RouteInfoByName as qt, RouteLocationNormalized$1 as r, KimeshRuntimeHooks as rn, KmLink as rt, onBeforeRouteLeave as s, KimeshRuntimePluginResult as sn, getCorePlugins as st, NavigationGuard as t, SearchSchema as tn, installLoaderGuard as tt, useRoute$1 as u, NavigationHookContext as un, applyPlugin as ut, defineKimeshMiddleware as v, isKimeshRuntimePlugin as vt, MiddlewareOption as w, KIMESH_APP_CONTEXT_KEY as wt, KnownMiddleware as x, createFileRoute as xt, navigateTo as y, defineContext as yt, clearKmState as z, ParamValue as zt };
+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 };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as LoaderGuardOptions, $t as RoutePath, A as RouteMiddleware, At as FullContext, B as getKmStateKeys, Bt as ParamValueOneOrMore, C as MiddlewareDefinition, Ct as CreateKimeshAppOptionsExtended, D as MiddlewareResult, Dt as CreateKimeshAppOptions, Et as BeforeLoadContext, F as useAfterNavigation, Ft as KimeshApp, G as RuntimeConfig, Gt as RouteHeadContext, H as useState, Ht as ParamValueZeroOrOne, I as useNavigationGuard, It as KimeshContext, J as useNavigate, Jt as RouteLocationRaw, K as useRuntimeConfig, Kt as RouteHeadFn, L as useNavigationMiddleware, Lt as LoaderContext, M as NavigationContext, Mt as InlineMiddlewareContext, N as NavigationErrorContext, Nt as InlineRouteMiddleware, O as NavigateToOptions, Ot as ExtractRouteParams, P as NavigationMiddlewareOptions, Pt as KIMESH_CONTEXT_KEY, Q as useSearch, Qt as RouteParamsRaw, R as STATE_KEY_PREFIX, Rt as LoaderFn, S as MiddlewareContext, St as defineRoute, Tt as createKimeshApp, U as tryUseKimeshApp, Ut as RouteDefinition, V as hasKmState, Vt as ParamValueZeroOrMore, W as useKimeshApp, Wt as RouteHeadConfig, X as useReactiveParams, Xt as RouteNames, Y as useParams, Yt as RouteNamedMap, Z as UseSearchReturn, Zt as RouteParams, _ as abortNavigation, _t as getPluginName, a as RouteRecordRaw, an as KimeshRuntimePluginDefinition, at as KmOutlet, b as KimeshMiddlewareNames, bt as useKimeshContext, c as onBeforeRouteUpdate, cn as NavigationAfterHookContext, ct as queryPlugin, d as useRouter, dn as RuntimeConfigPublic, dt as applyPlugins, en as RouteRecordInfo, et as createLoaderGuard, f as createMiddlewareExecutor, ft as applyPluginsWithParallel, g as middlewarePlugin, gt as getPluginMeta, h as createMiddlewareContext, ht as getPluginHooks, i as RouteLocationNormalizedLoaded, in as KimeshRuntimePlugin, it as KmLinkProps, j as TypedRouteMiddleware, jt as HasParams, k as NavigationRedirect, kt as FileRouteOptions, l as useLink, ln as NavigationErrorHookContext, lt as routerPlugin, mt as defineKimeshRuntimePlugin, n as NavigationHookAfter, nn as KimeshAppContext, nt as KmDeferred, o as Router, on as KimeshRuntimePluginMeta, ot as QueryPluginOptions, pt as KIMESH_PLUGIN_INDICATOR, q as NavigateOptions, qt as RouteInfoByName, r as RouteLocationNormalized, rn as KimeshRuntimeHooks, rt as KmLink, s as onBeforeRouteLeave, sn as KimeshRuntimePluginResult, st as getCorePlugins, t as NavigationGuard, tn as SearchSchema, tt as installLoaderGuard, u as useRoute, un as NavigationHookContext, ut as applyPlugin, v as defineKimeshMiddleware, vt as isKimeshRuntimePlugin, w as MiddlewareOption, wt as KIMESH_APP_CONTEXT_KEY, x as KnownMiddleware, xt as createFileRoute, y as navigateTo, yt as defineContext, z as clearKmState, zt as ParamValue } from "./index-WwJndf8N.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, 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, 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 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 };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as defineKimeshRuntimePlugin, c as getPluginName, i as KIMESH_PLUGIN_INDICATOR, l as isKimeshRuntimePlugin, o as getPluginHooks, r as createMiddlewareContext, s as getPluginMeta, t as middlewarePlugin } from "./plugin-DsScck9c.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-BfxCqV0B.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";
@@ -359,12 +359,12 @@ function defineRoute(options) {
 //#region src/context.ts
 /**
 * Define app context with type inference
-* 
+*
 * @example
 * ```ts
 * // src/app.context.ts
 * import { defineContext } from '@kimesh/router-runtime'
-* 
+*
 * export default defineContext(() => ({
 *   auth: useAuthStore(),
 *   i18n: createI18n(),
@@ -376,7 +376,7 @@ function defineContext(factory) {
 }
 /**
 * Use Kimesh context in components
-* 
+*
 * @example
 * ```vue
 * <script setup>
@@ -599,17 +599,17 @@ const supportsViewTransitions = () => typeof document !== "undefined" && "startV
 * Renders the matched route component with optional transitions and keepalive
 *
 * Transition options for async pages (useSuspenseQuery):
-* 
+*
 * 1. viewTransition: true (Recommended)
 *    - Uses View Transitions API (Chrome 111+, Edge 111+, Opera 97+)
 *    - Works perfectly with async pages
 *    - Falls back to instant transition on unsupported browsers
-* 
+*
 * 2. transition: { name: 'fade' } (without mode: 'out-in')
 *    - Uses Vue Transition with default mode (cross-fade)
 *    - Both pages exist during transition (old fades out, new fades in)
 *    - Requires CSS: .page-leave-active { position: absolute }
-* 
+*
 * 3. transition: { name: 'fade', mode: 'out-in' }
 *    - ⚠️ NOT recommended for async pages - may cause blank screen
 */
@@ -1066,7 +1066,7 @@ let _config;
 */
 function useRuntimeConfig() {
 	if (!_config) try {
-		_config = Object.freeze({ ...__KIMESH_CONFIG__ ?? {} });
+		_config = Object.freeze({ ...__KIMESH_CONFIG__ });
 	} catch {
 		_config = Object.freeze({});
 	}
@@ -1239,4 +1239,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, 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, 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 };

package/dist/middleware/index.d.mts

@@ -1,2 +1,2 @@
-import { A as RouteMiddleware, C as MiddlewareDefinition, D as MiddlewareResult, E as MiddlewareRegistryEntry, O as NavigateToOptions, S as MiddlewareContext, T as MiddlewareRegistry, _ as abortNavigation, b as KimeshMiddlewareNames, f as createMiddlewareExecutor, g as middlewarePlugin, h as createMiddlewareContext, j as TypedRouteMiddleware, k as NavigationRedirect, m as executeMiddlewareChain, p as executeMiddleware, v as defineKimeshMiddleware, w as MiddlewareOption, x as KnownMiddleware, y as navigateTo } from "../index-WwJndf8N.mjs";
-export { KimeshMiddlewareNames, KnownMiddleware, MiddlewareContext, MiddlewareDefinition, MiddlewareOption, MiddlewareRegistry, MiddlewareRegistryEntry, MiddlewareResult, NavigateToOptions, NavigationRedirect, RouteMiddleware, TypedRouteMiddleware, abortNavigation, createMiddlewareContext, createMiddlewareExecutor, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };
+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";
+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 { r as createMiddlewareContext, t as middlewarePlugin } from "../plugin-DsScck9c.mjs";
+import { i as createMiddlewareContext, n as middlewarePlugin, t as createMiddlewarePlugin } from "../plugin-BfxCqV0B.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, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };
+export { abortNavigation, createMiddlewareContext, createMiddlewareExecutor, createMiddlewarePlugin, defineKimeshMiddleware, executeMiddleware, executeMiddlewareChain, middlewarePlugin, navigateTo };

package/dist/middleware/plugin.d.mts

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

package/dist/middleware/plugin.mjs

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

package/dist/{plugin-DsScck9c.mjs → plugin-BfxCqV0B.mjs}

@@ -92,48 +92,62 @@ function createMiddlewareContext(to, from, appContext) {
 *
 * 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.
 */
 /**
-* Middleware runtime plugin
-* Registers with Vue Router and executes middleware on navigation
+* Create middleware plugin with provided registry
+*
+* @example
+* ```ts
+* import { globalMiddleware, namedMiddleware } from '#kimesh/middleware'
+*
+* const plugin = createMiddlewarePlugin({
+*   globalMiddleware,
+*   namedMiddleware,
+* })
+* ```
 */
-const middlewarePlugin = defineKimeshRuntimePlugin({
-	name: "kimesh:middleware",
-	enforce: "pre",
-	async setup(appContext) {
-		let globalMiddleware = [];
-		let namedMiddleware = {};
-		let hasMiddleware = false;
-		try {
-			const registry = await import("#kimesh/middleware");
-			globalMiddleware = registry.globalMiddleware || [];
-			namedMiddleware = registry.namedMiddleware || {};
-			hasMiddleware = true;
-			if (__KIMESH_DEV__) console.info(`[Kimesh] Middleware loaded: ${globalMiddleware.length} global, ${Object.keys(namedMiddleware).length} named`);
-		} catch (error) {
-			if (__KIMESH_DEV__) console.debug("[Kimesh] No middleware registry found, skipping middleware setup");
+function createMiddlewarePlugin(options = {}) {
+	const globalMiddleware = options.globalMiddleware || [];
+	const namedMiddleware = options.namedMiddleware || {};
+	const hasMiddleware = globalMiddleware.length > 0 || Object.keys(namedMiddleware).length > 0;
+	return defineKimeshRuntimePlugin({
+		name: "kimesh:middleware",
+		enforce: "pre",
+		setup(appContext) {
+			if (__KIMESH_DEV__ && hasMiddleware) console.info(`[Kimesh] Middleware loaded: ${globalMiddleware.length} global, ${Object.keys(namedMiddleware).length} named`);
+			if (hasMiddleware) 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 (__KIMESH_DEV__ && routeMiddleware.length > 0) 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
+			} } };
 		}
-		if (hasMiddleware) 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 (__KIMESH_DEV__ && routeMiddleware.length > 0) 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
 */
@@ -192,4 +206,4 @@ async function normalizeMiddleware(middleware, namedMiddleware) {
 var plugin_default = middlewarePlugin;
 
 //#endregion
-export { defineKimeshRuntimePlugin as a, getPluginName as c, KIMESH_PLUGIN_INDICATOR as i, isKimeshRuntimePlugin as l, plugin_default as n, getPluginHooks as o, createMiddlewareContext as r, getPluginMeta as s, middlewarePlugin as t };
+export { KIMESH_PLUGIN_INDICATOR as a, getPluginMeta as c, createMiddlewareContext as i, getPluginName as l, middlewarePlugin as n, defineKimeshRuntimePlugin as o, plugin_default as r, getPluginHooks as s, createMiddlewarePlugin as t, isKimeshRuntimePlugin as u };

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@kimesh/router-runtime",
-  "version": "0.2.10",
+  "version": "0.2.11-nightly.20260127015259",
   "description": "Runtime router for Kimesh framework",
-  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/kimeshjs/kimesh.git"
   },
+  "files": [
+    "dist",
+    "src/default-app.vue"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -24,12 +30,6 @@
       "import": "./dist/middleware/plugin.mjs"
     }
   },
-  "main": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
-  "files": [
-    "dist",
-    "src/default-app.vue"
-  ],
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
@@ -41,22 +41,22 @@
     "hookable": "^5.5.3",
     "vue-router": "^4.6.4"
   },
+  "devDependencies": {
+    "@tanstack/vue-query": "^5.92.6",
+    "@types/node": "^25.0.8",
+    "tsdown": "^0.20.0-beta.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17",
+    "vue": "^3.5.26",
+    "vue-tsc": "^3.2.2"
+  },
   "peerDependencies": {
-    "vue": "^3.5.0",
-    "@tanstack/vue-query": "^5.0.0"
+    "@tanstack/vue-query": "^5.0.0",
+    "vue": "^3.5.0"
   },
   "peerDependenciesMeta": {
     "@tanstack/vue-query": {
       "optional": true
     }
-  },
-  "devDependencies": {
-    "@types/node": "^25.0.8",
-    "typescript": "^5.9.3",
-    "tsdown": "^0.20.0-beta.3",
-    "vue": "^3.5.26",
-    "vue-tsc": "^3.2.2",
-    "vitest": "^4.0.17",
-    "@tanstack/vue-query": "^5.92.6"
   }
 }