@kimesh/router-runtime 0.2.8 → 0.2.9

package/dist/index-WwJndf8N.d.mts

@@ -0,0 +1,1437 @@
+import * as vue13 from "vue";
+import { App, Component, ComputedRef, InjectionKey, KeepAliveProps, PropType, Ref, TransitionProps, VNode } from "vue";
+import * as vue_router0 from "vue-router";
+import { 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";
+
+//#region src/runtime-types.d.ts
+/**
+ * Metadata for runtime plugin ordering and identification
+ */
+interface KimeshRuntimePluginMeta {
+  /** Plugin name for debugging */
+  name?: string;
+  /** Execution order: pre runs first, post runs last */
+  enforce?: "pre" | "default" | "post";
+  /** Numeric order for fine-grained control */
+  order?: number;
+  /** Wait for these plugins to complete first */
+  dependsOn?: string[];
+  /** Run in parallel with other parallel plugins */
+  parallel?: boolean;
+}
+/**
+ * Navigation context for hooks
+ */
+interface NavigationHookContext {
+  to: RouteLocationNormalized;
+  from: RouteLocationNormalized;
+}
+/**
+ * Navigation error context
+ */
+interface NavigationErrorHookContext extends NavigationHookContext {
+  error: Error;
+}
+/**
+ * Navigation after context
+ */
+interface NavigationAfterHookContext extends NavigationHookContext {
+  failure?: NavigationFailure;
+}
+/**
+ * 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>;
+}
+/**
+ * Runtime config shape (public values only, no SSR)
+ */
+interface RuntimeConfigPublic {
+  [key: string]: unknown;
+}
+/**
+ * Runtime context available to plugins and composables
+ */
+interface KimeshAppContext {
+  vueApp: App;
+  router: Router;
+  queryClient: QueryClient;
+  hooks: Hookable<KimeshRuntimeHooks>;
+  $config: RuntimeConfigPublic;
+  /** Per-layer runtime configs (for layer-aware features like $fetch) */
+  $layersConfig: Record<string, Record<string, unknown>>;
+  isHydrating: boolean;
+  provide: <T>(name: string, value: T) => void;
+  runWithContext: <T extends () => unknown>(fn: T) => ReturnType<T>;
+  /**
+   * Centralized reactive state storage for useState composable
+   * CSR-optimized: state exists purely in-memory, no SSR hydration
+   */
+  _state: Record<string, unknown>;
+}
+/**
+ * Return type for plugin setup function
+ */
+interface KimeshRuntimePluginResult<Injections = Record<string, unknown>> {
+  provide?: Injections;
+}
+/** Plugin setup return type */
+type PluginSetupReturn<Injections> = void | KimeshRuntimePluginResult<Injections> | Promise<void> | Promise<KimeshRuntimePluginResult<Injections>>;
+/**
+ * Runtime plugin function signature
+ */
+interface KimeshRuntimePlugin<Injections = Record<string, unknown>> {
+  (app: KimeshAppContext): PluginSetupReturn<Injections>;
+  __kimesh_plugin?: true;
+  _name?: string;
+  meta?: KimeshRuntimePluginMeta;
+  hooks?: Partial<KimeshRuntimeHooks>;
+}
+/**
+ * Object-style runtime plugin definition
+ */
+interface KimeshRuntimePluginDefinition<Injections = Record<string, unknown>> extends KimeshRuntimePluginMeta {
+  hooks?: Partial<KimeshRuntimeHooks>;
+  setup?: (app: KimeshAppContext) => PluginSetupReturn<Injections>;
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * User-defined context interface
+ * Extend this via declaration merging in your app:
+ *
+ * @example
+ * ```ts
+ * declare module '@kimesh/router-runtime' {
+ *   interface KimeshContext {
+ *     auth: AuthStore
+ *     i18n: I18n
+ *   }
+ * }
+ * ```
+ */
+interface KimeshContext {}
+/**
+ * Full context available in loaders (built-in + user-defined)
+ */
+interface FullContext extends KimeshContext {
+  queryClient: QueryClient;
+}
+/**
+ * Injection key for Kimesh context
+ */
+declare const KIMESH_CONTEXT_KEY: InjectionKey<FullContext>;
+/**
+ * Param value types for route parameters
+ */
+type ParamValue<isRaw extends boolean> = true extends isRaw ? string | number : string;
+type ParamValueOneOrMore<isRaw extends boolean> = [ParamValue<isRaw>, ...ParamValue<isRaw>[]];
+type ParamValueZeroOrMore<isRaw extends boolean> = true extends isRaw ? ParamValue<isRaw>[] | undefined | null : ParamValue<isRaw>[] | undefined;
+type ParamValueZeroOrOne<isRaw extends boolean> = true extends isRaw ? string | number | null | undefined : string;
+/**
+ * Extract param names from a route path string
+ * e.g., '/blog/:postId/comments/:commentId' → 'postId' | 'commentId'
+ */
+type ExtractParamNames<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? ExtractParamName<Param> | ExtractParamNames<`/${Rest}`> : T extends `${string}:${infer Param}` ? ExtractParamName<Param> : never;
+/**
+ * Clean param name (remove optional ? or * modifiers)
+ */
+type ExtractParamName<T extends string> = T extends `${infer Name}?` ? Name : T extends `${infer Name}*` ? Name : T extends `${infer Name}+` ? Name : T;
+/**
+ * Extract params object from route path
+ * e.g., '/blog/:postId' → { postId: string }
+ */
+type ExtractRouteParams<T extends string> = ExtractParamNames<T> extends never ? Record<string, string> : { [K in ExtractParamNames<T>]: string };
+/**
+ * Route record info type - populated by generated types
+ */
+interface RouteRecordInfo<Name extends string = string, Path extends string = string, ParamsRaw extends Record<string, unknown> = Record<string, unknown>, Params extends Record<string, unknown> = Record<string, unknown>, Children extends string = never> {
+  name: Name;
+  path: Path;
+  paramsRaw: ParamsRaw;
+  params: Params;
+  children: Children;
+}
+/**
+ * Route named map - populated by generated types
+ * This interface is augmented by route-types.d.ts
+ */
+interface RouteNamedMap {}
+/** Get all route names - falls back to string when RouteNamedMap is empty */
+type RouteNames = keyof RouteNamedMap extends never ? string : keyof RouteNamedMap;
+/** Allow both named routes and arbitrary string paths (& {} preserves autocomplete) */
+type RouteLocationRaw = RouteNames | (string & {});
+/** Get route info by name */
+type RouteInfoByName<T extends string> = T extends keyof RouteNamedMap ? RouteNamedMap[T] : RouteRecordInfo<T, T>;
+/** Get raw params for a route name (accepts string | number) */
+type RouteParamsRaw<T extends string> = T extends keyof RouteNamedMap ? RouteNamedMap[T] extends RouteRecordInfo<any, any, infer P, any, any> ? P : Record<string, string | number> : Record<string, string | number>;
+/** Get resolved params for a route name (string only) */
+type RouteParams<T extends string> = T extends keyof RouteNamedMap ? RouteNamedMap[T] extends RouteRecordInfo<any, any, any, infer P, any> ? P : Record<string, string> : Record<string, string>;
+/** Get path for a route name */
+type RoutePath<T extends string> = T extends keyof RouteNamedMap ? RouteNamedMap[T] extends RouteRecordInfo<any, infer P, any, any, any> ? P : string : string;
+/** Check if route has params */
+type HasParams<T extends string> = T extends keyof RouteNamedMap ? keyof RouteParams<T> extends never ? false : true : boolean;
+/**
+ * Options for creating a Kimesh app
+ */
+interface CreateKimeshAppOptions {
+  /** Root component (usually App.vue or a layout) */
+  rootComponent: Component;
+  /** Route records array */
+  routes: RouteRecordRaw[];
+  /** Base URL for router */
+  base?: string;
+  /** History mode */
+  history?: "hash" | "web";
+  /** Scroll behavior */
+  scrollBehavior?: Router["options"]["scrollBehavior"];
+  /** Query client configuration */
+  queryClientConfig?: QueryClientConfig;
+  /** Custom context (user-defined) */
+  context?: KimeshContext | (() => KimeshContext);
+}
+/**
+ * Kimesh App instance
+ */
+interface KimeshApp {
+  /** Vue app instance */
+  app: App;
+  /** Vue Router instance */
+  router: Router;
+  /** Query client instance */
+  queryClient: QueryClient;
+  /** Kimesh app context (new runtime plugin system) */
+  context?: KimeshAppContext;
+  /** Mount the app */
+  mount(container: string | Element): KimeshApp | Promise<KimeshApp>;
+  /** Unmount the app */
+  unmount(): void;
+}
+/**
+ * Loader context passed to loader functions
+ */
+interface LoaderContext<TParams = Record<string, string>, TSearch = 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;
+  /** AbortSignal for cancellation */
+  signal: AbortSignal;
+}
+/**
+ * Loader function type
+ */
+type LoaderFn<TParams = Record<string, string>, TSearch = Record<string, unknown>, TData = unknown> = (ctx: LoaderContext<TParams, TSearch>) => Promise<TData> | TData;
+/**
+ * Schema interface for validateSearch (compatible with Zod)
+ */
+interface SearchSchema<T = unknown> {
+  parse: (input: unknown) => T;
+  safeParse?: (input: unknown) => {
+    success: boolean;
+    data?: T;
+    error?: unknown;
+  };
+}
+/**
+ * Context passed to route head function
+ */
+interface RouteHeadContext<TParams = Record<string, string>, TLoaderData = unknown> {
+  /** Route params extracted from URL */
+  params: TParams;
+  /** Data returned from route loader */
+  loaderData: TLoaderData;
+  /** Current route */
+  route: RouteLocationNormalizedLoaded;
+}
+/**
+ * Route head configuration - compatible with @unhead/vue Head type
+ */
+interface RouteHeadConfig {
+  /** Page title */
+  title?: string;
+  /** Title template (e.g., '%s | My App') */
+  titleTemplate?: string | ((title: string) => string);
+  /** Meta tags */
+  meta?: Array<{
+    name?: string;
+    property?: string;
+    content?: string;
+    charset?: string;
+    "http-equiv"?: string;
+    [key: string]: string | undefined;
+  }>;
+  /** Link tags */
+  link?: Array<{
+    rel?: string;
+    href?: string;
+    type?: string;
+    as?: string;
+    crossorigin?: string;
+    media?: string;
+    sizes?: string;
+    hreflang?: string;
+    title?: string;
+    [key: string]: string | undefined;
+  }>;
+  /** Script tags */
+  script?: Array<{
+    src?: string;
+    async?: boolean;
+    defer?: boolean;
+    type?: string;
+    innerHTML?: string;
+    [key: string]: string | boolean | undefined;
+  }>;
+  /** Style tags */
+  style?: Array<{
+    innerHTML?: string;
+    media?: string;
+    type?: string;
+    [key: string]: string | undefined;
+  }>;
+  /** HTML attributes */
+  htmlAttrs?: {
+    lang?: string;
+    dir?: "ltr" | "rtl" | "auto";
+    class?: string;
+    [key: string]: string | undefined;
+  };
+  /** Body attributes */
+  bodyAttrs?: {
+    class?: string;
+    [key: string]: string | undefined;
+  };
+}
+/**
+ * Route head function signature
+ */
+type RouteHeadFn<TParams = Record<string, string>, TLoaderData = unknown> = (context: RouteHeadContext<TParams, TLoaderData>) => RouteHeadConfig;
+/**
+ * Inline middleware context for typed routes
+ */
+interface InlineMiddlewareContext {
+  /** Vue Router instance */
+  router: Router;
+  /** Kimesh app context */
+  app: KimeshAppContext;
+  /** Custom data for sharing between middleware */
+  data: Record<string, unknown>;
+}
+/**
+ * Inline route middleware with typed params
+ * Used in createFileRoute for automatic param inference
+ */
+type InlineRouteMiddleware<TParams = Record<string, string>> = (to: RouteLocationNormalized & {
+  params: TParams;
+}, from: RouteLocationNormalized, context: InlineMiddlewareContext) => void | undefined | false | {
+  path?: string;
+  name?: string;
+} | Promise<void | undefined | false | {
+  path?: string;
+  name?: string;
+}>;
+/**
+ * File route options
+ */
+interface FileRouteOptions<TMeta = unknown, TParams = Record<string, string>, TSearch = Record<string, unknown>, TLoaderData = unknown> {
+  /** Route meta */
+  meta?: TMeta;
+  /** Loader function - runs before navigation completes */
+  loader?: LoaderFn<TParams, TSearch, TLoaderData>;
+  /** Search params validation schema (Zod compatible) */
+  validateSearch?: SearchSchema<TSearch>;
+  /**
+   * Route middleware (runs before beforeLoad)
+   *
+   * @example Named middleware
+   * ```ts
+   * middleware: 'admin'
+   * ```
+   *
+   * @example Multiple middleware
+   * ```ts
+   * middleware: ['auth', 'analytics']
+   * ```
+   *
+   * @example Inline middleware (typed params!)
+   * ```ts
+   * middleware: (to, from, ctx) => {
+   *   // to.params is typed based on route path!
+   *   console.log(to.params.postId)
+   * }
+   * ```
+   */
+  middleware?: string | InlineRouteMiddleware<TParams> | Array<string | InlineRouteMiddleware<TParams>>;
+  /** Before load hook (runs after middleware) */
+  beforeLoad?: (ctx: BeforeLoadContext) => Promise<void> | void;
+  /**
+   * Route-level head configuration
+   *
+   * @example Static head
+   * ```ts
+   * head: {
+   *   title: 'About Us',
+   *   meta: [{ name: 'description', content: 'Learn about our company' }]
+   * }
+   * ```
+   *
+   * @example Dynamic head from loader
+   * ```ts
+   * head: ({ loaderData }) => ({
+   *   title: loaderData.post.title,
+   *   meta: [{ property: 'og:title', content: loaderData.post.title }]
+   * })
+   * ```
+   */
+  head?: RouteHeadFn<TParams, TLoaderData> | RouteHeadConfig;
+  /**
+   * Page transition configuration
+   *
+   * @example
+   * ```ts
+   * transition: { name: 'slide', mode: 'out-in' }
+   * // or disable transition
+   * transition: false
+   * ```
+   */
+  transition?: boolean | TransitionProps;
+  /**
+   * View Transition API (experimental)
+   * Uses native browser document.startViewTransition() API
+   *
+   * @example
+   * ```ts
+   * viewTransition: true // respect user's prefers-reduced-motion
+   * viewTransition: 'always' // always use view transitions
+   * ```
+   */
+  viewTransition?: boolean | "always";
+  /**
+   * KeepAlive configuration for route component
+   *
+   * @example
+   * ```ts
+   * keepalive: true
+   * keepalive: { max: 10 }
+   * ```
+   */
+  keepalive?: boolean | KeepAliveProps;
+}
+/**
+ * Before load context
+ */
+interface BeforeLoadContext {
+  /** Current route */
+  route: RouteLocationNormalizedLoaded;
+  /** Router instance */
+  router: Router;
+  /** Abort navigation */
+  abort: () => void;
+}
+/**
+ * Route definition returned by createFileRoute
+ */
+interface RouteDefinition<TPath extends string = string, TMeta = unknown, TParams = Record<string, string>, TSearch = Record<string, unknown>, TLoaderData = unknown> {
+  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;
+  head?: RouteHeadFn<TParams, TLoaderData> | RouteHeadConfig;
+  transition?: boolean | TransitionProps;
+  viewTransition?: boolean | "always";
+  keepalive?: boolean | KeepAliveProps;
+}
+declare module "vue-router" {
+  interface RouteMeta {
+    /** Kimesh route definition with loader */
+    __kimesh?: RouteDefinition;
+    /** Error from loader execution */
+    __kimeshError?: unknown;
+    /** Source layer name for layer-aware features */
+    __kimeshLayer?: string;
+  }
+}
+//#endregion
+//#region src/create-app.d.ts
+declare const KIMESH_APP_CONTEXT_KEY: InjectionKey<KimeshAppContext>;
+interface CreateKimeshAppOptionsExtended extends CreateKimeshAppOptions {
+  plugins?: KimeshRuntimePlugin[];
+  runtimeConfig?: RuntimeConfigPublic;
+  /** Per-layer runtime configs (for layer-aware features like $fetch) */
+  layersConfig?: Record<string, Record<string, unknown>>;
+}
+/**
+ * Create a Kimesh application with router, query client, and runtime plugins
+ */
+declare function createKimeshApp(options: CreateKimeshAppOptionsExtended): Promise<KimeshApp>;
+//#endregion
+//#region src/create-file-route.d.ts
+/**
+ * Create a file-based route definition
+ *
+ * @example
+ * ```ts
+ * // In routes/about.vue
+ * export const Route = createFileRoute('/about')({
+ *   meta: { title: 'About Us' },
+ *   loader: async () => {
+ *     return { data: await fetchAboutData() }
+ *   },
+ *   head: {
+ *     title: 'About Us',
+ *     meta: [{ name: 'description', content: 'Learn about us' }]
+ *   }
+ * })
+ * ```
+ *
+ * @example With typed params
+ * ```ts
+ * // In routes/users/$userId.vue
+ * export const Route = createFileRoute('/users/:userId')({
+ *   middleware: (to, from, ctx) => {
+ *     // to.params.userId is typed!
+ *     console.log(to.params.userId)
+ *   },
+ *   loader: ({ params }) => {
+ *     // params.userId is typed!
+ *     return fetchUser(params.userId)
+ *   }
+ * })
+ * ```
+ */
+declare function createFileRoute<TPath extends string>(path: TPath): <TMeta = unknown>(options?: FileRouteOptions<TMeta, ExtractRouteParams<TPath>>) => RouteDefinition<TPath, TMeta, ExtractRouteParams<TPath>>;
+/**
+ * Define route for use in Vue SFC
+ * Alternative syntax for createFileRoute
+ */
+declare function defineRoute<TMeta = unknown>(options: FileRouteOptions<TMeta>): FileRouteOptions<TMeta>;
+//#endregion
+//#region src/context.d.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(),
+ * }))
+ * ```
+ */
+declare function defineContext<T extends KimeshContext>(factory: () => T): () => T;
+/**
+ * Use Kimesh context in components
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const ctx = useKimeshContext()
+ * ctx.auth.logout()
+ * </script>
+ * ```
+ */
+declare function useKimeshContext(): FullContext;
+//#endregion
+//#region src/runtime-plugin.d.ts
+declare 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() } }
+ *   }
+ * })
+ * ```
+ */
+declare function defineKimeshRuntimePlugin<Injections extends Record<string, unknown> = Record<string, unknown>>(plugin: KimeshRuntimePlugin<Injections> | KimeshRuntimePluginDefinition<Injections>): KimeshRuntimePlugin<Injections>;
+/**
+ * Check if a value is a Kimesh runtime plugin
+ */
+declare function isKimeshRuntimePlugin(value: unknown): value is KimeshRuntimePlugin;
+/**
+ * Get plugin metadata
+ */
+declare function getPluginMeta(plugin: KimeshRuntimePlugin): KimeshRuntimePluginMeta;
+/**
+ * Get plugin name
+ */
+declare function getPluginName(plugin: KimeshRuntimePlugin): string;
+/**
+ * Get plugin hooks
+ */
+declare function getPluginHooks(plugin: KimeshRuntimePlugin): Partial<KimeshRuntimeHooks> | undefined;
+//#endregion
+//#region src/plugin-executor.d.ts
+/**
+ * Apply a single plugin to the app context
+ */
+declare function applyPlugin(app: KimeshAppContext, plugin: KimeshRuntimePlugin): Promise<void>;
+/**
+ * Apply all plugins to the app context with dependency resolution
+ */
+declare function applyPlugins(app: KimeshAppContext, plugins: KimeshRuntimePlugin[]): Promise<void>;
+/**
+ * Apply plugins with parallel support.
+ * Plugins with parallel: true run concurrently within their group.
+ */
+declare function applyPluginsWithParallel(app: KimeshAppContext, plugins: KimeshRuntimePlugin[]): Promise<void>;
+//#endregion
+//#region src/plugins/core.d.ts
+/**
+ * @kimesh/router-runtime - Core Plugins
+ *
+ * Built-in runtime plugins for Kimesh.
+ */
+/**
+ * Router plugin that wires Vue Router guards to Kimesh hook system
+ *
+ * This plugin runs with `enforce: 'pre'` to ensure router hooks
+ * are available to all other plugins.
+ */
+declare const routerPlugin: KimeshRuntimePlugin<Record<string, unknown>>;
+interface QueryPluginOptions {
+  /** Enable route-based prefetching */
+  prefetching?: boolean;
+  /** Paths to exclude from prefetching */
+  excludePrefetch?: (string | RegExp)[];
+  [key: string]: unknown;
+}
+/**
+ * Query plugin that sets up prefetching on navigation
+ *
+ * Note: QueryClient is already initialized in createKimeshApp,
+ * this plugin adds navigation-based prefetching.
+ */
+declare const queryPlugin: KimeshRuntimePlugin<QueryPluginOptions>;
+/**
+ * Get the default core plugins for a Kimesh app
+ */
+declare function getCorePlugins(): KimeshRuntimePlugin<Record<string, unknown>>[];
+//#endregion
+//#region src/components/KmOutlet.d.ts
+/**
+ * KmOutlet - Router view wrapper component
+ * 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
+ */
+declare const KmOutlet: vue13.DefineComponent<vue13.ExtractPropTypes<{
+  name: {
+    type: StringConstructor;
+    default: string;
+  };
+  /**
+   * Page transition configuration (Vue Transition)
+   * ⚠️ Avoid mode: 'out-in' with async pages
+   */
+  transition: {
+    type: any;
+    default: undefined;
+  };
+  /**
+   * Enable View Transitions API (recommended for async pages)
+   * Works in Chrome 111+, Edge 111+, Opera 97+
+   * Falls back to instant transition on unsupported browsers
+   */
+  viewTransition: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * KeepAlive configuration
+   */
+  keepalive: {
+    type: any;
+    default: undefined;
+  };
+  /**
+   * Custom page key function for route identification
+   */
+  pageKey: {
+    type: any;
+    default: null;
+  };
+}>, () => VNode, {}, {}, {}, vue13.ComponentOptionsMixin, vue13.ComponentOptionsMixin, {}, string, vue13.PublicProps, Readonly<vue13.ExtractPropTypes<{
+  name: {
+    type: StringConstructor;
+    default: string;
+  };
+  /**
+   * Page transition configuration (Vue Transition)
+   * ⚠️ Avoid mode: 'out-in' with async pages
+   */
+  transition: {
+    type: any;
+    default: undefined;
+  };
+  /**
+   * Enable View Transitions API (recommended for async pages)
+   * Works in Chrome 111+, Edge 111+, Opera 97+
+   * Falls back to instant transition on unsupported browsers
+   */
+  viewTransition: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  /**
+   * KeepAlive configuration
+   */
+  keepalive: {
+    type: any;
+    default: undefined;
+  };
+  /**
+   * Custom page key function for route identification
+   */
+  pageKey: {
+    type: any;
+    default: null;
+  };
+}>> & Readonly<{}>, {
+  name: string;
+  transition: any;
+  viewTransition: boolean;
+  keepalive: any;
+  pageKey: any;
+}, {}, {}, {}, string, vue13.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/KmLink.d.ts
+/**
+ * Type-safe link props - requires params if route has them
+ * Allows both named routes (with autocomplete) and raw string paths
+ */
+type KmLinkProps<T extends string = RouteNames> = T extends RouteNames ? HasParams<T> extends true ? {
+  to: T;
+  params: RouteParamsRaw<T>;
+  replace?: boolean;
+} : HasParams<T> extends false ? {
+  to: T;
+  params?: undefined;
+  replace?: boolean;
+} : {
+  to: T;
+  params?: Record<string, string | number>;
+  replace?: boolean;
+} : {
+  to: T;
+  params?: Record<string, string | number>;
+  replace?: boolean;
+};
+/**
+ * KmLink - Type-safe router link component
+ *
+ * @example
+ * ```vue
+ * <!-- Static route -->
+ * <KmLink to="/posts">Posts</KmLink>
+ *
+ * <!-- Dynamic route with params -->
+ * <KmLink to="/posts/:postId" :params="{ postId: '123' }">
+ *   Post 123
+ * </KmLink>
+ * ```
+ */
+declare const KmLink: vue13.DefineComponent<vue13.ExtractPropTypes<{
+  to: {
+    type: PropType<RouteLocationRaw>;
+    required: true;
+  };
+  params: {
+    type: PropType<Record<string, string | number>>;
+    default: undefined;
+  };
+  replace: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  activeClass: {
+    type: StringConstructor;
+    default: string;
+  };
+  exactActiveClass: {
+    type: StringConstructor;
+    default: string;
+  };
+  prefetch: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  tag: {
+    type: StringConstructor;
+    default: string;
+  };
+}>, () => vue13.VNode<vue13.RendererNode, vue13.RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, vue13.ComponentOptionsMixin, vue13.ComponentOptionsMixin, {}, string, vue13.PublicProps, Readonly<vue13.ExtractPropTypes<{
+  to: {
+    type: PropType<RouteLocationRaw>;
+    required: true;
+  };
+  params: {
+    type: PropType<Record<string, string | number>>;
+    default: undefined;
+  };
+  replace: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  activeClass: {
+    type: StringConstructor;
+    default: string;
+  };
+  exactActiveClass: {
+    type: StringConstructor;
+    default: string;
+  };
+  prefetch: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  tag: {
+    type: StringConstructor;
+    default: string;
+  };
+}>> & Readonly<{}>, {
+  params: Record<string, string | number>;
+  replace: boolean;
+  activeClass: string;
+  exactActiveClass: string;
+  prefetch: boolean;
+  tag: string;
+}, {}, {}, {}, string, vue13.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/components/KmDeferred.d.ts
+/**
+ * KmDeferred - Suspense wrapper with error handling
+ *
+ * Wraps Vue's <Suspense> with error boundary functionality.
+ * Use with useSuspenseQuery for progressive data loading.
+ *
+ * @example
+ * ```vue
+ * <KmDeferred :timeout="200">
+ *   <AsyncDataComponent />
+ *   <template #fallback>
+ *     <Skeleton />
+ *   </template>
+ *   <template #error="{ error, retry }">
+ *     <ErrorCard :error="error" @retry="retry" />
+ *   </template>
+ * </KmDeferred>
+ * ```
+ */
+declare const KmDeferred: vue13.DefineComponent<vue13.ExtractPropTypes<{
+  /**
+   * Delay in ms before showing fallback (default: 0)
+   * Helps avoid flashing loading states for fast loads
+   */
+  timeout: {
+    type: PropType<number>;
+    default: number;
+  };
+}>, () => VNode, {}, {}, {}, vue13.ComponentOptionsMixin, vue13.ComponentOptionsMixin, {}, string, vue13.PublicProps, Readonly<vue13.ExtractPropTypes<{
+  /**
+   * Delay in ms before showing fallback (default: 0)
+   * Helps avoid flashing loading states for fast loads
+   */
+  timeout: {
+    type: PropType<number>;
+    default: number;
+  };
+}>> & Readonly<{}>, {
+  timeout: number;
+}, {}, {}, {}, string, vue13.ComponentProvideOptions, true, {}, any>;
+//#endregion
+//#region src/guards/loader-guard.d.ts
+interface LoaderGuardOptions {
+  onError?: (error: Error, to: RouteLocationNormalized) => void;
+}
+/**
+ * Create the loader navigation guard
+ */
+declare function createLoaderGuard(context: FullContext, options?: LoaderGuardOptions): (to: RouteLocationNormalized, from: RouteLocationNormalized, abortController: AbortController) => Promise<void>;
+/**
+ * Install loader guard on router
+ */
+declare function installLoaderGuard(router: Router, context: FullContext, options?: {
+  onError?: (error: Error, to: RouteLocationNormalized) => void;
+}): () => void;
+//#endregion
+//#region src/composables/use-search.d.ts
+interface UseSearchReturn<T> {
+  search: ComputedRef<T>;
+  setSearch: <K extends keyof T>(key: K, value: T[K]) => void;
+  setAllSearch: (params: Partial<T>) => void;
+  resetSearch: () => void;
+}
+/**
+ * Access and update validated search params
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useSearch } from '@kimesh/router-runtime'
+ * import { z } from 'zod'
+ *
+ * const searchSchema = z.object({
+ *   page: z.coerce.number().default(1),
+ *   sort: z.enum(['asc', 'desc']).default('desc')
+ * })
+ *
+ * const { search, setSearch } = useSearch(searchSchema)
+ * </script>
+ * ```
+ */
+declare function useSearch<T>(schema: SearchSchema<T>): UseSearchReturn<T>;
+//#endregion
+//#region src/composables/use-params.d.ts
+/**
+ * Get typed route params (non-reactive snapshot)
+ *
+ * @example
+ * ```ts
+ * // In /posts/:postId page
+ * const params = useParams<'/posts/:postId'>()
+ * // params is typed as { postId: string }
+ * console.log(params.postId)
+ * ```
+ */
+declare function useParams<T extends string = RouteNames>(): RouteParams<T>;
+/**
+ * Get reactive typed route params
+ *
+ * @example
+ * ```ts
+ * // In /posts/:postId page
+ * const params = useReactiveParams<'/posts/:postId'>()
+ * // params.value is typed as { postId: string }
+ * watchEffect(() => {
+ *   console.log(params.value.postId)
+ * })
+ * ```
+ */
+declare function useReactiveParams<T extends string = RouteNames>(): ComputedRef<RouteParams<T>>;
+//#endregion
+//#region src/composables/use-navigate.d.ts
+/**
+ * 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 ? {
+  to: T;
+  params: RouteParamsRaw<T>;
+  replace?: boolean;
+} : HasParams<T> extends false ? {
+  to: T;
+  params?: undefined;
+  replace?: boolean;
+} : {
+  to: T;
+  params?: Record<string, string | number>;
+  replace?: boolean;
+}) : {
+  to: T;
+  params?: Record<string, string | number>;
+  replace?: boolean;
+};
+/**
+ * Type-safe navigation composable
+ *
+ * @example
+ * ```ts
+ * const { navigate } = useNavigate()
+ *
+ * // Navigate to static route
+ * navigate({ to: '/posts' })
+ *
+ * // Navigate to dynamic route with params
+ * navigate({ to: '/posts/:postId', params: { postId: '123' } })
+ *
+ * // Replace instead of push
+ * navigate({ to: '/posts', replace: true })
+ * ```
+ */
+declare function useNavigate(): {
+  navigate: <T extends RouteLocationRaw = string>(options: NavigateOptions<T>) => Promise<void | vue_router0.NavigationFailure | undefined>;
+  back: () => void;
+  forward: () => void;
+  go: (delta: number) => void;
+  router: vue_router0.Router;
+};
+//#endregion
+//#region src/composables/use-runtime-config.d.ts
+/**
+ * @kimesh/router-runtime - useRuntimeConfig composable
+ *
+ * Provides type-safe access to runtime configuration.
+ * Phase 1: Client-side only, returns build-time injected config.
+ */
+/**
+ * Runtime configuration type.
+ * Users can extend this interface via declaration merging for type-safe config access.
+ *
+ * @example
+ * ```ts
+ * // src/types/runtime-config.d.ts
+ * declare module '@kimesh/router-runtime' {
+ *   interface RuntimeConfig {
+ *     apiBase: string;
+ *     debug: boolean;
+ *     features: {
+ *       darkMode: boolean;
+ *     };
+ *   }
+ * }
+ * ```
+ */
+interface RuntimeConfig {
+  [key: string]: unknown;
+}
+/**
+ * Access runtime configuration.
+ *
+ * Returns the runtime config that was injected at build time via Vite's `define`.
+ * Values can be overridden using `KIMESH_*` environment variables during build.
+ *
+ * @returns Frozen runtime config object
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const config = useRuntimeConfig()
+ * console.log(config.apiBase)
+ * console.log(config.debug)
+ * </script>
+ * ```
+ *
+ * @example
+ * ```ts
+ * // In a composable
+ * export function useApi() {
+ *   const config = useRuntimeConfig()
+ *
+ *   async function fetch<T>(endpoint: string): Promise<T> {
+ *     const url = `${config.apiBase}${endpoint}`
+ *     const response = await globalThis.fetch(url)
+ *     return response.json()
+ *   }
+ *
+ *   return { fetch }
+ * }
+ * ```
+ */
+declare function useRuntimeConfig<T extends RuntimeConfig = RuntimeConfig>(): T;
+//#endregion
+//#region src/composables/use-kimesh-app.d.ts
+/**
+ * Get the Kimesh app context
+ *
+ * @example
+ * ```ts
+ * const { router, queryClient, $config } = useKimeshApp()
+ * console.log($config.apiUrl)
+ * ```
+ *
+ * @throws Error if called outside a Kimesh app
+ */
+declare function useKimeshApp(): KimeshAppContext;
+/**
+ * Try to get the Kimesh app context without throwing
+ */
+declare function tryUseKimeshApp(): KimeshAppContext | undefined;
+//#endregion
+//#region src/composables/useState.d.ts
+declare const STATE_KEY_PREFIX = "$s_";
+/**
+ * Get all state keys (without prefix).
+ */
+declare function getKmStateKeys(): string[];
+/**
+ * Check if a state exists.
+ */
+declare function hasKmState(key: string): boolean;
+/**
+ * Clear Kimesh state by key(s) or predicate.
+ * Pass undefined to clear all state, a string for single key,
+ * an array for multiple keys, or a predicate function.
+ */
+declare function clearKmState(keys?: string | string[] | ((key: string) => boolean)): void;
+/**
+ * Get or create reactive state by key.
+ *
+ * @throws TypeError if key is not a non-empty string or init is not a function
+ * @throws Error if _state is not initialized
+ */
+declare function useState<T>(key: string, init?: () => T | Ref<T>): Ref<T>;
+//#endregion
+//#region src/composables/use-navigation-middleware.d.ts
+/**
+ * Navigation context for middleware
+ */
+interface NavigationContext {
+  to: RouteLocationNormalized;
+  from: RouteLocationNormalized;
+  failure?: NavigationFailure;
+}
+/**
+ * Navigation error context
+ */
+interface NavigationErrorContext {
+  error: Error;
+  to: RouteLocationNormalized;
+  from: RouteLocationNormalized;
+}
+type BeforeNavigationHandler = KimeshRuntimeHooks["navigate:before"];
+type AfterNavigationHandler = KimeshRuntimeHooks["navigate:after"];
+type ErrorNavigationHandler = KimeshRuntimeHooks["navigate:error"];
+/**
+ * Options for useNavigationMiddleware
+ */
+interface NavigationMiddlewareOptions {
+  /** Called before navigation */
+  before?: BeforeNavigationHandler;
+  /** Called after navigation */
+  after?: AfterNavigationHandler;
+  /** Called on navigation error */
+  error?: ErrorNavigationHandler;
+}
+/**
+ * Register navigation middleware using the hook system
+ *
+ * @example
+ * ```ts
+ * // In a plugin or component setup
+ * const { remove } = useNavigationMiddleware({
+ *   before: ({ to }) => {
+ *     if (!isAuthenticated() && to.meta.requiresAuth) {
+ *       return false // Cancel navigation
+ *     }
+ *   },
+ *   after: ({ to }) => {
+ *     analytics.trackPageView(to.path)
+ *   },
+ *   error: ({ error }) => {
+ *     console.error('Navigation failed:', error)
+ *   },
+ * })
+ *
+ * // Cleanup when done
+ * onUnmounted(() => remove())
+ * ```
+ *
+ * @returns Object with remove function to cleanup hooks
+ */
+declare function useNavigationMiddleware(options: NavigationMiddlewareOptions): {
+  remove: () => void;
+};
+/**
+ * Create a navigation guard that runs before navigation
+ *
+ * @example
+ * ```ts
+ * // Auth guard plugin
+ * export default defineKimeshRuntimePlugin({
+ *   name: 'auth-guard',
+ *   setup(app) {
+ *     app.runWithContext(() => {
+ *       useNavigationGuard(({ to }) => {
+ *         if (to.meta.requiresAuth && !isAuthenticated()) {
+ *           return false
+ *         }
+ *       })
+ *     })
+ *   }
+ * })
+ * ```
+ */
+declare function useNavigationGuard(guard: BeforeNavigationHandler): () => void;
+/**
+ * Register a callback for after navigation
+ */
+declare function useAfterNavigation(callback: AfterNavigationHandler): () => void;
+//#endregion
+//#region src/middleware/types.d.ts
+/**
+ * Navigation redirect configuration
+ */
+interface NavigationRedirect {
+  /** Target path */
+  path?: string;
+  /** Target route name */
+  name?: string;
+  /** Route params */
+  params?: Record<string, unknown>;
+  /** Query parameters */
+  query?: Record<string, unknown>;
+  /** Replace current history entry instead of pushing */
+  replace?: boolean;
+  /** HTTP redirect code (for SSR) */
+  redirectCode?: 301 | 302 | 303 | 307 | 308;
+}
+/**
+ * Middleware execution result
+ */
+type MiddlewareResult = void | undefined | false | NavigationRedirect | Promise<void | undefined | false | NavigationRedirect>;
+/**
+ * Middleware execution context
+ */
+interface MiddlewareContext {
+  /** Current route being navigated to */
+  to: RouteLocationNormalized;
+  /** Previous route */
+  from: RouteLocationNormalized;
+  /** Vue Router instance */
+  router: Router;
+  /** Kimesh app context */
+  app: KimeshAppContext;
+  /** Custom data for sharing between middleware */
+  data: Record<string, unknown>;
+}
+/**
+ * Middleware function signature
+ */
+type RouteMiddleware = (to: RouteLocationNormalized, from: RouteLocationNormalized, context: MiddlewareContext) => MiddlewareResult;
+/**
+ * Typed middleware function with specific params type
+ * Use this when you need typed params in inline middleware
+ *
+ * @example
+ * ```ts
+ * export const Route = createFileRoute('/users/:userId')({
+ *   middleware: ((to, from, ctx) => {
+ *     const userId = to.params.userId // typed!
+ *   }) as TypedRouteMiddleware<{ userId: string }>
+ * })
+ * ```
+ */
+type TypedRouteMiddleware<TParams extends Record<string, string> = Record<string, string>> = (to: RouteLocationNormalized & {
+  params: TParams;
+}, from: RouteLocationNormalized, context: MiddlewareContext) => MiddlewareResult;
+/**
+ * Object-style middleware definition
+ */
+interface MiddlewareDefinition {
+  /** Optional middleware name */
+  name?: string;
+  /** Execution priority (higher = earlier) */
+  priority?: number;
+  /** Whether this middleware is global */
+  global?: boolean;
+  /** The middleware execution function */
+  execute: RouteMiddleware;
+}
+/**
+ * navigateTo options
+ */
+interface NavigateToOptions {
+  /** Replace current history entry instead of pushing */
+  replace?: boolean;
+  /** HTTP redirect code (for SSR) */
+  redirectCode?: 301 | 302 | 303 | 307 | 308;
+  /** External URL (will use window.location) */
+  external?: boolean;
+  /** Query parameters to add */
+  query?: Record<string, string | number>;
+}
+/**
+ * Middleware registry entry
+ */
+interface MiddlewareRegistryEntry {
+  name: string;
+  fileName: string;
+  isGlobal: boolean;
+  priority: number;
+  middleware: RouteMiddleware | MiddlewareDefinition;
+}
+/**
+ * Generated middleware registry interface
+ */
+interface MiddlewareRegistry {
+  globalMiddleware: RouteMiddleware[];
+  namedMiddleware: Record<string, () => Promise<RouteMiddleware>>;
+  middlewareNames: readonly string[];
+  getGlobalMiddleware: () => RouteMiddleware[];
+  getNamedMiddleware: (name: string) => (() => Promise<RouteMiddleware>) | undefined;
+  hasMiddleware: (name: string) => boolean;
+}
+/**
+ * Middleware option for route meta
+ */
+type MiddlewareOption = string | RouteMiddleware | Array<string | RouteMiddleware>;
+/**
+ * Type augmentation for KimeshMiddlewareNames
+ * This is augmented by generated types
+ */
+interface KimeshMiddlewareNames {}
+/**
+ * Known middleware names (union of user-defined middleware)
+ */
+type KnownMiddleware = keyof KimeshMiddlewareNames extends never ? string : keyof KimeshMiddlewareNames;
+//#endregion
+//#region src/middleware/helpers.d.ts
+/**
+ * Define a Kimesh middleware function
+ *
+ * @example Function-style
+ * ```ts
+ * export default defineKimeshMiddleware((to, from, ctx) => {
+ *   if (!isAuthenticated()) {
+ *     return navigateTo('/login')
+ *   }
+ * })
+ * ```
+ *
+ * @example Object-style
+ * ```ts
+ * export default defineKimeshMiddleware({
+ *   name: 'auth',
+ *   priority: 100,
+ *   execute(to, from, ctx) {
+ *     if (!isAuthenticated()) {
+ *       return abortNavigation('Not authenticated')
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function defineKimeshMiddleware(middleware: RouteMiddleware): RouteMiddleware;
+declare function defineKimeshMiddleware(definition: MiddlewareDefinition): RouteMiddleware;
+/**
+ * Navigate to a different route from middleware
+ *
+ * @example Simple path
+ * ```ts
+ * return navigateTo('/dashboard')
+ * ```
+ *
+ * @example Route object
+ * ```ts
+ * return navigateTo({ name: 'user', params: { id: '123' } })
+ * ```
+ *
+ * @example With options
+ * ```ts
+ * return navigateTo('/home', { replace: true })
+ * ```
+ */
+declare function navigateTo(to: string | NavigationRedirect, options?: NavigateToOptions): NavigationRedirect;
+/**
+ * Abort the current navigation
+ *
+ * @example
+ * ```ts
+ * return abortNavigation()
+ * ```
+ *
+ * @example With reason
+ * ```ts
+ * return abortNavigation('Unauthorized access')
+ * ```
+ *
+ * @example With error
+ * ```ts
+ * return abortNavigation(new Error('Custom error'))
+ * ```
+ */
+declare function abortNavigation(reason?: string | Error): false;
+//#endregion
+//#region src/middleware/plugin.d.ts
+/**
+ * @kimesh/router-runtime - Middleware Plugin
+ *
+ * Runtime plugin that integrates middleware execution with Vue Router.
+ * Executes middleware in router.beforeEach guard.
+ */
+/**
+ * Middleware runtime plugin
+ * Registers with Vue Router and executes middleware on navigation
+ */
+declare const middlewarePlugin: KimeshRuntimePlugin<{
+  middleware: {
+    globalCount: number;
+    namedCount: number;
+  };
+}>;
+//#endregion
+//#region src/middleware/context.d.ts
+/**
+ * Create middleware execution context
+ */
+declare function createMiddlewareContext(to: RouteLocationNormalized, from: RouteLocationNormalized, appContext: KimeshAppContext): MiddlewareContext;
+//#endregion
+//#region src/middleware/executor.d.ts
+/**
+ * Execute a single middleware function
+ */
+declare function executeMiddleware(middleware: RouteMiddleware, context: MiddlewareContext, appContext: KimeshAppContext): Promise<void | false | NavigationRedirect>;
+/**
+ * Execute a chain of middleware functions
+ * Stops on first non-void result (redirect or abort)
+ */
+declare function executeMiddlewareChain(middlewares: RouteMiddleware[], context: MiddlewareContext, appContext: KimeshAppContext): Promise<void | false | NavigationRedirect>;
+/**
+ * Create middleware executor with app context
+ */
+declare function createMiddlewareExecutor(appContext: KimeshAppContext): {
+  /**
+   * Execute a middleware function
+   */
+  execute(middleware: RouteMiddleware, context: MiddlewareContext): Promise<void | false | NavigationRedirect>;
+  /**
+   * Execute a chain of middleware
+   */
+  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 };