@kimesh/kit 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,2257 @@
+import { Hookable } from "hookable";
+import { Ignore } from "ignore";
+import * as vite3 from "vite";
+import { Plugin, Plugin as VitePlugin, PluginOption, PluginOption as VitePluginOption, ResolvedConfig, UserConfig, ViteDevServer } from "vite";
+import { KimeshLayerConfig, LayerAutoImportConfig, LayerComponentConfig, LayerComposableConfig, LayerRouteConfig, ResolvedLayer, ResolvedLayer as ResolvedLayer$1, generateLayerAliases, mergeLayerConfigs, prepareLayers, resolveLayers } from "@kimesh/layers";
+import { AutoImportConfig, ImportPreset, LayerAutoImportSource as ImportSource, buildImportRegistry, generateDts, kimeshAutoImport, scanExports } from "@kimesh/auto-import";
+import { ComponentResolver } from "unplugin-vue-components";
+import { App } from "vue";
+
+//#region src/types/components.d.ts
+/**
+ * @kimesh/kit - Component Types
+ */
+interface KimeshComponent {
+  /** Component name as used in templates */
+  name: string;
+  /** Path to the component file */
+  filePath: string;
+  /** Named export to use (default: 'default') */
+  export?: string;
+  /** Component prefix */
+  prefix?: string;
+  /** Register globally */
+  global?: boolean;
+  /** Priority for resolution (higher = preferred) */
+  priority?: number;
+  /** Source layer name */
+  layer?: string;
+}
+interface KimeshComponentsDir {
+  /** Path to the components directory */
+  path: string;
+  /** Component prefix */
+  prefix?: string;
+  /** Register globally */
+  global?: boolean;
+  /** Glob pattern for matching components */
+  pattern?: string | string[];
+  /** Patterns to ignore */
+  ignore?: string[];
+  /** File extensions to include */
+  extensions?: string[];
+  /** Enable deep scanning (subdirectories) */
+  deep?: boolean;
+  /** Source layer name */
+  layer?: string;
+}
+//#endregion
+//#region src/types/imports.d.ts
+/**
+ * @kimesh/kit - Import Types
+ */
+interface KimeshImport {
+  /** Import name */
+  name: string;
+  /** Alias for the import */
+  as?: string;
+  /** Module to import from */
+  from: string;
+  /** Is type-only import */
+  type?: boolean;
+  /** Priority for resolution */
+  priority?: number;
+  /** Source layer name */
+  layer?: string;
+}
+interface KimeshImportsDir {
+  /** Path to the directory */
+  path: string;
+  /** Only scan these patterns */
+  pattern?: string | string[];
+  /** Patterns to ignore */
+  ignore?: string[];
+  /** Import as type-only */
+  type?: boolean;
+  /** Source layer name */
+  layer?: string;
+}
+interface KimeshImportPreset {
+  /** Preset name (e.g., 'vue', 'vue-router') */
+  from: string;
+  /** Imports to include from the preset */
+  imports: string[];
+  /** Import as type-only */
+  type?: boolean;
+}
+//#endregion
+//#region src/types/router.d.ts
+/**
+ * @kimesh/kit - Router Types
+ */
+interface KimeshRoute {
+  /** Route name */
+  name?: string;
+  /** Route path */
+  path: string;
+  /** Component file path */
+  file?: string;
+  /** Child routes */
+  children?: KimeshRoute[];
+  /** Route meta */
+  meta?: Record<string, unknown>;
+  /** Source layer name */
+  layer?: string;
+}
+interface KimeshRouteMiddleware {
+  /** Middleware name */
+  name: string;
+  /** Middleware file path */
+  path: string;
+  /** Global middleware (applied to all routes) */
+  global?: boolean;
+  /** Source layer name */
+  layer?: string;
+}
+//#endregion
+//#region src/types/hooks.d.ts
+type HookResult = void | Promise<void>;
+interface KimeshHooks {
+  /** Called after config is loaded, before layers */
+  "config:loaded": (config: KimeshConfig) => HookResult;
+  /** Called after layers are resolved */
+  "layers:resolved": (layers: ResolvedLayer$1[]) => HookResult;
+  /** Called to extend layer configuration */
+  "layers:extend": (layers: ResolvedLayer$1[]) => HookResult;
+  /** Called when Kimesh is fully initialized and ready */
+  ready: (kimesh: Kimesh) => HookResult;
+  /** Called before modules are processed */
+  "modules:before": (kimesh: Kimesh) => HookResult;
+  /** Called after all modules are processed */
+  "modules:done": (kimesh: Kimesh) => HookResult;
+  /** Called before build starts */
+  "build:before": (kimesh: Kimesh) => HookResult;
+  /** Called after build completes */
+  "build:done": (kimesh: Kimesh) => HookResult;
+  /** Called on build error */
+  "build:error": (error: Error, kimesh: Kimesh) => HookResult;
+  /** Called to extend Vite config before it's resolved */
+  "vite:extend": (ctx: {
+    kimesh: Kimesh;
+    config: vite3.UserConfig;
+  }) => HookResult;
+  /** Called after Vite config is resolved */
+  "vite:configResolved": (config: ResolvedConfig, kimesh: Kimesh) => HookResult;
+  /** Called when Vite dev server is created */
+  "vite:serverCreated": (server: ViteDevServer, kimesh: Kimesh) => HookResult;
+  /** Called to add import sources/presets */
+  "imports:sources": (sources: Array<{
+    from: string;
+    imports: string[];
+  }>, kimesh: Kimesh) => HookResult;
+  /** Called to extend imports */
+  "imports:extend": (imports: KimeshImport[], kimesh: Kimesh) => HookResult;
+  /** Called to add import directories */
+  "imports:dirs": (dirs: KimeshImportsDir[], kimesh: Kimesh) => HookResult;
+  /** Called to add component directories */
+  "components:dirs": (dirs: KimeshComponentsDir[], kimesh: Kimesh) => HookResult;
+  /** Called to extend components */
+  "components:extend": (components: KimeshComponent[], kimesh: Kimesh) => HookResult;
+  /** Called to add component resolvers */
+  "components:resolvers": (resolvers: ComponentResolver[], kimesh: Kimesh) => HookResult;
+  /** Called after routes are generated */
+  "routes:extend": (routes: KimeshRoute[], kimesh: Kimesh) => HookResult;
+  /** Called to add route middleware */
+  "routes:middleware": (middleware: KimeshRouteMiddleware[], kimesh: Kimesh) => HookResult;
+  /** Called when templates need generation */
+  "templates:extend": (templates: KimeshTemplate[], kimesh: Kimesh) => HookResult;
+  /** Called after templates are written */
+  "templates:done": (templates: KimeshTemplate[], kimesh: Kimesh) => HookResult;
+  /** Called to extend type templates */
+  "types:extend": (typeTemplates: KimeshTypeTemplate[], kimesh: Kimesh) => HookResult;
+  /** Called after types are generated */
+  "types:done": (files: string[], kimesh: Kimesh) => HookResult;
+  /** Called on file change in watch mode */
+  "watch:change": (file: string, event: "add" | "change" | "unlink", kimesh: Kimesh) => HookResult;
+  /** Called before HMR update */
+  "hmr:before": (file: string, kimesh: Kimesh) => HookResult;
+  /** Called after HMR update */
+  "hmr:after": (file: string, kimesh: Kimesh) => HookResult;
+  /** Called when Kimesh is closing */
+  close: (kimesh: Kimesh) => HookResult;
+}
+//#endregion
+//#region src/types/runtime-plugin.d.ts
+/**
+ * Metadata for runtime plugin ordering and identification
+ */
+interface KimeshRuntimePluginMeta {
+  name?: string;
+  enforce?: "pre" | "default" | "post";
+  order?: number;
+  dependsOn?: string[];
+  parallel?: boolean;
+}
+/**
+ * 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>;
+  "navigate:before": (context: {
+    to: unknown;
+    from: unknown;
+  }) => void | false | Promise<void | false>;
+  "navigate:after": (context: {
+    to: unknown;
+    from: unknown;
+    failure?: unknown;
+  }) => void | Promise<void>;
+  "navigate:error": (context: {
+    error: Error;
+    to: unknown;
+    from: unknown;
+  }) => void | Promise<void>;
+}
+interface RuntimeConfigPublic {
+  [key: string]: unknown;
+}
+/**
+ * Minimal build-time app context. Full runtime version is in @kimesh/router-runtime.
+ */
+interface KimeshAppContext {
+  vueApp: App;
+  router: unknown;
+  queryClient: unknown;
+  hooks: {
+    callHook: <T extends keyof KimeshRuntimeHooks>(name: T, ...args: Parameters<KimeshRuntimeHooks[T]>) => Promise<void>;
+    addHooks: (hooks: Partial<KimeshRuntimeHooks>) => void;
+  };
+  provide: <T>(name: string, value: T) => void;
+  $config: RuntimeConfigPublic;
+  isHydrating: boolean;
+  runWithContext: <T extends () => unknown>(fn: T) => ReturnType<T>;
+}
+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>;
+}
+/**
+ * Normalized runtime plugin for registry storage
+ */
+interface KimeshRuntimePluginEntry {
+  src?: string;
+  name?: string;
+  meta?: KimeshRuntimePluginMeta;
+  plugin?: KimeshRuntimePlugin;
+  append?: boolean;
+}
+interface AddRuntimePluginOptions {
+  append?: boolean;
+}
+//#endregion
+//#region src/types/kimesh.d.ts
+interface KimeshTemplate<TData = unknown> {
+  /** Output filename (relative to buildDir) */
+  filename: string;
+  /** Generate template contents */
+  getContents?: (data: TData & {
+    kimesh: Kimesh;
+  }) => string | Promise<string>;
+  /** Source file path (alternative to getContents) */
+  src?: string;
+  /** Write to disk (default: true) */
+  write?: boolean;
+  /** Custom data passed to getContents */
+  data?: TData;
+}
+interface KimeshTypeTemplate<TData = unknown> extends KimeshTemplate<TData> {
+  /** Always writes .d.ts files */
+  filename: `${string}.d.ts`;
+}
+interface ResolvedTemplate {
+  /** Output filename */
+  filename: string;
+  /** Absolute path to the written file */
+  dst: string;
+  /** Template contents */
+  contents: string;
+}
+interface KimeshAlias {
+  /** Alias name (e.g., '#my-alias', '@/components') */
+  find: string | RegExp;
+  /** Path to resolve to */
+  replacement: string;
+}
+interface KimeshVitePluginEntry {
+  /** The Vite plugin */
+  plugin: Plugin;
+  /** Plugin enforce order */
+  enforce?: "pre" | "post";
+  /** Numeric order (lower = earlier) */
+  order?: number;
+  /** Metadata for debugging */
+  meta?: {
+    name?: string;
+    module?: string;
+  };
+}
+interface KimeshRegistries {
+  /** Vite plugins to add */
+  vitePlugins: KimeshVitePluginEntry[];
+  /** Aliases */
+  aliases: KimeshAlias[];
+  /** Templates to generate */
+  templates: KimeshTemplate[];
+  /** Type templates to generate (.d.ts) */
+  typeTemplates: KimeshTypeTemplate[];
+  /** Auto-imports */
+  imports: KimeshImport[];
+  /** Auto-import directories */
+  importsDirs: KimeshImportsDir[];
+  /** Import presets */
+  importsPresets: KimeshImportPreset[];
+  /** Components */
+  components: KimeshComponent[];
+  /** Component directories */
+  componentsDirs: KimeshComponentsDir[];
+  /** Component resolvers */
+  componentResolvers: ComponentResolver[];
+  /** Routes */
+  routes: KimeshRoute[];
+  /** Route middleware */
+  routeMiddleware: KimeshRouteMiddleware[];
+  /** Runtime plugins (execute in Vue app at runtime) */
+  runtimePlugins: KimeshRuntimePluginEntry[];
+}
+interface KimeshOptions {
+  /** Whether in development mode */
+  dev: boolean;
+  /** Project root directory */
+  root: string;
+  /** Build output directory (.kimesh) */
+  buildDir: string;
+  /** The Kimesh configuration */
+  config: KimeshConfig;
+  /** Resolved layers */
+  layers: ResolvedLayer$1[];
+  /** Runtime config (exposed to client/server) */
+  runtimeConfig: {
+    public: Record<string, unknown>;
+    private: Record<string, unknown>;
+  };
+}
+interface Kimesh {
+  /** Kimesh options */
+  readonly options: KimeshOptions;
+  /** Hookable instance for lifecycle hooks */
+  readonly hooks: Hookable<KimeshHooks>;
+  /** Registries for plugins, templates, imports, components, etc. */
+  readonly _registries: KimeshRegistries;
+  /** Resolved layers (shorthand for options.layers) */
+  readonly layers: ResolvedLayer$1[];
+  /** Project root directory */
+  readonly root: string;
+  /** Build directory (.kimesh) */
+  readonly buildDir: string;
+  /** Register a hook */
+  hook: <T extends keyof KimeshHooks>(name: T, handler: KimeshHooks[T], options?: {
+    allowDeprecated?: boolean;
+  }) => () => void;
+  /** Call a hook */
+  callHook: <T extends keyof KimeshHooks>(name: T, ...args: Parameters<KimeshHooks[T]>) => Promise<void>;
+  /** Register a hook that runs only once */
+  hookOnce: <T extends keyof KimeshHooks>(name: T, handler: KimeshHooks[T]) => () => void;
+}
+//#endregion
+//#region src/types/module.d.ts
+interface KimeshModuleMeta {
+  /** Module name (npm package name) */
+  name?: string;
+  /** Module version */
+  version?: string;
+  /** Config key in kimesh.config.ts for module options */
+  configKey?: string;
+  /** Compatibility constraints */
+  compatibility?: {
+    /** Minimum Kimesh version required */kimesh?: string; /** Minimum Vite version required */
+    vite?: string;
+  };
+}
+/**
+ * Module defaults can be:
+ * - A static object
+ * - A function that receives Kimesh and returns defaults (sync or async)
+ */
+type KimeshModuleDefaults<TOptions> = TOptions | ((kimesh: Kimesh) => TOptions | Promise<TOptions>);
+interface KimeshModuleDefinition<TOptions = Record<string, unknown>> {
+  /** Module metadata */
+  meta?: KimeshModuleMeta;
+  /** Default options (can be function for dynamic defaults) */
+  defaults?: KimeshModuleDefaults<Partial<TOptions>>;
+  /** Shorthand hook registration */
+  hooks?: Partial<KimeshHooks>;
+  /**
+       * Setup function called after layers are resolved
+       * @param options - Merged options (defaults + user config)
+       * @param kimesh - Kimesh context
+       */
+  setup?: (options: TOptions, kimesh: Kimesh) => void | Promise<void>;
+}
+/**
+ * A resolved Kimesh module
+ */
+interface KimeshModule<TOptions = Record<string, unknown>> {
+  /** Module definition */
+  _def: KimeshModuleDefinition<TOptions>;
+  /** Module meta (resolved) */
+  meta: Required<KimeshModuleMeta>;
+  /** Get default options */
+  getDefaults: (kimesh: Kimesh) => Promise<Partial<TOptions>>;
+  /** Setup function */
+  setup: (options: TOptions, kimesh: Kimesh) => void | Promise<void>;
+}
+/**
+ * Module input in config - can be:
+ * - A string package name (resolved from node_modules)
+ * - A module object
+ * - A tuple of [module, options]
+ * - A tuple of [string, options]
+ */
+type KimeshModuleInput<TOptions = any> = string | KimeshModule<TOptions> | [KimeshModule<TOptions>, Partial<TOptions>] | [string, Partial<TOptions>];
+interface KimeshPluginDefinition {
+  /** Plugin name */
+  name: string;
+  /**
+       * Setup function that returns Vite plugin(s)
+       * @param kimesh - Kimesh context
+       */
+  setup: (kimesh: Kimesh) => vite3.PluginOption | vite3.PluginOption[];
+}
+interface KimeshPlugin {
+  /** Plugin definition */
+  _def: KimeshPluginDefinition;
+  /** Plugin name */
+  name: string;
+  /** Get Vite plugins */
+  getPlugins: (kimesh: Kimesh) => vite3.PluginOption[];
+}
+//#endregion
+//#region src/types/config.d.ts
+/**
+ * Runtime configuration that can be overridden by environment variables.
+ *
+ * Values are resolved at build-time via Vite's `define` mechanism.
+ * Use `KIMESH_*` environment variables to override values.
+ *
+ * @example
+ * ```ts
+ * // In kimesh.config.ts
+ * runtimeConfig: {
+ *   apiBase: '/api', // KIMESH_API_BASE
+ *   debug: false, // KIMESH_DEBUG=true
+ *   features: {
+ *     darkMode: true, // KIMESH_FEATURES_DARK_MODE
+ *   }
+ * }
+ * ```
+ */
+interface RuntimeConfig {
+  [key: string]: string | number | boolean | null | undefined | RuntimeConfig;
+}
+/**
+ * Layer configuration in kimesh.config.ts
+ */
+interface LayersConfig {
+  /** Directories to scan for layers (default: ['layers']) */
+  dirs?: string[];
+  /** Layers to enable - 'all' | 'none' | string[] */
+  enabled?: "all" | "none" | string[];
+  /** Layers to exclude */
+  excluded?: string[];
+}
+/**
+ * Auto-import configuration in kimesh.config.ts
+ */
+interface AutoImportOptions {
+  /** Enable auto-imports (default: true) */
+  enabled?: boolean;
+  /** Directories to scan for composables */
+  dirs?: string[];
+  /** External import presets (vue, vue-router, etc.) */
+  presets?: string[];
+  /** Custom import sources */
+  imports?: Array<{
+    from: string;
+    imports: string[];
+    type?: boolean;
+  }>;
+  /** Generate .d.ts files (default: true) */
+  dts?: boolean;
+}
+/**
+ * Component auto-import configuration
+ */
+interface ComponentsConfig {
+  /** Enable component auto-imports (default: true) */
+  enabled?: boolean;
+  /** Directories to scan */
+  dirs?: string[];
+  /** Component prefix */
+  prefix?: string;
+  /** Global component registration */
+  global?: boolean;
+}
+/**
+ * Vite configuration options for Kimesh.
+ */
+interface KimeshViteConfig extends Omit<UserConfig, "root" | "configFile"> {
+  /**
+       * Additional Vite plugins.
+       * These are merged AFTER Kimesh's internal plugins.
+       */
+  plugins?: PluginOption[];
+}
+/**
+ * Default aliases provided by Kimesh.
+ * Templates use placeholders: <srcDir>, <rootDir>
+ * These are replaced at build time with actual paths.
+ */
+declare const DEFAULT_ALIASES: Record<string, string>;
+/**
+ * Debug mode configuration for detailed logging and diagnostics.
+ */
+interface DebugConfig {
+  /**
+       * Log hook execution with timing information
+       * @default false
+       */
+  hooks?: boolean;
+  /**
+       * Log module loading and setup
+       * @default false
+       */
+  modules?: boolean;
+  /**
+       * Log layer resolution
+       * @default false
+       */
+  layers?: boolean;
+  /**
+       * Log configuration loading and merging
+       * @default false
+       */
+  config?: boolean;
+  /**
+       * Log Vite plugin operations
+       * @default false
+       */
+  vite?: boolean;
+  /**
+       * Log route generation
+       * @default false
+       */
+  routes?: boolean;
+  /**
+       * Log auto-import resolution
+       * @default false
+       */
+  imports?: boolean;
+}
+/**
+ * Default file/folder ignore patterns
+ */
+declare const DEFAULT_IGNORE_PATTERNS: string[];
+/**
+ * Options for file ignore patterns (passed to node-ignore)
+ */
+interface IgnoreOptions {
+  /**
+       * Whether matching is case-insensitive
+       * @default false
+       */
+  ignorecase?: boolean;
+}
+/**
+ * Per-route configuration rules.
+ * Keys are route patterns (supports wildcards).
+ *
+ * @example
+ * ```ts
+ * routeRules: {
+ *   '/admin/**': {
+ *     redirect: '/login',
+ *   },
+ *   '/api/**': {
+ *     headers: { 'Cache-Control': 'no-store' },
+ *   },
+ *   '/static/**': {
+ *     prerender: true,
+ *   },
+ * }
+ * ```
+ */
+interface RouteRule {
+  /**
+       * Redirect to another path
+       * Can be a string path or an object with statusCode
+       */
+  redirect?: string | {
+    to: string;
+    statusCode?: 301 | 302 | 307 | 308;
+  };
+  /**
+       * Pre-render this route at build time (for static generation)
+       * @default false
+       */
+  prerender?: boolean;
+  /**
+       * Cache configuration for this route
+       */
+  cache?: boolean | {
+    /**
+             * Cache max age in seconds
+             */
+    maxAge?: number;
+    /**
+             * Stale-while-revalidate in seconds
+             */
+    swr?: number;
+    /**
+             * Cache key modifiers
+             */
+    varies?: string[];
+  };
+  /**
+       * Custom headers to set for this route
+       */
+  headers?: Record<string, string>;
+  /**
+       * CORS configuration for this route
+       */
+  cors?: boolean | {
+    origin?: string | string[];
+    methods?: string[];
+    headers?: string[];
+    credentials?: boolean;
+  };
+  /**
+       * Custom meta data for the route
+       */
+  meta?: Record<string, unknown>;
+}
+/**
+ * Directory configuration for Kimesh.
+ * Customizes the default directory structure.
+ */
+interface DirectoryConfig {
+  /**
+       * Directory for static assets
+       * @default 'assets'
+       */
+  assets?: string;
+  /**
+       * Directory for runtime plugins
+       * @default 'plugins'
+       */
+  plugins?: string;
+  /**
+       * Directory for public static files
+       * @default 'public'
+       */
+  public?: string;
+  /**
+       * Directory for shared code across the app
+       * @default 'shared'
+       */
+  shared?: string;
+}
+/**
+ * Bundle analyzer configuration options.
+ */
+interface AnalyzeConfig {
+  /**
+       * Enable the bundle analyzer
+       * @default false
+       */
+  enabled?: boolean;
+  /**
+       * Automatically open analyzer report in browser
+       * @default false
+       */
+  openAnalyzer?: boolean;
+  /**
+       * Custom filename for the report
+       * @default 'report.html'
+       */
+  reportFilename?: string;
+}
+/**
+ * Build configuration for Kimesh.
+ * Controls production build behavior.
+ */
+interface BuildConfig {
+  /**
+       * Enable bundle analysis. Shows a visualization of bundle contents.
+       *
+       * @example
+       * ```ts
+       * build: {
+       *   analyze: true,
+       *   // or with options:
+       *   analyze: {
+       *     enabled: true,
+       *     openAnalyzer: false,
+       *     reportFilename: 'stats.html',
+       *   },
+       * }
+       * ```
+       */
+  analyze?: boolean | AnalyzeConfig;
+  /**
+       * Generate source maps for production builds.
+       * - `true`: Generate separate source map files
+       * - `'hidden'`: Generate source maps but don't reference them in bundles
+       * - `'inline'`: Inline source maps into bundles
+       * - `false`: No source maps
+       *
+       * @default false
+       */
+  sourcemap?: boolean | "hidden" | "inline";
+  /**
+       * Build target for esbuild/terser.
+       * Specifies the JS language version to target.
+       *
+       * @default 'esnext'
+       */
+  target?: string;
+  /**
+       * Minification strategy for production builds.
+       * - `true`: Use default minifier (esbuild)
+       * - `'esbuild'`: Fast minification with esbuild
+       * - `'terser'`: More aggressive minification with terser
+       * - `false`: No minification
+       *
+       * @default 'esbuild'
+       */
+  minify?: boolean | "esbuild" | "terser";
+}
+/**
+ * HTTPS configuration options for dev server.
+ */
+interface HttpsConfig {
+  /**
+       * Path to SSL key file
+       */
+  key?: string;
+  /**
+       * Path to SSL certificate file
+       */
+  cert?: string;
+}
+/**
+ * Proxy target configuration.
+ */
+interface ProxyOptions {
+  /**
+       * Target URL to proxy to
+       */
+  target: string;
+  /**
+       * Change the origin header to match target
+       * @default true
+       */
+  changeOrigin?: boolean;
+  /**
+       * Rewrite the URL path
+       */
+  rewrite?: (path: string) => string;
+  /**
+       * Whether to proxy WebSocket connections
+       * @default false
+       */
+  ws?: boolean;
+  /**
+       * SSL verification options
+       */
+  secure?: boolean;
+  /**
+       * Custom headers to send with the proxy request
+       */
+  headers?: Record<string, string>;
+}
+/**
+ * CORS configuration options for dev server.
+ */
+interface CorsOptions {
+  /**
+       * Allowed origins
+       * @default '*'
+       */
+  origin?: string | string[] | boolean;
+  /**
+       * Allowed HTTP methods
+       * @default ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE']
+       */
+  methods?: string[];
+  /**
+       * Allowed headers
+       */
+  allowedHeaders?: string[];
+  /**
+       * Headers exposed to the client
+       */
+  exposedHeaders?: string[];
+  /**
+       * Allow credentials (cookies, authorization headers)
+       * @default false
+       */
+  credentials?: boolean;
+  /**
+       * Max age for preflight request caching (seconds)
+       * @default 86400
+       */
+  maxAge?: number;
+}
+/**
+ * Enhanced development server configuration.
+ */
+interface DevServerConfig {
+  /**
+       * Port to listen on
+       * @default 3000
+       */
+  port?: number;
+  /**
+       * Host to bind to.
+       * - `'localhost'`: Only accessible from this machine
+       * - `true` or `'0.0.0.0'`: Accessible from network
+       *
+       * @default 'localhost'
+       */
+  host?: string | boolean;
+  /**
+       * Automatically open browser when server starts
+       * @default false
+       */
+  open?: boolean;
+  /**
+       * Enable HTTPS for dev server.
+       * Set to `true` to use auto-generated certificates,
+       * or provide custom key/cert paths.
+       *
+       * @example
+       * ```ts
+       * dev: {
+       *   https: true, // Auto-generate certificates
+       *   // or with custom certs:
+       *   https: {
+       *     key: './certs/localhost.key',
+       *     cert: './certs/localhost.crt',
+       *   },
+       * }
+       * ```
+       */
+  https?: boolean | HttpsConfig;
+  /**
+       * Configure proxy rules for dev server.
+       * Useful for API proxying during development.
+       *
+       * @example
+       * ```ts
+       * dev: {
+       *   proxy: {
+       *     '/api': 'http://localhost:8080',
+       *     '/socket': {
+       *       target: 'ws://localhost:8081',
+       *       ws: true,
+       *     },
+       *   },
+       * }
+       * ```
+       */
+  proxy?: Record<string, string | ProxyOptions>;
+  /**
+       * Configure CORS for dev server.
+       * Set to `true` to enable default CORS settings.
+       *
+       * @default false
+       */
+  cors?: boolean | CorsOptions;
+  /**
+       * Exit if the specified port is already in use
+       * @default false
+       */
+  strictPort?: boolean;
+}
+/**
+ * TypeScript configuration options for Kimesh.
+ */
+interface TypeScriptConfig {
+  /**
+       * Enable strict TypeScript mode.
+       * When true, adds strict compiler options to generated tsconfig.
+       *
+       * @default true
+       */
+  strict?: boolean;
+  /**
+       * Enable type checking during development and/or build.
+       * - `true`: Enable type checking during both dev and build
+       * - `'build'`: Only type check during build
+       * - `false`: Disable type checking
+       *
+       * @default false
+       */
+  typeCheck?: boolean | "build";
+  /**
+       * Additional tsconfig compiler options to merge with generated config.
+       * These options will extend the auto-generated `.kimesh/tsconfig.json`.
+       *
+       * @example
+       * ```ts
+       * typescript: {
+       *   tsConfig: {
+       *     compilerOptions: {
+       *       experimentalDecorators: true,
+       *       emitDecoratorMetadata: true,
+       *     },
+       *   },
+       * }
+       * ```
+       */
+  tsConfig?: {
+    compilerOptions?: Record<string, unknown>;
+    include?: string[];
+    exclude?: string[];
+    references?: Array<{
+      path: string;
+    }>;
+  };
+}
+/**
+ * Chokidar watch options (simplified subset).
+ * @see https://github.com/paulmillr/chokidar#api
+ */
+interface ChokidarOptions {
+  /**
+       * Indicates whether the process should continue as long as files are being watched
+       * @default true
+       */
+  persistent?: boolean;
+  /**
+       * Patterns to ignore
+       */
+  ignored?: string | RegExp | string[] | ((path: string) => boolean);
+  /**
+       * Use polling instead of native events
+       * @default false
+       */
+  usePolling?: boolean;
+  /**
+       * Polling interval in milliseconds (if usePolling is true)
+       * @default 100
+       */
+  interval?: number;
+  /**
+       * Polling interval for binary files (if usePolling is true)
+       * @default 300
+       */
+  binaryInterval?: number;
+  /**
+       * Delay in milliseconds for stabilized 'add' events
+       * @default 2000
+       */
+  awaitWriteFinish?: boolean | {
+    stabilityThreshold?: number;
+    pollInterval?: number;
+  };
+  /**
+       * Use file descriptor watching instead of stat polling
+       * @default false
+       */
+  atomic?: boolean | number;
+  /**
+       * Watch depth limit (how many levels to traverse)
+       * @default undefined (no limit)
+       */
+  depth?: number;
+}
+/**
+ * Watchers configuration for advanced file watching control.
+ */
+interface WatchersConfig {
+  /**
+       * Chokidar options for file watching
+       */
+  chokidar?: ChokidarOptions;
+  /**
+       * Webpack watch options (for future use if needed)
+       */
+  webpack?: {
+    aggregateTimeout?: number;
+    poll?: boolean | number;
+    ignored?: string | RegExp | string[];
+  };
+}
+/**
+ * Module options interface - augmented by modules via declaration merging.
+ *
+ * Modules augment this interface to add their config keys.
+ * The keys become available in defineKmConfig once the module is installed.
+ *
+ * @example
+ * ```ts
+ * // In @kimesh/tailwindcss/types.ts:
+ * declare module '@kimesh/kit' {
+ *   interface KimeshModuleOptions {
+ *     tailwindcss?: KimeshTailwindConfig
+ *   }
+ * }
+ * ```
+ */
+interface KimeshModuleOptions {
+  [key: string]: unknown;
+}
+/**
+ * App-level configuration
+ */
+interface AppConfig {
+  /**
+       * Global head configuration for the app
+       * Automatically enables @kimesh/head plugin when configured
+       */
+  head?: {
+    /** Page title */title?: string; /** Title template (e.g., '%s | My App') */
+    titleTemplate?: string | ((title: string) => string); /** Meta tags */
+    meta?: Array<Record<string, string | undefined>>; /** Link tags */
+    link?: Array<Record<string, string | undefined>>; /** Script tags */
+    script?: Array<Record<string, string | boolean | undefined>>; /** Style tags */
+    style?: Array<Record<string, string | undefined>>; /** HTML attributes */
+    htmlAttrs?: Record<string, string | undefined>; /** Body attributes */
+    bodyAttrs?: Record<string, string | undefined>;
+  };
+}
+/**
+ * Kimesh configuration (kimesh.config.ts)
+ *
+ * Module options are typed via the KimeshModuleOptions interface.
+ * Modules can augment this interface to add typesafe config keys.
+ */
+interface KimeshConfig extends KimeshModuleOptions {
+  /** Application/layer name */
+  name?: string;
+  /** Base path for routes (for layers) */
+  basePath?: string;
+  /**
+       * Define additional aliases to access custom directories within your JavaScript and CSS.
+       *
+       * Aliases are automatically added to the generated TypeScript configurations
+       * for full type support and path auto-complete.
+       *
+       * @default { "~": "/<srcDir>", "@": "/<srcDir>", "~~": "/<rootDir>", "@@": "/<rootDir>", "#build": "/<rootDir>/.kimesh" }
+       *
+       * @example
+       * ```ts
+       * import { fileURLToPath } from 'node:url'
+       *
+       * export default defineKmConfig({
+       *   alias: {
+       *     'images': fileURLToPath(new URL('./assets/images', import.meta.url)),
+       *     'style': fileURLToPath(new URL('./assets/style', import.meta.url)),
+       *   },
+       * })
+       * ```
+       */
+  alias?: Record<string, string>;
+  /**
+       * Set to `true` to enable debug mode.
+       *
+       * Prints out hook names and timings, logs hook arguments,
+       * and provides detailed information about module loading and layer resolution.
+       *
+       * @default false
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   debug: true,
+       *   // or with specific options:
+       *   debug: {
+       *     hooks: true,
+       *     modules: true,
+       *     layers: true,
+       *   },
+       * })
+       * ```
+       */
+  debug?: boolean | DebugConfig;
+  /**
+       * Hooks are listeners to Kimesh events that are typically used in modules,
+       * but are also available in `kimesh.config.ts`.
+       *
+       * Internally, hooks follow a naming pattern using colons (e.g., build:done).
+       * For ease of configuration, you can structure them as an hierarchical object.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   hooks: {
+       *     'ready': (kimesh) => {
+       *       console.log('Kimesh is ready!')
+       *     },
+       *     'build:done': (kimesh) => {
+       *       console.log('Build completed!')
+       *     },
+       *   },
+       * })
+       * ```
+       */
+  hooks?: Partial<KimeshHooks>;
+  /**
+       * Files matching glob patterns specified inside the `ignore` array
+       * will be ignored in building.
+       *
+       * More customizable than `ignorePrefix`: allows complex patterns.
+       *
+       * @default ["**\/*.stories.{js,cts,mts,ts,jsx,tsx}", "**\/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}", "**\/*.d.{cts,mts,ts}", ".kimesh"]
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   ignore: [
+       *     '**\/__tests__/**',
+       *     '**\/*.mock.ts',
+       *     'legacy/**',
+       *   ],
+       * })
+       * ```
+       */
+  ignore?: string[];
+  /**
+       * Any file in routes, layouts, middleware directories will be ignored
+       * during the build process if its filename starts with the prefix specified.
+       *
+       * @default "-"
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   ignorePrefix: '_', // Ignore files starting with underscore
+       * })
+       * ```
+       */
+  ignorePrefix?: string;
+  /**
+       * Pass options directly to `node-ignore` (which is used by Kimesh to ignore files).
+       *
+       * @see https://github.com/kaelzhang/node-ignore
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   ignoreOptions: {
+       *     ignorecase: false, // Case-sensitive matching
+       *   },
+       * })
+       * ```
+       */
+  ignoreOptions?: IgnoreOptions;
+  /**
+       * Global route rules applied to matching routes.
+       *
+       * Keys are route patterns (supports wildcards with **).
+       * Useful for redirects, caching, and per-route configuration.
+       *
+       * @experimental This feature's API may change in the future.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   routeRules: {
+       *     '/admin/**': {
+       *       redirect: '/login',
+       *     },
+       *     '/api/**': {
+       *       headers: { 'Cache-Control': 'no-store' },
+       *       cors: true,
+       *     },
+       *     '/blog/**': {
+       *       prerender: true,
+       *     },
+       *   },
+       * })
+       * ```
+       */
+  routeRules?: Record<string, RouteRule>;
+  /**
+       * Source directory for your application code.
+       * All relative paths are resolved from this directory.
+       *
+       * @default 'src'
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   srcDir: 'app', // Use 'app' instead of 'src'
+       * })
+       * ```
+       */
+  srcDir?: string;
+  /**
+       * Build output directory for Kimesh's generated files.
+       * Contains TypeScript configs, generated routes, and other build artifacts.
+       *
+       * @default '.kimesh'
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   buildDir: '.output', // Use '.output' instead of '.kimesh'
+       * })
+       * ```
+       */
+  buildDir?: string;
+  /**
+       * Directory configuration for customizing the project structure.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   dir: {
+       *     assets: 'static/assets',
+       *     plugins: 'app/plugins',
+       *     public: 'public',
+       *     shared: 'lib/shared',
+       *   },
+       * })
+       * ```
+       */
+  dir?: DirectoryConfig;
+  /**
+       * Build configuration for production builds.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   build: {
+       *     analyze: true,
+       *     sourcemap: 'hidden',
+       *     target: 'es2022',
+       *     minify: 'esbuild',
+       *   },
+       * })
+       * ```
+       */
+  build?: BuildConfig;
+  /**
+       * Enhanced development server configuration.
+       * Supports HTTPS, proxy, CORS, and more.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   dev: {
+       *     port: 3000,
+       *     host: 'localhost',
+       *     open: true,
+       *     https: true,
+       *     proxy: {
+       *       '/api': 'http://localhost:8080',
+       *     },
+       *     cors: true,
+       *     strictPort: false,
+       *   },
+       * })
+       * ```
+       */
+  dev?: DevServerConfig;
+  /**
+       * TypeScript configuration options.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   typescript: {
+       *     strict: true,
+       *     typeCheck: 'build',
+       *     tsConfig: {
+       *       compilerOptions: {
+       *         experimentalDecorators: true,
+       *       },
+       *     },
+       *   },
+       * })
+       * ```
+       */
+  typescript?: TypeScriptConfig;
+  /**
+       * Additional file patterns to watch during development.
+       * Uses glob patterns relative to the project root.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   watch: [
+       *     './custom-dir/**\/*',
+       *     './config/**\/*.json',
+       *   ],
+       * })
+       * ```
+       */
+  watch?: string[];
+  /**
+       * Advanced watcher configuration.
+       * Customize chokidar options for file watching.
+       *
+       * @example
+       * ```ts
+       * export default defineKmConfig({
+       *   watchers: {
+       *     chokidar: {
+       *       usePolling: true,
+       *       interval: 1000,
+       *       ignored: ['**\/.git/**'],
+       *     },
+       *   },
+       * })
+       * ```
+       */
+  watchers?: WatchersConfig;
+  /** Router configuration */
+  router?: {
+    /** Routes directory relative to srcDir (default: 'routes') */routesDir?: string; /** Import mode for route components */
+    importMode?: "async" | "sync";
+  };
+  /** Extend from other layers (paths or package names) */
+  extends?: Array<string | {
+    name: string;
+    path?: string;
+  }>;
+  /** Layers configuration */
+  layers?: LayersConfig;
+  /**
+       * Kimesh modules to load
+       */
+  modules?: KimeshModuleInput[];
+  /**
+       * App-level configuration
+       * Includes head management and other app-wide settings
+       */
+  app?: AppConfig;
+  /** Routes configuration (for layers) */
+  routes?: {
+    /** Base path for all routes */basePath?: string; /** Routes folder name */
+    folder?: string;
+  };
+  /** Auto-import configuration */
+  autoImport?: AutoImportOptions;
+  /** Component auto-import configuration */
+  components?: ComponentsConfig;
+  /** Composables configuration (for layers) */
+  composables?: {
+    /** Directories to scan */dirs?: string[];
+  };
+  /** CSS files to include */
+  css?: string[];
+  /**
+       * Vite configuration options.
+       */
+  vite?: KimeshViteConfig;
+  /**
+       * Runtime configuration with environment variable override support.
+       *
+       * In Phase 1, all config is client-side (build-time injection).
+       * Use KIMESH_* environment variables to override values.
+       *
+       * @example
+       * ```ts
+       * runtimeConfig: {
+       *   apiBase: '/api', // KIMESH_API_BASE
+       *   debug: false, // KIMESH_DEBUG=true
+       *   features: {
+       *     darkMode: true, // KIMESH_FEATURES_DARK_MODE
+       *   }
+       * }
+       * ```
+       */
+  runtimeConfig?: RuntimeConfig;
+}
+/**
+ * Define Kimesh configuration with type inference.
+ */
+declare function defineKmConfig(config: KimeshConfig): KimeshConfig;
+//#endregion
+//#region src/types/resolver.d.ts
+/**
+ * @kimesh/kit - Resolver Types
+ */
+interface KimeshResolver {
+  /** Resolve paths relative to the resolver's base */
+  resolve: (...paths: string[]) => string;
+  /** Resolve a path and check if it exists */
+  resolvePath: (path: string) => Promise<string>;
+  /** Resolve an alias to its actual path */
+  resolveAlias: (alias: string) => string | undefined;
+}
+//#endregion
+//#region src/core/kimesh.d.ts
+/**
+ * Create a new Kimesh context
+ */
+declare function createKimesh(options: {
+  config: KimeshConfig;
+  layers: ResolvedLayer$1[];
+  root: string;
+  buildDir: string;
+  dev?: boolean;
+}): Kimesh;
+/**
+ * Get the current Kimesh context
+ * @throws Error if not in a Kimesh context
+ */
+declare function useKimesh(): Kimesh;
+/**
+ * Try to get the current Kimesh context
+ * @returns Kimesh instance or undefined if not in context
+ */
+declare function tryUseKimesh(): Kimesh | undefined;
+//#endregion
+//#region src/core/module.d.ts
+/**
+ * Define a Kimesh module with full type inference
+ *
+ * @example
+ * ```ts
+ * export default defineKimeshModule<{ apiKey: string }>({
+ *   meta: {
+ *     name: "@kimesh/analytics",
+ *     configKey: "analytics",
+ *   },
+ *   defaults: {
+ *     apiKey: "",
+ *   },
+ *   hooks: {
+ *     "ready": (kimesh) => {
+ *       console.log("Kimesh is ready!");
+ *     },
+ *   },
+ *   async setup(options, kimesh) {
+ *     // Module setup logic
+ *   },
+ * });
+ * ```
+ */
+declare function defineKimeshModule<TOptions = Record<string, unknown>>(definition: KimeshModuleDefinition<TOptions>): KimeshModule<TOptions>;
+/**
+ * Normalize module input (string, module, or [module, options] tuple)
+ */
+declare function normalizeModuleInput<TOptions>(input: KimeshModuleInput<TOptions>, kimesh: Kimesh): Promise<{
+  module: KimeshModule<TOptions>;
+  options: Partial<TOptions>;
+}>;
+/**
+ * Execute a single module
+ */
+declare function executeModule<TOptions>(moduleInput: KimeshModuleInput<TOptions>, kimesh: Kimesh): Promise<void>;
+/**
+ * Execute all modules in order
+ */
+declare function executeModules(modules: KimeshModuleInput[], kimesh: Kimesh): Promise<void>;
+//#endregion
+//#region src/core/plugin.d.ts
+/**
+ * Define a Kimesh plugin (lightweight Vite plugin wrapper)
+ *
+ * @example
+ * ```ts
+ * export default defineKimeshPlugin({
+ *   name: "@kimesh/icons",
+ *   setup(kimesh) {
+ *     return Icons({
+ *       compiler: "vue3",
+ *       autoInstall: true,
+ *     });
+ *   },
+ * });
+ * ```
+ */
+declare function defineKimeshPlugin(definition: KimeshPluginDefinition): KimeshPlugin;
+//#endregion
+//#region src/kit/vite.d.ts
+interface AddVitePluginOptions {
+  /** Plugin enforce order */
+  enforce?: "pre" | "post";
+  /** Numeric order (lower = earlier) */
+  order?: number;
+  /** Add to beginning of plugins array */
+  prepend?: boolean;
+}
+/**
+ * Add a Vite plugin to the build
+ *
+ * @example
+ * ```ts
+ * addVitePlugin(myPlugin());
+ * addVitePlugin(myPlugin(), { enforce: "pre" });
+ * ```
+ */
+declare function addVitePlugin(plugin: Plugin | Plugin[] | PluginOption, options?: AddVitePluginOptions): void;
+/**
+ * Add a build plugin (alias for addVitePlugin with default order)
+ */
+declare function addBuildPlugin(plugin: Plugin | Plugin[], options?: AddVitePluginOptions): void;
+//#endregion
+//#region src/kit/alias.d.ts
+/**
+ * Add an alias
+ *
+ * @example
+ * ```ts
+ * addAlias("#my-module", "/path/to/module");
+ * addAlias("@/components", "./src/components");
+ * ```
+ */
+declare function addAlias(find: string | RegExp, replacement: string): void;
+/**
+ * Resolve an alias to its actual path
+ */
+declare function resolveAlias(alias: string): string | undefined;
+//#endregion
+//#region src/kit/templates.d.ts
+/**
+ * Add a template to be generated
+ *
+ * @example
+ * ```ts
+ * addTemplate({
+ *   filename: "my-config.ts",
+ *   getContents: ({ kimesh }) => `export default ${JSON.stringify(config)}`,
+ * });
+ * ```
+ */
+declare function addTemplate<TData = unknown>(template: KimeshTemplate<TData>): void;
+/**
+ * Add a type template (.d.ts) to be generated
+ *
+ * @example
+ * ```ts
+ * addTypeTemplate({
+ *   filename: "components.d.ts",
+ *   getContents: ({ kimesh }) => generateComponentTypes(kimesh),
+ * });
+ * ```
+ */
+declare function addTypeTemplate<TData = unknown>(template: KimeshTypeTemplate<TData>): void;
+/**
+ * Generate and write all templates
+ */
+declare function writeTemplates(kimesh: Kimesh): Promise<ResolvedTemplate[]>;
+/**
+ * Update specific templates (for HMR)
+ */
+declare function updateTemplates(kimesh: Kimesh, options?: {
+  filter?: (t: KimeshTemplate) => boolean;
+}): Promise<ResolvedTemplate[]>;
+//#endregion
+//#region src/kit/components.d.ts
+/**
+ * Add a single component
+ *
+ * @example
+ * ```ts
+ * addComponent({
+ *   name: "MyButton",
+ *   filePath: "./components/MyButton.vue",
+ * });
+ * ```
+ */
+declare function addComponent(component: KimeshComponent): void;
+/**
+ * Add a components directory
+ *
+ * @example
+ * ```ts
+ * addComponentsDir({
+ *   path: "./components/ui",
+ *   prefix: "Ui",
+ * });
+ * ```
+ */
+declare function addComponentsDir(dir: KimeshComponentsDir, options?: {
+  prepend?: boolean;
+}): void;
+/**
+ * Add a component resolver
+ *
+ * @example
+ * ```ts
+ * addComponentResolver({
+ *   type: "component",
+ *   resolve: (name) => {
+ *     if (name.startsWith("Ui")) {
+ *       return { name, from: `./components/ui/${name}.vue` };
+ *     }
+ *   },
+ * });
+ * ```
+ */
+declare function addComponentResolver(resolver: ComponentResolver): void;
+//#endregion
+//#region src/kit/imports.d.ts
+/**
+ * Add imports (auto-imports)
+ *
+ * @example
+ * ```ts
+ * addImports({ name: "useAuth", from: "./composables/auth" });
+ * addImports([
+ *   { name: "ref", from: "vue" },
+ *   { name: "computed", from: "vue" },
+ * ]);
+ * ```
+ */
+declare function addImports(imports: KimeshImport | KimeshImport[]): void;
+/**
+ * Add an imports directory
+ *
+ * @example
+ * ```ts
+ * addImportsDir("./composables");
+ * addImportsDir({ path: "./utils", pattern: "use*.ts" });
+ * ```
+ */
+declare function addImportsDir(dir: string | KimeshImportsDir, options?: {
+  prepend?: boolean;
+}): void;
+/**
+ * Add import presets
+ *
+ * @example
+ * ```ts
+ * addImportsPreset({ from: "vue", imports: ["ref", "computed", "watch"] });
+ * ```
+ */
+declare function addImportsPreset(preset: KimeshImportPreset): void;
+//#endregion
+//#region src/kit/resolver.d.ts
+/**
+ * Create a resolver for the current module
+ *
+ * @example
+ * ```ts
+ * const resolver = createResolver(import.meta.url);
+ * const runtimePath = resolver.resolve("./runtime");
+ * ```
+ */
+declare function createResolver(base: string): KimeshResolver;
+/**
+ * Resolve a path relative to project root
+ */
+declare function resolvePathFromRoot(...paths: string[]): string;
+/**
+ * Resolve a path relative to build directory
+ */
+declare function resolvePathFromBuild(...paths: string[]): string;
+//#endregion
+//#region src/kit/runtime-plugin.d.ts
+/**
+ * Add a runtime plugin to the Kimesh app
+ *
+ * @example
+ * ```ts
+ * addRuntimePlugin('~/plugins/analytics.ts')
+ * addRuntimePlugin({ src: '~/plugins/analytics.ts', meta: { enforce: 'post' } })
+ * ```
+ */
+declare function addRuntimePlugin(plugin: string | KimeshRuntimePluginEntry, options?: AddRuntimePluginOptions): void;
+/**
+ * Remove a runtime plugin by source path
+ */
+declare function removeRuntimePlugin(src: string): void;
+/**
+ * Check if a runtime plugin is registered
+ */
+declare function hasRuntimePlugin(src: string): boolean;
+/**
+ * Get all registered runtime plugins
+ */
+declare function getRuntimePlugins(): KimeshRuntimePluginEntry[];
+//#endregion
+//#region src/kit/plugin-scanner.d.ts
+/**
+ * @kimesh/kit - Plugin Scanner
+ *
+ * Scans the plugins directory for auto-discovered runtime plugins.
+ */
+/**
+ * Discovered plugin entry from filesystem scanning
+ */
+interface DiscoveredPlugin {
+  /** Plugin file path (absolute) */
+  src: string;
+  /** Plugin name derived from filename */
+  name: string;
+  /** Order derived from filename prefix (e.g., 01.auth.ts -> 1) */
+  order?: number;
+}
+/**
+ * Options for scanning plugins directory
+ */
+interface ScanPluginsOptions {
+  /** File extensions to scan (default: ['.ts', '.js', '.mjs']) */
+  extensions?: string[];
+  /** Pattern to ignore */
+  ignore?: string[];
+}
+/**
+ * Scan plugins directory for auto-discovered plugins
+ *
+ * @example
+ * ```ts
+ * const plugins = await scanPluginsDir('/app/src/plugins')
+ * // Returns: [
+ * //   { src: '/app/src/plugins/01.auth.ts', name: 'auth', order: 1 },
+ * //   { src: '/app/src/plugins/02.analytics.ts', name: 'analytics', order: 2 },
+ * //   { src: '/app/src/plugins/utils.ts', name: 'utils', order: undefined },
+ * // ]
+ * ```
+ */
+declare function scanPluginsDir(pluginsDir: string, options?: ScanPluginsOptions): Promise<DiscoveredPlugin[]>;
+/**
+ * Check if a directory has any plugin files
+ */
+declare function hasPlugins(pluginsDir: string, options?: ScanPluginsOptions): Promise<boolean>;
+//#endregion
+//#region src/kit/plugin-template.d.ts
+/**
+ * Options for generating plugins template
+ */
+interface GeneratePluginsTemplateOptions {
+  /** Auto-discovered plugins from filesystem */
+  discoveredPlugins: DiscoveredPlugin[];
+  /** Module-registered plugins */
+  registeredPlugins: KimeshRuntimePluginEntry[];
+  /** Build directory for relative path calculation */
+  buildDir: string;
+}
+/**
+ * Generate the plugins.mjs template content
+ *
+ * @example Output:
+ * ```js
+ * // Auto-discovered plugins
+ * import plugin_auth_0 from '../src/plugins/01.auth.ts'
+ * import plugin_analytics_1 from '../src/plugins/02.analytics.ts'
+ *
+ * // Module-registered plugins
+ * import plugin_icons_2 from '@kimesh/icons/runtime/plugin'
+ *
+ * export const plugins = [
+ *   plugin_auth_0,
+ *   plugin_analytics_1,
+ *   plugin_icons_2,
+ * ]
+ *
+ * export default plugins
+ * ```
+ */
+declare function generatePluginsTemplate(options: GeneratePluginsTemplateOptions): string;
+/**
+ * Add plugins template to Kimesh registries
+ */
+declare function addPluginsTemplate(kimesh: Kimesh, discoveredPlugins: DiscoveredPlugin[]): void;
+//#endregion
+//#region src/kit/alias-utils.d.ts
+/**
+ * Resolve an alias path template to an actual path
+ *
+ * @param template - Alias path template (e.g., "/<srcDir>/components")
+ * @param srcDir - Source directory path
+ * @param rootDir - Root directory path
+ * @returns Resolved absolute path
+ */
+declare function resolveAliasPath(template: string, srcDir: string, rootDir: string): string;
+/**
+ * Build resolved aliases from config
+ *
+ * @param config - Kimesh configuration
+ * @param srcDir - Source directory (default: rootDir/src)
+ * @param rootDir - Root directory
+ * @returns Resolved alias map
+ */
+declare function buildAliases(config: KimeshConfig, srcDir: string, rootDir: string): Record<string, string>;
+/**
+ * Convert aliases to Vite's resolve.alias format
+ *
+ * @param aliases - Alias map
+ * @returns Array of Vite alias entries
+ */
+declare function toViteAliases(aliases: Record<string, string>): Array<{
+  find: string | RegExp;
+  replacement: string;
+}>;
+/**
+ * Generate TypeScript path mappings from aliases
+ *
+ * @param aliases - Alias map
+ * @param rootDir - Root directory for relative paths
+ * @returns TypeScript compilerOptions.paths object
+ */
+declare function toTsConfigPaths(aliases: Record<string, string>, rootDir: string): Record<string, string[]>;
+/**
+ * Normalize debug configuration to DebugConfig object
+ *
+ * @param debug - Debug config from KimeshConfig (boolean or DebugConfig)
+ * @returns Normalized DebugConfig
+ */
+declare function normalizeDebugConfig(debug: boolean | DebugConfig | undefined): DebugConfig;
+/**
+ * Check if a specific debug option is enabled
+ *
+ * @param debug - Debug config
+ * @param option - Debug option to check
+ * @returns Whether the option is enabled
+ */
+declare function isDebugEnabled(debug: boolean | DebugConfig | undefined, option: keyof DebugConfig): boolean;
+//#endregion
+//#region src/kit/ignore-utils.d.ts
+/**
+ * Create an ignore instance with default and custom patterns
+ *
+ * @param config - Kimesh configuration
+ * @returns Configured ignore instance
+ */
+declare function createIgnoreFilter(config: KimeshConfig): Ignore;
+/**
+ * Check if a file should be ignored
+ *
+ * @param ig - Ignore instance
+ * @param filePath - Relative file path to check
+ * @returns Whether the file should be ignored
+ */
+declare function shouldIgnore(ig: Ignore, filePath: string): boolean;
+/**
+ * Filter an array of paths, removing ignored ones
+ *
+ * @param ig - Ignore instance
+ * @param paths - Array of relative paths
+ * @returns Array of non-ignored paths
+ */
+declare function filterIgnored(ig: Ignore, paths: string[]): string[];
+/**
+ * Create a simple matcher function for ignore patterns
+ *
+ * @param config - Kimesh configuration
+ * @returns A function that returns true if a path should be ignored
+ */
+declare function createIgnoreMatcher(config: KimeshConfig): (filePath: string) => boolean;
+/**
+ * Get all active ignore patterns from config
+ *
+ * @param config - Kimesh configuration
+ * @returns Array of all ignore patterns
+ */
+declare function getIgnorePatterns(config: KimeshConfig): string[];
+//#endregion
+//#region src/kit/route-rules.d.ts
+/**
+ * Match a route path against a pattern
+ *
+ * Supports:
+ * - Exact matches: `/about`
+ * - Wildcards: `/admin/**` (matches `/admin/users`, `/admin/users/123`)
+ * - Single segment wildcards: `/users/*` (matches `/users/123` but not `/users/123/posts`)
+ *
+ * @param pattern - Route pattern (e.g., `/admin/**`)
+ * @param routePath - Actual route path (e.g., `/admin/users`)
+ * @returns Whether the pattern matches the path
+ */
+declare function matchRoutePattern(pattern: string, routePath: string): boolean;
+/**
+ * Find matching route rules for a given path
+ *
+ * @param routeRules - Route rules configuration
+ * @param routePath - Route path to match
+ * @returns Array of matching rules in order of specificity (most specific first)
+ */
+declare function findMatchingRules(routeRules: Record<string, RouteRule>, routePath: string): Array<{
+  pattern: string;
+  rule: RouteRule;
+}>;
+/**
+ * Merge multiple route rules into a single rule
+ *
+ * Later rules override earlier rules for same properties.
+ *
+ * @param rules - Array of route rules to merge
+ * @returns Merged route rule
+ */
+declare function mergeRouteRules(rules: RouteRule[]): RouteRule;
+/**
+ * Get the effective route rule for a path
+ *
+ * @param config - Kimesh configuration
+ * @param routePath - Route path to get rule for
+ * @returns Merged route rule or undefined if no rules match
+ */
+declare function getRouteRule(config: KimeshConfig, routePath: string): RouteRule | undefined;
+/**
+ * Check if a route should be redirected
+ *
+ * @param rule - Route rule
+ * @returns Redirect information or undefined
+ */
+declare function getRedirectInfo(rule: RouteRule): {
+  to: string;
+  statusCode: 301 | 302 | 307 | 308;
+} | undefined;
+/**
+ * Generate route rules manifest for build output
+ *
+ * @param config - Kimesh configuration
+ * @returns Route rules manifest object
+ */
+declare function generateRouteRulesManifest(config: KimeshConfig): Record<string, RouteRule>;
+//#endregion
+//#region src/kit/debug.d.ts
+/**
+ * Set the debug configuration
+ *
+ * @param config - Kimesh configuration
+ */
+declare function setDebugConfig(config: KimeshConfig): void;
+/**
+ * Check if debug mode is enabled for a specific category
+ *
+ * @param category - Debug category to check
+ * @returns Whether debug is enabled for this category
+ */
+declare function isDebug(category?: keyof DebugConfig): boolean;
+/**
+ * Debug logger that only logs when debug mode is enabled
+ */
+declare const debug: {
+  /**
+       * Log debug message for hooks
+       */
+  hook(hookName: string, ...args: unknown[]): void;
+  /**
+       * Log debug message for modules
+       */
+  module(moduleName: string, message: string, ...args: unknown[]): void;
+  /**
+       * Log debug message for layers
+       */
+  layer(layerName: string, message: string, ...args: unknown[]): void;
+  /**
+       * Log debug message for config
+       */
+  config(message: string, ...args: unknown[]): void;
+  /**
+       * Log debug message for Vite
+       */
+  vite(message: string, ...args: unknown[]): void;
+  /**
+       * Log debug message for routes
+       */
+  route(routePath: string, message: string, ...args: unknown[]): void;
+  /**
+       * Log debug message for imports
+       */
+  import(name: string, message: string, ...args: unknown[]): void;
+  /**
+       * Log timing information
+       */
+  timing(label: string, startTime: number): void;
+  /**
+       * Create a timing tracker
+       */
+  startTiming(label: string): () => void;
+};
+/**
+ * Create a scoped debug logger for a specific module
+ *
+ * @param scope - Module or component name
+ * @returns Scoped debug logger
+ */
+declare function createDebugLogger(scope: string): {
+  log(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  timing: (label: string) => () => void;
+};
+/**
+ * Log a debug table (formatted key-value pairs)
+ *
+ * @param title - Table title
+ * @param data - Data to display
+ */
+declare function debugTable(title: string, data: Record<string, unknown>): void;
+//#endregion
+//#region src/vite/plugin.d.ts
+/**
+ * Kimesh Vite plugin
+ * Sets up Vue with Vite 8 + Rolldown + File-based routing + Layers + Auto-Import
+ */
+declare function kimeshPlugin(options?: KimeshPluginOptions): PluginOption[];
+//#endregion
+//#region src/config.d.ts
+interface LoadConfigOptions {
+  /** Project root directory */
+  root?: string;
+  /** Config file path */
+  configFile?: string;
+}
+/**
+ * Load kimesh.config.ts using c12
+ */
+declare function loadConfig(options?: LoadConfigOptions): Promise<KimeshConfig>;
+//#endregion
+//#region src/prepare.d.ts
+/**
+ * @kimesh/kit - Prepare Utilities
+ *
+ * Generates the .kimesh directory with TypeScript configurations,
+ * type declarations, and other generated files needed for IDE support.
+ *
+ * Similar to `nuxt prepare` - run before IDE work for full type support.
+ */
+/**
+ * Options for the prepare function
+ */
+interface PrepareOptions {
+  /** Root directory of the project */
+  root?: string;
+  /** Path to kimesh.config file */
+  configFile?: string;
+  /** Enable verbose logging */
+  verbose?: boolean;
+}
+/**
+ * Result of the prepare function
+ */
+interface PrepareResult {
+  /** Path to the .kimesh directory */
+  buildDir: string;
+  /** Number of layers resolved */
+  layerCount: number;
+  /** Number of aliases configured */
+  aliasCount: number;
+  /** Files that were generated */
+  generatedFiles: string[];
+}
+/**
+ * Prepare the .kimesh directory for TypeScript support
+ *
+ * This function generates all necessary files in the .kimesh directory
+ * to enable TypeScript autocompletion and type checking before running
+ * the dev server.
+ *
+ * @param options - Prepare options
+ * @returns Result with generated file information
+ *
+ * @example
+ * ```ts
+ * import { prepare } from '@kimesh/kit'
+ *
+ * await prepare({ root: process.cwd() })
+ * ```
+ */
+declare function prepare(options?: PrepareOptions): Promise<PrepareResult>;
+//#endregion
+//#region src/runtime-config.d.ts
+/**
+ * Options for environment variable processing
+ */
+interface EnvOptions {
+  /** Environment variable prefix (default: 'KIMESH_') */
+  prefix?: string;
+  /** Environment object to read from (default: process.env) */
+  env?: Record<string, string | undefined>;
+}
+/**
+ * Convert a config key path to environment variable name.
+ *
+ * @param keys - Array of keys representing the path (e.g., ['features', 'darkMode'])
+ * @param prefix - Environment variable prefix (default: 'KIMESH_')
+ * @returns Environment variable name (e.g., 'KIMESH_FEATURES_DARK_MODE')
+ *
+ * @example
+ * ```ts
+ * keyToEnv(['apiBase']) // => 'KIMESH_API_BASE'
+ * keyToEnv(['features', 'darkMode']) // => 'KIMESH_FEATURES_DARK_MODE'
+ * ```
+ */
+declare function keyToEnv(keys: string[], prefix?: string): string;
+/**
+ * Convert environment variable name to config key path.
+ *
+ * Note: This function uses a best-effort heuristic for reverse conversion.
+ * Since SNAKE_CASE to camelCase is ambiguous (e.g., API_BASE could be 'apiBase' or 'apibase'),
+ * this function assumes each underscore-separated segment is a word boundary.
+ *
+ * @param envKey - Environment variable name
+ * @param prefix - Environment variable prefix (default: 'KIMESH_')
+ * @returns Array of keys or null if the env var doesn't match the prefix
+ *
+ * @example
+ * ```ts
+ * envToKey('KIMESH_API_BASE') // => ['apiBase']
+ * envToKey('KIMESH_FEATURES_DARK_MODE') // => ['features', 'darkMode']
+ * ```
+ */
+declare function envToKey(envKey: string, prefix?: string): string[] | null;
+/**
+ * Apply environment variables to runtime config.
+ *
+ * Scans the environment for `KIMESH_*` variables and overlays them onto
+ * the config object. Called at build time to bake env values into the bundle.
+ *
+ * @param config - Base runtime config from kimesh.config.ts
+ * @param opts - Options for environment processing
+ * @returns Merged config with env overrides
+ *
+ * @example
+ * ```ts
+ * // Given:
+ * // KIMESH_API_BASE=https://api.example.com
+ * // KIMESH_DEBUG=true
+ *
+ * const config = applyEnv({
+ *   apiBase: '/api',
+ *   debug: false,
+ * });
+ *
+ * // Result:
+ * // { apiBase: 'https://api.example.com', debug: true }
+ * ```
+ */
+declare function applyEnv(config: Record<string, unknown>, opts?: EnvOptions): RuntimeConfig;
+/**
+ * Create an empty runtime config object.
+ * Used as a default when no config is provided.
+ */
+declare function createDefaultRuntimeConfig(): RuntimeConfig;
+//#endregion
+//#region src/hmr/watcher.d.ts
+interface HMRWatcherOptions {
+  /** Vite dev server instance */
+  server: ViteDevServer;
+  /** Resolved layers */
+  layers: ResolvedLayer$1[];
+  /** Debug mode */
+  debug?: boolean;
+}
+interface HMRContext {
+  /** File that changed */
+  file: string;
+  /** Type of change */
+  type: "add" | "change" | "unlink";
+  /** Layer this file belongs to (if any) */
+  layer?: ResolvedLayer$1;
+  /** Category of the file */
+  category: "route" | "component" | "composable" | "config" | "other";
+}
+/**
+ * Create HMR watcher for Kimesh layers
+ */
+declare function createHMRWatcher(options: HMRWatcherOptions): {
+  handleChange: (file: string, type: "add" | "change" | "unlink") => Promise<void>;
+  detectLayer: (filePath: string) => ResolvedLayer$1 | undefined;
+  detectCategory: (filePath: string) => "route" | "component" | "composable" | "config" | "other";
+};
+//#endregion
+//#region src/errors/formatter.d.ts
+interface ErrorContext {
+  /** File that caused the error */
+  file?: string;
+  /** Line number */
+  line?: number;
+  /** Column number */
+  column?: number;
+  /** Layer this error occurred in */
+  layer?: ResolvedLayer$1;
+  /** Code snippet */
+  snippet?: string;
+}
+interface FormattedError {
+  /** Error title */
+  title: string;
+  /** Error message */
+  message: string;
+  /** Location info */
+  location?: string;
+  /** Suggestions for fixing */
+  suggestions?: string[];
+  /** Full formatted output */
+  formatted: string;
+}
+/**
+ * Format an error with layer context
+ */
+declare function formatError(error: Error, context?: ErrorContext): FormattedError;
+/**
+ * Format a warning message
+ */
+declare function formatWarning(message: string, context?: ErrorContext): string;
+/**
+ * Format a conflict warning
+ */
+declare function formatConflictWarning(type: "route" | "import" | "component", name: string, sources: Array<{
+  layer: string;
+  path: string;
+}>, winner: string): string;
+/**
+ * Format timing info for debug
+ */
+declare function formatTiming(operation: string, timeMs: number, details?: Record<string, unknown>): string;
+/**
+ * Create a timing logger
+ */
+declare function createTimer(operation: string, debug?: boolean): {
+  end(details?: Record<string, unknown>): number;
+};
+//#endregion
+//#region src/index.d.ts
+interface KimeshPluginOptions {
+  /** Pre-resolved config (from CLI) */
+  config?: KimeshConfig;
+  /** Layer configuration (from CLI) */
+  layers?: {
+    /** Enabled layers */enabled?: "all" | "none" | string[]; /** Excluded layers */
+    excluded?: string[];
+  };
+  /** Enable debug logging */
+  debug?: boolean;
+  /**
+       * Additional Vite plugins added programmatically.
+       */
+  additionalPlugins?: vite3.PluginOption[];
+}
+//#endregion
+export { type AddRuntimePluginOptions, type AutoImportConfig, type AutoImportOptions, type ComponentsConfig, DEFAULT_ALIASES, DEFAULT_IGNORE_PATTERNS, type DebugConfig, type DiscoveredPlugin, type EnvOptions, type ErrorContext, type FormattedError, type GeneratePluginsTemplateOptions, type HMRContext, type HMRWatcherOptions, type HookResult, type IgnoreOptions, type ImportPreset, type ImportSource, type Kimesh, type KimeshAlias, type KimeshAppContext, type KimeshComponent, type KimeshComponentsDir, type KimeshConfig, type KimeshHooks, type KimeshImport, type KimeshImportPreset, type KimeshImportsDir, type KimeshLayerConfig, type KimeshModule, type KimeshModuleDefaults, type KimeshModuleDefinition, type KimeshModuleInput, type KimeshModuleMeta, type KimeshModuleOptions, type KimeshOptions, type KimeshPlugin, type KimeshPluginDefinition, KimeshPluginOptions, type KimeshRegistries, type KimeshResolver, type KimeshRoute, type KimeshRouteMiddleware, type KimeshRuntimeHooks, type KimeshRuntimePlugin, type KimeshRuntimePluginDefinition, type KimeshRuntimePluginEntry, type KimeshRuntimePluginMeta, type KimeshRuntimePluginResult, type KimeshTemplate, type KimeshTypeTemplate, type KimeshViteConfig, type KimeshVitePluginEntry, type LayerAutoImportConfig, type LayerComponentConfig, type LayerComposableConfig, type LayerRouteConfig, type LayersConfig, type LoadConfigOptions, type PrepareOptions, type PrepareResult, type ResolvedLayer, type ResolvedTemplate, type RouteRule, type RuntimeConfig, type RuntimeConfigPublic, type ScanPluginsOptions, type VitePlugin, type VitePluginOption, addAlias, addBuildPlugin, addComponent, addComponentResolver, addComponentsDir, addImports, addImportsDir, addImportsPreset, addPluginsTemplate, addRuntimePlugin, addTemplate, addTypeTemplate, addVitePlugin, applyEnv, buildAliases, buildImportRegistry, createDebugLogger, createDefaultRuntimeConfig, createHMRWatcher, createIgnoreFilter, createIgnoreMatcher, createKimesh, createResolver, createTimer, debug, debugTable, defineKimeshModule, defineKimeshPlugin, defineKmConfig, envToKey, executeModule, executeModules, filterIgnored, findMatchingRules, formatConflictWarning, formatError, formatTiming, formatWarning, generateDts, generateLayerAliases, generatePluginsTemplate, generateRouteRulesManifest, getIgnorePatterns, getRedirectInfo, getRouteRule, getRuntimePlugins, hasPlugins, hasRuntimePlugin, isDebug, isDebugEnabled, keyToEnv, kimeshAutoImport, kimeshPlugin, loadConfig, matchRoutePattern, mergeLayerConfigs, mergeRouteRules, normalizeDebugConfig, normalizeModuleInput, prepare, prepareLayers, removeRuntimePlugin, resolveAlias, resolveAliasPath, resolveLayers, resolvePathFromBuild, resolvePathFromRoot, scanExports, scanPluginsDir, setDebugConfig, shouldIgnore, toTsConfigPaths, toViteAliases, tryUseKimesh, updateTemplates, useKimesh, writeTemplates };
+//# sourceMappingURL=index.d.mts.map