@kimesh/router-runtime 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1129 @@
+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, useRouter } 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$1;
+  from: RouteLocationNormalized$1;
+}
+/**
+ * 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$1;
+  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;
+/**
+ * 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$1[];
+  /** Base URL for router */
+  base?: string;
+  /** History mode */
+  history?: "hash" | "web";
+  /** Scroll behavior */
+  scrollBehavior?: Router$1["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$1;
+  /** 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$1;
+}
+/**
+ * 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;
+/**
+ * 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>;
+  /** Before load hook */
+  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$1;
+  /** Router instance */
+  router: Router$1;
+  /** 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>;
+  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;
+  }
+} //# sourceMappingURL=types.d.ts.map
+//#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' }]
+ *   }
+ * })
+ * ```
+ */
+declare function createFileRoute<TPath extends string>(path: TPath): <TMeta = unknown>(options?: FileRouteOptions<TMeta>) => RouteDefinition<TPath, TMeta>;
+/**
+ * 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$1) => void;
+}
+/**
+ * Create the loader navigation guard
+ */
+declare function createLoaderGuard(context: FullContext, options?: LoaderGuardOptions): (to: RouteLocationNormalized$1, from: RouteLocationNormalized$1, abortController: AbortController) => Promise<void>;
+/**
+ * Install loader guard on router
+ */
+declare function installLoaderGuard(router: Router$1, context: FullContext, options?: {
+  onError?: (error: Error, to: RouteLocationNormalized$1) => 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$1;
+  from: RouteLocationNormalized$1;
+  failure?: NavigationFailure;
+}
+/**
+ * Navigation error context
+ */
+interface NavigationErrorContext {
+  error: Error;
+  to: RouteLocationNormalized$1;
+  from: RouteLocationNormalized$1;
+}
+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
+export { type BeforeLoadContext, type CreateKimeshAppOptions, type CreateKimeshAppOptionsExtended, type FileRouteOptions, type FullContext, type HasParams, KIMESH_APP_CONTEXT_KEY, KIMESH_CONTEXT_KEY, KIMESH_PLUGIN_INDICATOR, type KimeshApp, type KimeshAppContext, type KimeshContext, type KimeshRuntimeHooks, type KimeshRuntimePlugin, type KimeshRuntimePluginDefinition, type KimeshRuntimePluginMeta, type KimeshRuntimePluginResult, KmDeferred, KmLink, type KmLinkProps, KmOutlet, type LoaderContext, type LoaderFn, type LoaderGuardOptions, type NavigateOptions, type NavigationAfterHookContext, type NavigationContext, type NavigationErrorContext, type NavigationErrorHookContext, type NavigationGuard, type NavigationHookAfter, type NavigationHookContext, type NavigationMiddlewareOptions, type ParamValue, type ParamValueOneOrMore, type ParamValueZeroOrMore, type ParamValueZeroOrOne, type QueryPluginOptions, type RouteDefinition, type RouteHeadConfig, type RouteHeadContext, type RouteHeadFn, type RouteInfoByName, type RouteLocationNormalized, type RouteLocationNormalizedLoaded, type RouteLocationRaw, type RouteNamedMap, type RouteNames, type RouteParams, type RouteParamsRaw, type RoutePath, type RouteRecordInfo, type RouteRecordRaw, type Router, type RuntimeConfig, type RuntimeConfigPublic, STATE_KEY_PREFIX, type SearchSchema, type UseSearchReturn, applyPlugin, applyPlugins, applyPluginsWithParallel, clearKmState, createFileRoute, createKimeshApp, createLoaderGuard, defineContext, defineKimeshRuntimePlugin, defineRoute, getCorePlugins, getKmStateKeys, getPluginHooks, getPluginMeta, getPluginName, hasKmState, installLoaderGuard, isKimeshRuntimePlugin, onBeforeRouteLeave, onBeforeRouteUpdate, queryPlugin, routerPlugin, tryUseKimeshApp, useAfterNavigation, useKimeshApp, useKimeshContext, useLink, useNavigate, useNavigationGuard, useNavigationMiddleware, useParams, useReactiveParams, useRoute, useRouter, useRuntimeConfig, useSearch, useState };
+//# sourceMappingURL=index.d.mts.map