@kimesh/kit 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2795 @@
+import { createRequire } from "node:module";
+import { createHooks } from "hookable";
+import { snakeCase } from "scule";
+import { klona } from "klona/json";
+import destr from "destr";
+import { pathToFileURL } from "node:url";
+import consola from "consola";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import fg from "fast-glob";
+import { basename, extname, isAbsolute as isAbsolute$1, join as join$1, relative, resolve as resolve$1 } from "pathe";
+import ignore from "ignore";
+import pc from "picocolors";
+import { defu } from "defu";
+import { loadEnv, mergeConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import { kimeshRouterGenerator } from "@kimesh/router-generator";
+import { generateLayerAliases, generateLayerAliases as generateLayerAliases$1, mergeLayerConfigs, prepareLayers, prepareLayers as prepareLayers$1, resolveLayers } from "@kimesh/layers";
+import { buildImportRegistry, generateDts, kimeshAutoImport, kimeshAutoImport as kimeshAutoImport$1, scanExports } from "@kimesh/auto-import";
+import { loadConfig as loadConfig$1 } from "c12";
+
+//#region src/runtime-config.ts
+/**
+* @kimesh/kit - Runtime Configuration Processing
+*
+* Utilities for processing environment variables and merging with runtime config.
+* Phase 1: Build-time only, all config is public.
+*/
+/** Default environment variable prefix */
+const ENV_PREFIX = "KIMESH_";
+/**
+* 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'
+* ```
+*/
+function keyToEnv(keys, prefix = ENV_PREFIX) {
+	return prefix + keys.map((key) => snakeCase(key).toUpperCase()).join("_");
+}
+/**
+* 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']
+* ```
+*/
+function envToKey(envKey, prefix = ENV_PREFIX) {
+	if (!envKey.startsWith(prefix)) return null;
+	const rest = envKey.slice(prefix.length);
+	if (!rest) return null;
+	return rest.toLowerCase().split("_").reduce((acc, part, i) => {
+		if (i === 0) acc.push(part);
+		else if (part) {
+			const last = acc[acc.length - 1];
+			acc[acc.length - 1] = last + part.charAt(0).toUpperCase() + part.slice(1);
+		}
+		return acc;
+	}, []);
+}
+/**
+* Check if a value at the given path exists in the config object.
+* This helps determine if an env var corresponds to an existing config key.
+*/
+function hasConfigPath(config, keys) {
+	let current = config;
+	for (const key of keys) {
+		if (current === null || typeof current !== "object") return false;
+		if (!(key in current)) return false;
+		current = current[key];
+	}
+	return true;
+}
+/**
+* Get all possible key paths from environment variable name.
+* Since SNAKE_CASE conversion is ambiguous, this generates multiple candidates.
+*
+* @param envKey - Environment variable name (without prefix)
+* @returns Array of possible key path interpretations
+*/
+function getPossiblePaths(envKey) {
+	const parts = envKey.toLowerCase().split("_");
+	const paths = [];
+	function generateGroupings(parts$1, current, start) {
+		if (start >= parts$1.length) {
+			paths.push([...current]);
+			return;
+		}
+		for (let end = start + 1; end <= parts$1.length; end++) {
+			const segment = parts$1.slice(start, end).reduce((acc, part, i) => {
+				if (i === 0) return part;
+				return acc + part.charAt(0).toUpperCase() + part.slice(1);
+			}, "");
+			current.push(segment);
+			generateGroupings(parts$1, current, end);
+			current.pop();
+		}
+	}
+	generateGroupings(parts, [], 0);
+	return paths;
+}
+/**
+* Find the best matching config path for an environment variable.
+* Prioritizes existing paths in the config, falls back to single camelCase key.
+*/
+function findBestPath(envKey, config, prefix) {
+	if (!envKey.startsWith(prefix)) return null;
+	const rest = envKey.slice(prefix.length);
+	if (!rest) return null;
+	const possiblePaths = getPossiblePaths(rest);
+	for (const path of possiblePaths) if (hasConfigPath(config, path)) return path;
+	return [rest.toLowerCase().split("_").reduce((acc, part, i) => {
+		if (i === 0) return part;
+		return acc + part.charAt(0).toUpperCase() + part.slice(1);
+	}, "")];
+}
+/**
+* Set a value at a nested path in an object, creating intermediate objects as needed.
+*/
+function setNestedValue(obj, keys, value) {
+	let current = obj;
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) current[key] = {};
+		current = current[key];
+	}
+	current[keys[keys.length - 1]] = value;
+}
+/**
+* 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 }
+* ```
+*/
+function applyEnv(config, opts = {}) {
+	const { prefix = ENV_PREFIX, env = process.env } = opts;
+	const result = klona(config);
+	for (const [key, value] of Object.entries(env)) {
+		if (value === void 0) continue;
+		if (!key.startsWith(prefix)) continue;
+		const configPath = findBestPath(key, result, prefix);
+		if (!configPath || configPath.length === 0) continue;
+		setNestedValue(result, configPath, destr(value));
+	}
+	return result;
+}
+/**
+* Create an empty runtime config object.
+* Used as a default when no config is provided.
+*/
+function createDefaultRuntimeConfig() {
+	return {};
+}
+
+//#endregion
+//#region src/core/kimesh.ts
+/**
+* @kimesh/kit - Core Kimesh Context Implementation
+*
+* The Kimesh class is the central context for all module operations.
+*/
+/**
+* Create empty registries
+*/
+function createEmptyRegistries() {
+	return {
+		vitePlugins: [],
+		aliases: [],
+		templates: [],
+		typeTemplates: [],
+		imports: [],
+		importsDirs: [],
+		importsPresets: [],
+		components: [],
+		componentsDirs: [],
+		componentResolvers: [],
+		routes: [],
+		routeMiddleware: [],
+		runtimePlugins: []
+	};
+}
+/**
+* Create a new Kimesh context
+*/
+function createKimesh(options) {
+	const hooks = createHooks();
+	const registries = createEmptyRegistries();
+	const resolvedRuntimeConfig = applyEnv(options.config.runtimeConfig || createDefaultRuntimeConfig());
+	const kimeshOptions = {
+		dev: options.dev ?? process.env.NODE_ENV !== "production",
+		root: options.root,
+		buildDir: options.buildDir,
+		config: options.config,
+		layers: options.layers,
+		runtimeConfig: {
+			public: resolvedRuntimeConfig,
+			private: {}
+		}
+	};
+	return {
+		options: kimeshOptions,
+		hooks,
+		_registries: registries,
+		get layers() {
+			return kimeshOptions.layers;
+		},
+		get root() {
+			return kimeshOptions.root;
+		},
+		get buildDir() {
+			return kimeshOptions.buildDir;
+		},
+		hook(name, handler, opts) {
+			return hooks.hook(name, handler, opts);
+		},
+		callHook(name, ...args) {
+			return hooks.callHook(name, ...args);
+		},
+		hookOnce(name, handler) {
+			return hooks.hookOnce(name, handler);
+		}
+	};
+}
+let currentKimesh;
+/**
+* Set the current Kimesh context (internal use)
+*/
+function _setKimeshContext(kimesh) {
+	currentKimesh = kimesh;
+}
+/**
+* Get the current Kimesh context
+* @throws Error if not in a Kimesh context
+*/
+function useKimesh() {
+	if (!currentKimesh) throw new Error("[kimesh] useKimesh() called outside of Kimesh context. Make sure you're calling this within a module setup function.");
+	return currentKimesh;
+}
+/**
+* Try to get the current Kimesh context
+* @returns Kimesh instance or undefined if not in context
+*/
+function tryUseKimesh() {
+	return currentKimesh;
+}
+
+//#endregion
+//#region src/core/module.ts
+/**
+* @kimesh/kit - Module Definition & Execution
+*/
+/**
+* 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
+*   },
+* });
+* ```
+*/
+function defineKimeshModule(definition) {
+	return {
+		_def: definition,
+		meta: {
+			name: definition.meta?.name ?? "anonymous-module",
+			version: definition.meta?.version ?? "0.0.0",
+			configKey: definition.meta?.configKey ?? "",
+			compatibility: definition.meta?.compatibility ?? {}
+		},
+		async getDefaults(kimesh) {
+			if (!definition.defaults) return {};
+			if (typeof definition.defaults === "function") return await definition.defaults(kimesh);
+			return definition.defaults;
+		},
+		async setup(options, kimesh) {
+			if (definition.hooks) {
+				for (const [hookName, handler] of Object.entries(definition.hooks)) if (handler) kimesh.hook(hookName, handler);
+			}
+			if (definition.setup) await definition.setup(options, kimesh);
+		}
+	};
+}
+/**
+* Resolve a string module name to an actual module
+*/
+async function resolveStringModule(moduleName, kimesh) {
+	try {
+		const requirePath = kimesh.root + "/package.json";
+		const require = createRequire(pathToFileURL(requirePath).href);
+		let modulePath;
+		try {
+			modulePath = require.resolve(moduleName);
+			consola.debug(`[Kimesh] Resolved module "${moduleName}" to ${modulePath}`);
+		} catch (err) {
+			consola.debug(`[Kimesh] Failed to resolve "${moduleName}" from ${requirePath}:`, err);
+			throw new Error(`Module "${moduleName}" not found. Make sure it's installed in your project.`);
+		}
+		const imported = await import(pathToFileURL(modulePath).href);
+		const module = imported.default || imported;
+		if (module && typeof module === "object" && "_def" in module) return module;
+		if (module && typeof module === "object" && "setup" in module) return defineKimeshModule(module);
+		throw new Error(`Module "${moduleName}" does not export a valid Kimesh module. Make sure the module uses defineKimeshModule() or exports a valid module definition.`);
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error(`Failed to load module "${moduleName}": ${error}`);
+	}
+}
+/**
+* Normalize module input (string, module, or [module, options] tuple)
+*/
+async function normalizeModuleInput(input, kimesh) {
+	if (typeof input === "string") return {
+		module: await resolveStringModule(input, kimesh),
+		options: {}
+	};
+	if (Array.isArray(input)) {
+		const [moduleOrString, options] = input;
+		if (typeof moduleOrString === "string") return {
+			module: await resolveStringModule(moduleOrString, kimesh),
+			options: options ?? {}
+		};
+		return {
+			module: moduleOrString,
+			options: options ?? {}
+		};
+	}
+	return {
+		module: input,
+		options: {}
+	};
+}
+/**
+* Execute a single module
+*/
+async function executeModule(moduleInput, kimesh) {
+	const { module, options: userOptions } = await normalizeModuleInput(moduleInput, kimesh);
+	const defaults = await module.getDefaults(kimesh);
+	const configKey = module.meta.configKey;
+	const configOptions = configKey ? kimesh.options.config[configKey] ?? {} : {};
+	const mergedOptions = {
+		...defaults,
+		...configOptions,
+		...userOptions
+	};
+	_setKimeshContext(kimesh);
+	try {
+		await module.setup(mergedOptions, kimesh);
+	} finally {
+		_setKimeshContext(void 0);
+	}
+}
+/**
+* Extract module name from various input formats
+*/
+function getModuleName(input) {
+	if (typeof input === "string") return input;
+	if (Array.isArray(input)) {
+		const first = input[0];
+		if (typeof first === "string") return first;
+		return first.meta?.name ?? "unknown";
+	}
+	return input.meta?.name ?? "unknown";
+}
+/**
+* Execute all modules in order
+*/
+async function executeModules(modules, kimesh) {
+	await kimesh.callHook("modules:before", kimesh);
+	for (const moduleInput of modules) try {
+		await executeModule(moduleInput, kimesh);
+	} catch (error) {
+		const moduleName = getModuleName(moduleInput);
+		consola.error(`[Kimesh] Failed to execute module "${moduleName}":`, error);
+	}
+	await kimesh.callHook("modules:done", kimesh);
+}
+
+//#endregion
+//#region src/core/plugin.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,
+*     });
+*   },
+* });
+* ```
+*/
+function defineKimeshPlugin(definition) {
+	return {
+		_def: definition,
+		name: definition.name,
+		getPlugins(kimesh) {
+			const result = definition.setup(kimesh);
+			return Array.isArray(result) ? result : [result];
+		}
+	};
+}
+
+//#endregion
+//#region src/kit/vite.ts
+/**
+* Add a Vite plugin to the build
+*
+* @example
+* ```ts
+* addVitePlugin(myPlugin());
+* addVitePlugin(myPlugin(), { enforce: "pre" });
+* ```
+*/
+function addVitePlugin(plugin, options) {
+	_addVitePlugin(useKimesh(), plugin, options);
+}
+/**
+* Internal: Add Vite plugin with explicit Kimesh context
+*/
+function _addVitePlugin(kimesh, plugin, options) {
+	const plugins = Array.isArray(plugin) ? plugin : [plugin];
+	const registry = kimesh._registries.vitePlugins;
+	for (const p of plugins) {
+		if (!p) continue;
+		const entry = {
+			plugin: p,
+			enforce: options?.enforce,
+			order: options?.order,
+			meta: { name: p.name }
+		};
+		if (options?.prepend) registry.unshift(entry);
+		else registry.push(entry);
+	}
+}
+/**
+* Add a build plugin (alias for addVitePlugin with default order)
+*/
+function addBuildPlugin(plugin, options) {
+	addVitePlugin(plugin, options);
+}
+
+//#endregion
+//#region src/kit/alias.ts
+/**
+* Add an alias
+*
+* @example
+* ```ts
+* addAlias("#my-module", "/path/to/module");
+* addAlias("@/components", "./src/components");
+* ```
+*/
+function addAlias(find, replacement) {
+	_addAlias(useKimesh(), find, replacement);
+}
+/**
+* Internal: Add alias with explicit Kimesh context
+*/
+function _addAlias(kimesh, find, replacement) {
+	const alias = {
+		find,
+		replacement
+	};
+	kimesh._registries.aliases.push(alias);
+}
+/**
+* Resolve an alias to its actual path
+*/
+function resolveAlias(alias) {
+	return _resolveAlias(useKimesh(), alias);
+}
+/**
+* Check if an alias matches a given find pattern
+*/
+function matchesAlias(alias, find) {
+	if (typeof find === "string") return alias === find || alias.startsWith(find + "/");
+	return find.test(alias);
+}
+/**
+* Internal: Resolve alias with explicit Kimesh context
+*/
+function _resolveAlias(kimesh, alias) {
+	for (const entry of kimesh._registries.aliases) if (matchesAlias(alias, entry.find)) return alias.replace(entry.find, entry.replacement);
+}
+
+//#endregion
+//#region src/kit/templates.ts
+/**
+* @kimesh/kit - Template Utilities
+*/
+/**
+* Add a template to be generated
+*
+* @example
+* ```ts
+* addTemplate({
+*   filename: "my-config.ts",
+*   getContents: ({ kimesh }) => `export default ${JSON.stringify(config)}`,
+* });
+* ```
+*/
+function addTemplate(template) {
+	_addTemplate(useKimesh(), template);
+}
+/**
+* Internal: Add template with explicit Kimesh context
+*/
+function _addTemplate(kimesh, template) {
+	kimesh._registries.templates.push(template);
+}
+/**
+* Add a type template (.d.ts) to be generated
+*
+* @example
+* ```ts
+* addTypeTemplate({
+*   filename: "components.d.ts",
+*   getContents: ({ kimesh }) => generateComponentTypes(kimesh),
+* });
+* ```
+*/
+function addTypeTemplate(template) {
+	_addTypeTemplate(useKimesh(), template);
+}
+/**
+* Internal: Add type template with explicit Kimesh context
+*/
+function _addTypeTemplate(kimesh, template) {
+	kimesh._registries.typeTemplates.push(template);
+}
+/**
+* Ensure build directory exists
+*/
+function ensureBuildDir(kimesh) {
+	if (!existsSync(kimesh.buildDir)) mkdirSync(kimesh.buildDir, { recursive: true });
+}
+/**
+* Generate and write all templates
+*/
+async function writeTemplates(kimesh) {
+	ensureBuildDir(kimesh);
+	const results = [];
+	for (const template of kimesh._registries.templates) {
+		const resolved = await resolveTemplate(kimesh, template);
+		if (resolved) {
+			if (template.write !== false) writeTemplate(resolved);
+			results.push(resolved);
+		}
+	}
+	for (const template of kimesh._registries.typeTemplates) {
+		const resolved = await resolveTemplate(kimesh, template);
+		if (resolved) {
+			writeTemplate(resolved);
+			results.push(resolved);
+		}
+	}
+	return results;
+}
+/**
+* Resolve a single template
+*/
+async function resolveTemplate(kimesh, template) {
+	let contents;
+	if (template.getContents) contents = await template.getContents({
+		...template.data,
+		kimesh
+	});
+	else if (template.src) contents = readFileSync(template.src, "utf-8");
+	else return null;
+	const dst = join(kimesh.buildDir, template.filename);
+	return {
+		filename: template.filename,
+		dst,
+		contents
+	};
+}
+/**
+* Write a resolved template to disk
+*/
+function writeTemplate(template) {
+	const dir = dirname(template.dst);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(template.dst, template.contents, "utf-8");
+}
+/**
+* Update specific templates (for HMR)
+*/
+async function updateTemplates(kimesh, options) {
+	const templates = options?.filter ? kimesh._registries.templates.filter(options.filter) : kimesh._registries.templates;
+	const results = [];
+	for (const template of templates) {
+		const resolved = await resolveTemplate(kimesh, template);
+		if (resolved && template.write !== false) {
+			writeTemplate(resolved);
+			results.push(resolved);
+		}
+	}
+	return results;
+}
+
+//#endregion
+//#region src/kit/components.ts
+/**
+* Add a single component
+*
+* @example
+* ```ts
+* addComponent({
+*   name: "MyButton",
+*   filePath: "./components/MyButton.vue",
+* });
+* ```
+*/
+function addComponent(component) {
+	_addComponent(useKimesh(), component);
+}
+/**
+* Internal: Add component with explicit Kimesh context
+*/
+function _addComponent(kimesh, component) {
+	kimesh._registries.components.push(component);
+}
+/**
+* Add a components directory
+*
+* @example
+* ```ts
+* addComponentsDir({
+*   path: "./components/ui",
+*   prefix: "Ui",
+* });
+* ```
+*/
+function addComponentsDir(dir, options) {
+	_addComponentsDir(useKimesh(), dir, options);
+}
+/**
+* Internal: Add components directory with explicit Kimesh context
+*/
+function _addComponentsDir(kimesh, dir, options) {
+	if (options?.prepend) kimesh._registries.componentsDirs.unshift(dir);
+	else kimesh._registries.componentsDirs.push(dir);
+}
+/**
+* Add a component resolver
+*
+* @example
+* ```ts
+* addComponentResolver({
+*   type: "component",
+*   resolve: (name) => {
+*     if (name.startsWith("Ui")) {
+*       return { name, from: `./components/ui/${name}.vue` };
+*     }
+*   },
+* });
+* ```
+*/
+function addComponentResolver(resolver) {
+	_addComponentResolver(useKimesh(), resolver);
+}
+/**
+* Internal: Add component resolver with explicit Kimesh context
+*/
+function _addComponentResolver(kimesh, resolver) {
+	kimesh._registries.componentResolvers.push(resolver);
+}
+
+//#endregion
+//#region src/kit/imports.ts
+/**
+* Add imports (auto-imports)
+*
+* @example
+* ```ts
+* addImports({ name: "useAuth", from: "./composables/auth" });
+* addImports([
+*   { name: "ref", from: "vue" },
+*   { name: "computed", from: "vue" },
+* ]);
+* ```
+*/
+function addImports(imports) {
+	_addImports(useKimesh(), imports);
+}
+/**
+* Internal: Add imports with explicit Kimesh context
+*/
+function _addImports(kimesh, imports) {
+	const importsList = Array.isArray(imports) ? imports : [imports];
+	kimesh._registries.imports.push(...importsList);
+}
+/**
+* Add an imports directory
+*
+* @example
+* ```ts
+* addImportsDir("./composables");
+* addImportsDir({ path: "./utils", pattern: "use*.ts" });
+* ```
+*/
+function addImportsDir(dir, options) {
+	_addImportsDir(useKimesh(), dir, options);
+}
+/**
+* Internal: Add imports directory with explicit Kimesh context
+*/
+function _addImportsDir(kimesh, dir, options) {
+	const dirConfig = typeof dir === "string" ? { path: dir } : dir;
+	if (options?.prepend) kimesh._registries.importsDirs.unshift(dirConfig);
+	else kimesh._registries.importsDirs.push(dirConfig);
+}
+/**
+* Add import presets
+*
+* @example
+* ```ts
+* addImportsPreset({ from: "vue", imports: ["ref", "computed", "watch"] });
+* ```
+*/
+function addImportsPreset(preset) {
+	_addImportsPreset(useKimesh(), preset);
+}
+/**
+* Internal: Add import preset with explicit Kimesh context
+*/
+function _addImportsPreset(kimesh, preset) {
+	kimesh._registries.importsPresets.push(preset);
+}
+
+//#endregion
+//#region src/kit/resolver.ts
+/**
+* @kimesh/kit - Resolver Utilities
+*/
+/**
+* Create a resolver for the current module
+*
+* @example
+* ```ts
+* const resolver = createResolver(import.meta.url);
+* const runtimePath = resolver.resolve("./runtime");
+* ```
+*/
+function createResolver(base) {
+	const baseDir = base.startsWith("file://") ? dirname(new URL(base).pathname) : dirname(base);
+	return {
+		resolve(...paths) {
+			return resolve(baseDir, ...paths);
+		},
+		async resolvePath(path) {
+			const resolved = resolve(baseDir, path);
+			if (!existsSync(resolved)) throw new Error(`Path not found: ${resolved}`);
+			return resolved;
+		},
+		resolveAlias(alias) {
+			const kimesh = tryUseKimesh();
+			if (!kimesh) return;
+			return _resolveAlias(kimesh, alias);
+		}
+	};
+}
+/**
+* Resolve a path relative to project root
+*/
+function resolvePathFromRoot(...paths) {
+	return resolve(useKimesh().root, ...paths);
+}
+/**
+* Resolve a path relative to build directory
+*/
+function resolvePathFromBuild(...paths) {
+	return resolve(useKimesh().buildDir, ...paths);
+}
+
+//#endregion
+//#region src/kit/runtime-plugin.ts
+/**
+* @kimesh/kit - Runtime Plugin Kit Utilities
+*
+* Functions for registering runtime plugins during module setup.
+*/
+/**
+* Extract plugin name from a file path
+*/
+function extractPluginName(path) {
+	const match = path.match(/([^/\\]+?)(?:\.[^.]+)?$/);
+	if (!match) return "anonymous";
+	const filename = match[1];
+	const orderMatch = filename.match(/^\d+\.(.+)$/);
+	return orderMatch ? orderMatch[1] : filename;
+}
+/**
+* Normalize a plugin path or entry to a standard entry format
+*/
+function normalizeRuntimePlugin(plugin) {
+	if (typeof plugin === "string") return {
+		src: plugin,
+		name: extractPluginName(plugin)
+	};
+	return plugin;
+}
+/**
+* Add a runtime plugin to the Kimesh app
+*
+* @example
+* ```ts
+* addRuntimePlugin('~/plugins/analytics.ts')
+* addRuntimePlugin({ src: '~/plugins/analytics.ts', meta: { enforce: 'post' } })
+* ```
+*/
+function addRuntimePlugin(plugin, options = {}) {
+	const kimesh = useKimesh();
+	const normalized = normalizeRuntimePlugin(plugin);
+	if (normalized.src) kimesh._registries.runtimePlugins = kimesh._registries.runtimePlugins.filter((p) => p.src !== normalized.src);
+	if (options.append) kimesh._registries.runtimePlugins.push(normalized);
+	else kimesh._registries.runtimePlugins.unshift(normalized);
+}
+/**
+* Remove a runtime plugin by source path
+*/
+function removeRuntimePlugin(src) {
+	const kimesh = useKimesh();
+	kimesh._registries.runtimePlugins = kimesh._registries.runtimePlugins.filter((p) => p.src !== src);
+}
+/**
+* Check if a runtime plugin is registered
+*/
+function hasRuntimePlugin(src) {
+	return useKimesh()._registries.runtimePlugins.some((p) => p.src === src);
+}
+/**
+* Get all registered runtime plugins
+*/
+function getRuntimePlugins() {
+	return [...useKimesh()._registries.runtimePlugins];
+}
+
+//#endregion
+//#region src/kit/plugin-scanner.ts
+/**
+* @kimesh/kit - Plugin Scanner
+*
+* Scans the plugins directory for auto-discovered runtime plugins.
+*/
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".js",
+	".mjs"
+];
+const DEFAULT_IGNORE = [
+	"**/node_modules/**",
+	"**/*.d.ts",
+	"**/*.test.ts",
+	"**/*.spec.ts"
+];
+/**
+* Parse filename to extract order prefix and plugin name
+*
+* Filename conventions:
+* - `auth.ts` -> name: 'auth', order: undefined
+* - `01.auth.ts` -> name: 'auth', order: 1
+* - `10.analytics.ts` -> name: 'analytics', order: 10
+*/
+function parsePluginFilename(filename) {
+	const withoutExt = basename(filename, extname(filename));
+	const orderMatch = withoutExt.match(/^(\d+)\.(.+)$/);
+	if (orderMatch) return {
+		name: orderMatch[2],
+		order: parseInt(orderMatch[1], 10)
+	};
+	return { name: withoutExt };
+}
+/**
+* Build glob pattern for plugin file scanning
+*/
+function buildPluginGlobPattern(extensions) {
+	const normalizedExts = extensions.map((e) => e.startsWith(".") ? e.slice(1) : e);
+	if (normalizedExts.length === 1) return `*.${normalizedExts[0]}`;
+	return `*.{${normalizedExts.join(",")}}`;
+}
+/**
+* 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 },
+* // ]
+* ```
+*/
+async function scanPluginsDir(pluginsDir, options = {}) {
+	if (!existsSync(pluginsDir)) return [];
+	const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+	const ignore$1 = options.ignore ?? DEFAULT_IGNORE;
+	return (await fg(buildPluginGlobPattern(extensions), {
+		cwd: pluginsDir,
+		onlyFiles: true,
+		ignore: ignore$1,
+		absolute: false
+	})).map((file) => {
+		const { name, order } = parsePluginFilename(file);
+		return {
+			src: join$1(pluginsDir, file),
+			name,
+			order
+		};
+	}).sort((a, b) => {
+		if (a.order === void 0 && b.order === void 0) return a.name.localeCompare(b.name);
+		if (a.order === void 0) return 1;
+		if (b.order === void 0) return -1;
+		return a.order - b.order;
+	});
+}
+/**
+* Check if a directory has any plugin files
+*/
+async function hasPlugins(pluginsDir, options = {}) {
+	return (await scanPluginsDir(pluginsDir, options)).length > 0;
+}
+
+//#endregion
+//#region src/kit/plugin-template.ts
+/**
+* @kimesh/kit - Plugin Template Generator
+*
+* Generates the #build/plugins.mjs file that exports all runtime plugins.
+*/
+/**
+* Create a valid JavaScript variable name from plugin name
+*/
+function toVariableName(name, index) {
+	return `plugin_${name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1").replace(/_+/g, "_")}_${index}`;
+}
+/**
+* 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
+* ```
+*/
+function generatePluginsTemplate(options) {
+	const { discoveredPlugins, registeredPlugins, buildDir } = options;
+	const imports = [];
+	const pluginVars = [];
+	let index = 0;
+	if (discoveredPlugins.length > 0) {
+		imports.push("// Auto-discovered plugins");
+		for (const plugin of discoveredPlugins) {
+			const varName = toVariableName(plugin.name, index);
+			const importPath = relative(buildDir, plugin.src).replace(/\.ts$/, "");
+			imports.push(`import ${varName} from '${importPath}'`);
+			pluginVars.push(varName);
+			index++;
+		}
+	}
+	const pluginsWithSrc = registeredPlugins.filter((p) => p.src);
+	if (pluginsWithSrc.length > 0) {
+		if (imports.length > 0) imports.push("");
+		imports.push("// Module-registered plugins");
+		for (const plugin of pluginsWithSrc) {
+			const varName = toVariableName(plugin.name || "module", index);
+			const importPath = plugin.src.startsWith("@") || plugin.src.startsWith(".") ? plugin.src : relative(buildDir, plugin.src).replace(/\.ts$/, "");
+			imports.push(`import ${varName} from '${importPath}'`);
+			pluginVars.push(varName);
+			index++;
+		}
+	}
+	if (pluginVars.length === 0) return `/**
+ * Kimesh Runtime Plugins
+ * Auto-generated by @kimesh/kit - Do not edit manually
+ */
+
+export const plugins = []
+
+export default plugins
+`;
+	const pluginsList = pluginVars.map((v) => `  ${v},`).join("\n");
+	return `/**
+ * Kimesh Runtime Plugins
+ * Auto-generated by @kimesh/kit - Do not edit manually
+ */
+
+${imports.join("\n")}
+
+export const plugins = [
+${pluginsList}
+]
+
+export default plugins
+`;
+}
+/**
+* Add plugins template to Kimesh registries
+*/
+function addPluginsTemplate(kimesh, discoveredPlugins) {
+	kimesh._registries.templates.push({
+		filename: "plugins.mjs",
+		getContents: ({ kimesh: km }) => {
+			return generatePluginsTemplate({
+				discoveredPlugins,
+				registeredPlugins: km._registries.runtimePlugins,
+				buildDir: km.buildDir
+			});
+		}
+	});
+}
+
+//#endregion
+//#region src/types/config.ts
+/**
+* Default aliases provided by Kimesh.
+* Templates use placeholders: <srcDir>, <rootDir>
+* These are replaced at build time with actual paths.
+*/
+const DEFAULT_ALIASES = {
+	"~": "<srcDir>",
+	"@": "<srcDir>",
+	"~~": "<rootDir>",
+	"@@": "<rootDir>",
+	"#build": "<rootDir>/.kimesh",
+	"#app": "<rootDir>/.kimesh/app"
+};
+/**
+* Default file/folder ignore patterns
+*/
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/*.stories.{js,cts,mts,ts,jsx,tsx}",
+	"**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}",
+	"**/*.d.{cts,mts,ts}",
+	"**/.{git,cache,data,output}",
+	"**/*.sock",
+	".kimesh",
+	"**/node_modules",
+	"**/-*.*"
+];
+/**
+* Define Kimesh configuration with type inference.
+*/
+function defineKmConfig(config) {
+	return config;
+}
+
+//#endregion
+//#region src/kit/alias-utils.ts
+/**
+* @kimesh/kit - Alias Resolution Utilities
+*
+* Utilities for resolving and processing path aliases.
+*/
+/**
+* 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
+*/
+function resolveAliasPath(template, srcDir, rootDir) {
+	return template.replace(/<srcDir>/g, srcDir).replace(/<rootDir>/g, rootDir);
+}
+/**
+* Build resolved aliases from config
+*
+* @param config - Kimesh configuration
+* @param srcDir - Source directory (default: rootDir/src)
+* @param rootDir - Root directory
+* @returns Resolved alias map
+*/
+function buildAliases(config, srcDir, rootDir) {
+	const aliases = {};
+	for (const [alias, template] of Object.entries(DEFAULT_ALIASES)) aliases[alias] = resolveAliasPath(template, srcDir, rootDir);
+	if (config.alias) for (const [alias, path] of Object.entries(config.alias)) aliases[alias] = isAbsolute(path) ? path : resolve(rootDir, path);
+	return aliases;
+}
+/**
+* Convert aliases to Vite's resolve.alias format
+*
+* @param aliases - Alias map
+* @returns Array of Vite alias entries
+*/
+function toViteAliases(aliases) {
+	return Object.entries(aliases).map(([find, replacement]) => ({
+		find,
+		replacement
+	}));
+}
+/**
+* Generate TypeScript path mappings from aliases
+*
+* @param aliases - Alias map
+* @param rootDir - Root directory for relative paths
+* @returns TypeScript compilerOptions.paths object
+*/
+function toTsConfigPaths(aliases, rootDir) {
+	const paths = {};
+	for (const [alias, absolutePath] of Object.entries(aliases)) {
+		const relativePath = absolutePath.startsWith(rootDir) ? "./" + absolutePath.slice(rootDir.length + 1) : absolutePath;
+		paths[alias] = [relativePath];
+		paths[`${alias}/*`] = [`${relativePath}/*`];
+	}
+	return paths;
+}
+/**
+* Normalize debug configuration to DebugConfig object
+*
+* @param debug - Debug config from KimeshConfig (boolean or DebugConfig)
+* @returns Normalized DebugConfig
+*/
+function normalizeDebugConfig(debug$1) {
+	if (!debug$1) return {};
+	if (debug$1 === true) return {
+		hooks: true,
+		modules: true,
+		layers: true,
+		config: true,
+		vite: true,
+		routes: true,
+		imports: true
+	};
+	return debug$1;
+}
+/**
+* Check if a specific debug option is enabled
+*
+* @param debug - Debug config
+* @param option - Debug option to check
+* @returns Whether the option is enabled
+*/
+function isDebugEnabled(debug$1, option) {
+	if (!debug$1) return false;
+	if (debug$1 === true) return true;
+	return !!debug$1[option];
+}
+
+//#endregion
+//#region src/kit/ignore-utils.ts
+/**
+* @kimesh/kit - Ignore Patterns Utilities
+*
+* Utilities for handling file ignore patterns using node-ignore.
+*/
+/**
+* Create an ignore instance with default and custom patterns
+*
+* @param config - Kimesh configuration
+* @returns Configured ignore instance
+*/
+function createIgnoreFilter(config) {
+	const ig = ignore(config.ignoreOptions);
+	ig.add(DEFAULT_IGNORE_PATTERNS);
+	if (config.ignore) ig.add(config.ignore);
+	const prefix = config.ignorePrefix ?? "-";
+	if (prefix) ig.add(`**/${prefix}*`);
+	return ig;
+}
+/**
+* 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
+*/
+function shouldIgnore(ig, filePath) {
+	const normalizedPath = filePath.replace(/\\/g, "/");
+	return ig.ignores(normalizedPath);
+}
+/**
+* Filter an array of paths, removing ignored ones
+*
+* @param ig - Ignore instance
+* @param paths - Array of relative paths
+* @returns Array of non-ignored paths
+*/
+function filterIgnored(ig, paths) {
+	return paths.filter((p) => !shouldIgnore(ig, p));
+}
+/**
+* Create a simple matcher function for ignore patterns
+*
+* @param config - Kimesh configuration
+* @returns A function that returns true if a path should be ignored
+*/
+function createIgnoreMatcher(config) {
+	const ig = createIgnoreFilter(config);
+	return (filePath) => shouldIgnore(ig, filePath);
+}
+/**
+* Get all active ignore patterns from config
+*
+* @param config - Kimesh configuration
+* @returns Array of all ignore patterns
+*/
+function getIgnorePatterns(config) {
+	const patterns = [...DEFAULT_IGNORE_PATTERNS];
+	if (config.ignore) patterns.push(...config.ignore);
+	const prefix = config.ignorePrefix ?? "-";
+	if (prefix) patterns.push(`**/${prefix}*`);
+	return patterns;
+}
+
+//#endregion
+//#region src/kit/route-rules.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
+*/
+function matchRoutePattern(pattern, routePath) {
+	const normalizedPattern = pattern.replace(/\/+/g, "/").replace(/\/$/, "");
+	const normalizedPath = routePath.replace(/\/+/g, "/").replace(/\/$/, "");
+	let regexPattern = normalizedPattern.replace(/\/\*\*/g, "___DOUBLE_WILDCARD___").replace(/\*/g, "___SINGLE_WILDCARD___").replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/___DOUBLE_WILDCARD___/g, "(?:/.*)?").replace(/___SINGLE_WILDCARD___/g, "[^/]+");
+	return (/* @__PURE__ */ new RegExp(`^${regexPattern}$`)).test(normalizedPath);
+}
+/**
+* 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)
+*/
+function findMatchingRules(routeRules, routePath) {
+	const matches = [];
+	for (const [pattern, rule] of Object.entries(routeRules)) if (matchRoutePattern(pattern, routePath)) {
+		let specificity = 0;
+		if (!pattern.includes("*")) specificity = 1e3;
+		else if (pattern.includes("**")) specificity = pattern.split("/").length;
+		else specificity = pattern.split("/").length * 10;
+		matches.push({
+			pattern,
+			rule,
+			specificity
+		});
+	}
+	matches.sort((a, b) => b.specificity - a.specificity);
+	return matches.map(({ pattern, rule }) => ({
+		pattern,
+		rule
+	}));
+}
+/**
+* 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
+*/
+function mergeRouteRules(rules) {
+	const merged = {};
+	for (const rule of rules) {
+		if (rule.redirect !== void 0) merged.redirect = rule.redirect;
+		if (rule.prerender !== void 0) merged.prerender = rule.prerender;
+		if (rule.cache !== void 0) if (typeof rule.cache === "boolean") merged.cache = rule.cache;
+		else if (typeof merged.cache === "object" && typeof rule.cache === "object") merged.cache = {
+			...merged.cache,
+			...rule.cache
+		};
+		else merged.cache = rule.cache;
+		if (rule.headers) merged.headers = {
+			...merged.headers,
+			...rule.headers
+		};
+		if (rule.cors !== void 0) if (typeof rule.cors === "boolean") merged.cors = rule.cors;
+		else if (typeof merged.cors === "object" && typeof rule.cors === "object") merged.cors = {
+			...merged.cors,
+			...rule.cors
+		};
+		else merged.cors = rule.cors;
+		if (rule.meta) merged.meta = {
+			...merged.meta,
+			...rule.meta
+		};
+	}
+	return merged;
+}
+/**
+* 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
+*/
+function getRouteRule(config, routePath) {
+	if (!config.routeRules) return;
+	const matches = findMatchingRules(config.routeRules, routePath);
+	if (matches.length === 0) return;
+	return mergeRouteRules(matches.reverse().map((m) => m.rule));
+}
+/**
+* Check if a route should be redirected
+*
+* @param rule - Route rule
+* @returns Redirect information or undefined
+*/
+function getRedirectInfo(rule) {
+	if (!rule.redirect) return;
+	if (typeof rule.redirect === "string") return {
+		to: rule.redirect,
+		statusCode: 302
+	};
+	return {
+		to: rule.redirect.to,
+		statusCode: rule.redirect.statusCode ?? 302
+	};
+}
+/**
+* Generate route rules manifest for build output
+*
+* @param config - Kimesh configuration
+* @returns Route rules manifest object
+*/
+function generateRouteRulesManifest(config) {
+	return config.routeRules ?? {};
+}
+
+//#endregion
+//#region src/kit/debug.ts
+/**
+* @kimesh/kit - Debug Utilities
+*
+* Utilities for debug mode logging and diagnostics.
+*/
+let cachedDebugConfig = null;
+/**
+* Set the debug configuration
+*
+* @param config - Kimesh configuration
+*/
+function setDebugConfig(config) {
+	if (!config.debug) {
+		cachedDebugConfig = null;
+		return;
+	}
+	if (config.debug === true) cachedDebugConfig = {
+		hooks: true,
+		modules: true,
+		layers: true,
+		config: true,
+		vite: true,
+		routes: true,
+		imports: true
+	};
+	else cachedDebugConfig = config.debug;
+}
+/**
+* Check if debug mode is enabled for a specific category
+*
+* @param category - Debug category to check
+* @returns Whether debug is enabled for this category
+*/
+function isDebug(category) {
+	if (!cachedDebugConfig) return false;
+	if (!category) return true;
+	return !!cachedDebugConfig[category];
+}
+/**
+* Debug logger that only logs when debug mode is enabled
+*/
+const debug = {
+	hook(hookName, ...args) {
+		if (!isDebug("hooks")) return;
+		consola.debug(pc.gray(`[hook] ${pc.cyan(hookName)}`), ...args);
+	},
+	module(moduleName, message, ...args) {
+		if (!isDebug("modules")) return;
+		consola.debug(pc.gray(`[module] ${pc.magenta(moduleName)}: ${message}`), ...args);
+	},
+	layer(layerName, message, ...args) {
+		if (!isDebug("layers")) return;
+		consola.debug(pc.gray(`[layer] ${pc.yellow(layerName)}: ${message}`), ...args);
+	},
+	config(message, ...args) {
+		if (!isDebug("config")) return;
+		consola.debug(pc.gray(`[config] ${message}`), ...args);
+	},
+	vite(message, ...args) {
+		if (!isDebug("vite")) return;
+		consola.debug(pc.gray(`[vite] ${message}`), ...args);
+	},
+	route(routePath, message, ...args) {
+		if (!isDebug("routes")) return;
+		consola.debug(pc.gray(`[route] ${pc.green(routePath)}: ${message}`), ...args);
+	},
+	import(name, message, ...args) {
+		if (!isDebug("imports")) return;
+		consola.debug(pc.gray(`[import] ${pc.blue(name)}: ${message}`), ...args);
+	},
+	timing(label, startTime) {
+		if (!cachedDebugConfig) return;
+		const duration = performance.now() - startTime;
+		consola.debug(pc.gray(`[timing] ${label}: ${pc.bold(duration.toFixed(2))}ms`));
+	},
+	startTiming(label) {
+		const start = performance.now();
+		return () => debug.timing(label, start);
+	}
+};
+/**
+* Create a scoped debug logger for a specific module
+*
+* @param scope - Module or component name
+* @returns Scoped debug logger
+*/
+function createDebugLogger(scope) {
+	return {
+		log(message, ...args) {
+			if (!cachedDebugConfig) return;
+			consola.debug(pc.gray(`[${scope}] ${message}`), ...args);
+		},
+		info(message, ...args) {
+			if (!cachedDebugConfig) return;
+			consola.info(pc.gray(`[${scope}] ${message}`), ...args);
+		},
+		warn(message, ...args) {
+			if (!cachedDebugConfig) return;
+			consola.warn(`[${scope}] ${message}`, ...args);
+		},
+		error(message, ...args) {
+			consola.error(`[${scope}] ${message}`, ...args);
+		},
+		timing: debug.startTiming
+	};
+}
+/**
+* Log a debug table (formatted key-value pairs)
+*
+* @param title - Table title
+* @param data - Data to display
+*/
+function debugTable(title, data) {
+	if (!cachedDebugConfig) return;
+	consola.debug(pc.bold(pc.cyan(`\n${title}:`)));
+	const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
+	for (const [key, value] of Object.entries(data)) {
+		const paddedKey = key.padEnd(maxKeyLength);
+		const formattedValue = typeof value === "object" ? JSON.stringify(value, null, 2) : String(value);
+		consola.debug(pc.gray(`  ${paddedKey} : ${formattedValue}`));
+	}
+}
+
+//#endregion
+//#region src/kit/tsconfig-generator.ts
+/**
+* @kimesh/kit - TypeScript Configuration Generator
+*
+* Auto-generates TypeScript configurations with alias path mappings.
+* Similar to Nuxt's .nuxt/tsconfig.json generation.
+*/
+/**
+* Generate tsconfig.json content for .kimesh directory
+*
+* This generates a tsconfig that can be extended by the project's tsconfig.json,
+* providing automatic TypeScript support for all aliases.
+*
+* @param options - Generation options
+* @returns TSConfig JSON object
+*/
+function generateTsConfig(options) {
+	const { rootDir, srcDir, buildDir, aliases, layerAliases = {}, moduleAliases = {}, internalAliases = {}, include = ["../src/**/*", "./**/*"], exclude = ["../node_modules"] } = options;
+	const allAliases = {
+		...aliases,
+		...layerAliases,
+		...moduleAliases,
+		...internalAliases
+	};
+	const paths = {};
+	for (const [alias, absolutePath] of Object.entries(allAliases)) {
+		const relativePath = relative(buildDir, absolutePath);
+		const normalizedPath = relativePath.startsWith("..") ? relativePath : "./" + relativePath;
+		paths[alias] = [normalizedPath];
+		paths[`${alias}/*`] = [`${normalizedPath}/*`];
+	}
+	return {
+		compilerOptions: {
+			target: "ESNext",
+			module: "ESNext",
+			moduleResolution: "bundler",
+			strict: true,
+			jsx: "preserve",
+			sourceMap: true,
+			resolveJsonModule: true,
+			esModuleInterop: true,
+			lib: ["ESNext", "DOM"],
+			skipLibCheck: true,
+			noEmit: true,
+			baseUrl: ".",
+			paths
+		},
+		include,
+		exclude
+	};
+}
+/**
+* Write generated tsconfig.json to .kimesh directory
+*
+* @param options - Generation options
+*/
+function writeTsConfig(options) {
+	const { buildDir } = options;
+	mkdirSync(buildDir, { recursive: true });
+	const tsconfig = generateTsConfig(options);
+	writeFileSync(join$1(buildDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2), "utf-8");
+}
+
+//#endregion
+//#region src/kit/phase2-utils.ts
+/**
+* @kimesh/kit - Phase 2 Configuration Utilities
+*
+* Utility functions for Phase 2 configuration options:
+* - Directory resolution (2.1)
+* - Build config defaults (2.2)
+* - Dev server config merging (2.3)
+* - TypeScript config extension (2.4)
+* - Watch pattern handling (2.5)
+*/
+/**
+* Default source directory
+*/
+const DEFAULT_SRC_DIR = "src";
+/**
+* Default build directory
+*/
+const DEFAULT_BUILD_DIR = ".kimesh";
+/**
+* Resolve all directory paths from configuration.
+*
+* @param config - Kimesh configuration
+* @param rootDir - Project root directory
+* @returns Resolved absolute paths for all directories
+*
+* @example
+* ```ts
+* const dirs = resolveDirectories(config, process.cwd())
+* console.log(dirs.srcDir)    // '/path/to/project/src'
+* console.log(dirs.buildDir)  // '/path/to/project/.kimesh'
+* ```
+*/
+function resolveDirectories(config, rootDir) {
+	const srcDirName = config.srcDir ?? DEFAULT_SRC_DIR;
+	const srcDir = isAbsolute$1(srcDirName) ? srcDirName : resolve$1(rootDir, srcDirName);
+	const buildDirName = config.buildDir ?? DEFAULT_BUILD_DIR;
+	const buildDir = isAbsolute$1(buildDirName) ? buildDirName : resolve$1(rootDir, buildDirName);
+	const dirConfig = {
+		assets: config.dir?.assets ?? "assets",
+		plugins: config.dir?.plugins ?? "plugins",
+		public: config.dir?.public ?? "public",
+		shared: config.dir?.shared ?? "shared"
+	};
+	return {
+		rootDir,
+		srcDir,
+		buildDir,
+		assetsDir: resolve$1(srcDir, dirConfig.assets),
+		pluginsDir: resolve$1(srcDir, dirConfig.plugins),
+		sharedDir: resolve$1(srcDir, dirConfig.shared),
+		publicDir: resolve$1(rootDir, dirConfig.public)
+	};
+}
+/**
+* Normalize analyze configuration to consistent object format.
+*
+* @param analyze - Build analyze config (boolean or object)
+* @returns Normalized analyze config object
+*
+* @example
+* ```ts
+* normalizeAnalyzeConfig(true)  // { enabled: true, openAnalyzer: false, reportFilename: 'report.html' }
+* normalizeAnalyzeConfig(false) // { enabled: false, openAnalyzer: false, reportFilename: 'report.html' }
+* ```
+*/
+function normalizeAnalyzeConfig(analyze) {
+	if (typeof analyze === "boolean") return {
+		enabled: analyze,
+		openAnalyzer: false,
+		reportFilename: "report.html"
+	};
+	return {
+		enabled: analyze?.enabled ?? false,
+		openAnalyzer: analyze?.openAnalyzer ?? false,
+		reportFilename: analyze?.reportFilename ?? "report.html"
+	};
+}
+/**
+* Resolve build configuration with defaults.
+*
+* @param config - Build configuration
+* @returns Resolved build config with all defaults applied
+*
+* @example
+* ```ts
+* const buildConfig = resolveBuildConfig({ analyze: true })
+* console.log(buildConfig.target) // 'esnext'
+* ```
+*/
+function resolveBuildConfig(config) {
+	return {
+		analyze: normalizeAnalyzeConfig(config?.analyze),
+		sourcemap: config?.sourcemap ?? false,
+		target: config?.target ?? "esnext",
+		minify: config?.minify ?? "esbuild"
+	};
+}
+/**
+* Normalize HTTPS configuration.
+*
+* @param https - HTTPS config (boolean or object)
+* @returns Normalized HTTPS config
+*/
+function normalizeHttpsConfig(https) {
+	if (typeof https === "boolean") return { enabled: https };
+	if (https) return {
+		enabled: true,
+		key: https.key,
+		cert: https.cert
+	};
+	return { enabled: false };
+}
+/**
+* Normalize CORS configuration.
+*
+* @param cors - CORS config (boolean or object)
+* @returns Normalized CORS config
+*/
+function normalizeCorsConfig(cors) {
+	if (typeof cors === "boolean") return {
+		enabled: cors,
+		origin: cors ? "*" : void 0
+	};
+	if (cors) return {
+		enabled: true,
+		origin: cors.origin,
+		methods: cors.methods,
+		allowedHeaders: cors.allowedHeaders,
+		exposedHeaders: cors.exposedHeaders,
+		credentials: cors.credentials,
+		maxAge: cors.maxAge
+	};
+	return { enabled: false };
+}
+/**
+* Resolve dev server configuration with defaults.
+*
+* @param config - Dev server configuration
+* @returns Resolved dev config with all defaults applied
+*/
+function resolveDevConfig(config) {
+	return {
+		port: config?.port ?? 3e3,
+		host: config?.host ?? "localhost",
+		open: config?.open ?? false,
+		https: normalizeHttpsConfig(config?.https),
+		proxy: config?.proxy ?? {},
+		cors: normalizeCorsConfig(config?.cors),
+		strictPort: config?.strictPort ?? false
+	};
+}
+/**
+* Resolve watch configuration with defaults.
+*
+* @param watch - Watch patterns array
+* @param watchers - Watchers configuration
+* @returns Resolved watch config
+*/
+function resolveWatchConfig(watch, watchers) {
+	return {
+		patterns: watch ?? [],
+		chokidar: watchers?.chokidar ?? {}
+	};
+}
+/**
+* Merge chokidar options with defaults.
+*
+* @param options - User-provided chokidar options
+* @returns Merged chokidar options
+*/
+function mergeChokidarOptions(options) {
+	return defu(options ?? {}, {
+		persistent: true,
+		usePolling: false,
+		interval: 100,
+		binaryInterval: 300,
+		atomic: false
+	});
+}
+/**
+* Convert watch config to Vite watch options.
+*
+* @param config - Resolved watch configuration
+* @returns Vite-compatible watch options
+*/
+function toViteWatchOptions(config) {
+	const merged = mergeChokidarOptions(config.chokidar);
+	return {
+		usePolling: merged.usePolling,
+		interval: merged.interval,
+		binaryInterval: merged.binaryInterval,
+		ignored: merged.ignored
+	};
+}
+
+//#endregion
+//#region src/vite/entry.ts
+/**
+* Generate the entry point code for a Kimesh app
+*/
+function generateEntryCode(options) {
+	const { hasContext, hasPlugins: hasPlugins$1 } = options;
+	const imports = [
+		`import { createKimeshApp } from '@kimesh/router-runtime'`,
+		`import { routes } from '#kimesh/routes'`,
+		`import App from '#kimesh/app'`
+	];
+	if (hasContext) imports.push(`import createContext from '#kimesh/context'`);
+	if (hasPlugins$1) imports.push(`import { plugins } from '#kimesh/plugins'`);
+	const optionLines = [`  runtimeConfig: __KIMESH_CONFIG__,`, `  layersConfig: __KIMESH_LAYERS_CONFIG__,`];
+	if (hasContext) optionLines.push(`  context: createContext(),`);
+	if (hasPlugins$1) optionLines.push(`  plugins,`);
+	const optionsBlock = `\n${optionLines.join("\n")}`;
+	return `${imports.join("\n")}
+
+declare const __KIMESH_CONFIG__: Record<string, unknown>
+declare const __KIMESH_LAYERS_CONFIG__: Record<string, Record<string, unknown>>
+
+async function bootstrap() {
+  const app = await createKimeshApp({
+    rootComponent: App,
+    routes,${optionsBlock}
+  })
+
+  app.mount('#app')
+}
+
+bootstrap()
+`;
+}
+/**
+* Generate context type declaration file for host app
+*/
+function generateContextTypes() {
+	return `/* eslint-disable */
+/* prettier-ignore */
+// Auto-generated by @kimesh/kit
+// Do not edit this file manually
+
+import type { AppContext } from '../src/app.context'
+
+declare module '@kimesh/router-runtime' {
+  interface KimeshContext extends AppContext {}
+}
+
+export {}
+`;
+}
+/**
+* Generate context type declaration file for a layer
+* @param hostContextPath - Relative path from layer's .kimesh to host's app.context.ts
+*/
+function generateLayerContextTypes(hostContextPath) {
+	return `/* eslint-disable */
+/* prettier-ignore */
+// Auto-generated by @kimesh/kit
+// Do not edit this file manually
+
+import type { AppContext } from '${hostContextPath}'
+
+declare module '@kimesh/router-runtime' {
+  interface KimeshContext extends AppContext {}
+}
+
+export {}
+`;
+}
+
+//#endregion
+//#region src/vite/html.ts
+/**
+* Generate the HTML template for a Kimesh app
+*/
+function generateHtml(title) {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="/.kimesh/entry.ts"><\/script>
+</body>
+</html>`;
+}
+
+//#endregion
+//#region src/hmr/watcher.ts
+/**
+* Create HMR watcher for Kimesh layers
+*/
+function createHMRWatcher(options) {
+	const { server, layers, debug: debug$1 } = options;
+	const log = (...args) => {
+		if (debug$1) consola.debug("[kimesh:hmr]", ...args);
+	};
+	/**
+	* Detect which layer a file belongs to
+	*/
+	function detectLayer(filePath) {
+		const sortedLayers = [...layers].sort((a, b) => b.path.length - a.path.length);
+		for (const layer of sortedLayers) if (filePath.startsWith(layer.path)) return layer;
+	}
+	/**
+	* Check if path contains a directory segment (cross-platform)
+	*/
+	function pathContains(filePath, segment) {
+		return filePath.includes(`/${segment}/`) || filePath.includes(`\\${segment}\\`);
+	}
+	/**
+	* Detect file category based on path
+	*/
+	function detectCategory(filePath) {
+		if (pathContains(filePath, "routes")) return "route";
+		if (pathContains(filePath, "components")) return "component";
+		if (pathContains(filePath, "composables")) return "composable";
+		if (filePath.includes("kimesh.config")) return "config";
+		return "other";
+	}
+	/**
+	* Handle file change
+	*/
+	async function handleChange(file, type) {
+		const startTime = performance.now();
+		const layer = detectLayer(file);
+		const category = detectCategory(file);
+		const context = {
+			file,
+			type,
+			layer,
+			category
+		};
+		log(`File ${type}: ${file}`, layer ? `[${layer.name}]` : "[app]", `(${category})`);
+		switch (category) {
+			case "route":
+				await handleRouteChange(context);
+				break;
+			case "component":
+				await handleComponentChange(context);
+				break;
+			case "composable":
+				await handleComposableChange(context);
+				break;
+			case "config":
+				await handleConfigChange(context);
+				break;
+			default: break;
+		}
+		log(`HMR handled in ${(performance.now() - startTime).toFixed(1)}ms`);
+	}
+	/**
+	* Handle route file change
+	*/
+	async function handleRouteChange(context) {
+		const routesModule = server.moduleGraph.getModuleById("\0virtual:kimesh-routes");
+		if (routesModule) {
+			server.moduleGraph.invalidateModule(routesModule);
+			log("Invalidated virtual:kimesh-routes");
+		}
+		if (context.type === "add" || context.type === "unlink") {
+			server.ws.send({
+				type: "full-reload",
+				path: "*"
+			});
+			log("Triggered full reload for route structure change");
+		} else {
+			const module = server.moduleGraph.getModuleById(context.file);
+			if (module) {
+				server.moduleGraph.invalidateModule(module);
+				server.ws.send({
+					type: "update",
+					updates: [{
+						type: "js-update",
+						path: context.file,
+						acceptedPath: context.file,
+						timestamp: Date.now()
+					}]
+				});
+			}
+		}
+	}
+	/**
+	* Handle component file change
+	*/
+	async function handleComponentChange(context) {
+		if (context.type === "add" || context.type === "unlink") {
+			const autoImportModule = server.moduleGraph.getModuleById("\0virtual:kimesh-auto-imports");
+			if (autoImportModule) {
+				server.moduleGraph.invalidateModule(autoImportModule);
+				log("Invalidated auto-import registry for component change");
+			}
+		}
+	}
+	/**
+	* Handle composable file change
+	*/
+	async function handleComposableChange(context) {
+		const module = server.moduleGraph.getModuleById(context.file);
+		if (module) {
+			const importers = collectImporters(module);
+			for (const importer of importers) server.moduleGraph.invalidateModule(importer);
+			server.moduleGraph.invalidateModule(module);
+			log(`Invalidated ${importers.size + 1} modules for composable change`);
+			server.ws.send({
+				type: "update",
+				updates: Array.from(importers).map((m) => ({
+					type: "js-update",
+					path: m.file,
+					acceptedPath: m.file,
+					timestamp: Date.now()
+				}))
+			});
+		}
+		if (context.type === "add" || context.type === "unlink") {
+			const autoImportModule = server.moduleGraph.getModuleById("\0virtual:kimesh-auto-imports");
+			if (autoImportModule) server.moduleGraph.invalidateModule(autoImportModule);
+		}
+	}
+	/**
+	* Handle config file change
+	*/
+	async function handleConfigChange(context) {
+		consola.info(`[kimesh] Config changed${context.layer ? ` in ${context.layer.name}` : ""}, restart required`);
+		server.ws.send({
+			type: "full-reload",
+			path: "*"
+		});
+	}
+	/**
+	* Collect all modules that import a given module (recursive)
+	*/
+	function collectImporters(module, seen = /* @__PURE__ */ new Set()) {
+		const importers = /* @__PURE__ */ new Set();
+		for (const importer of module.importers) if (!seen.has(importer)) {
+			seen.add(importer);
+			importers.add(importer);
+			const nestedImporters = collectImporters(importer, seen);
+			for (const nested of nestedImporters) importers.add(nested);
+		}
+		return importers;
+	}
+	return {
+		handleChange,
+		detectLayer,
+		detectCategory
+	};
+}
+
+//#endregion
+//#region src/errors/formatter.ts
+/**
+* @kimesh/kit - Error Formatter
+*
+* Enhanced error messages with layer context and suggestions.
+*/
+/**
+* Format an error with layer context
+*/
+function formatError(error, context) {
+	const title = pc.red(pc.bold(`✖ ${error.name || "Error"}`));
+	let message = error.message;
+	let location;
+	const suggestions = [];
+	if (context?.file) {
+		const layerInfo = context.layer ? pc.dim(` [${context.layer.name}]`) : "";
+		if (context.line) location = pc.cyan(`${context.file}:${context.line}${context.column ? `:${context.column}` : ""}`) + layerInfo;
+		else location = pc.cyan(context.file) + layerInfo;
+	}
+	if (error.message.includes("Cannot find module")) {
+		suggestions.push("Check if the import path is correct");
+		suggestions.push("Ensure the dependency is installed");
+		if (context?.layer) suggestions.push(`Try using the layer alias: #${context.layer.name}/...`);
+	}
+	if (error.message.includes("is not defined")) {
+		suggestions.push("Add the missing import or ensure auto-import is enabled");
+		suggestions.push("Check if the export exists in the source file");
+	}
+	if (error.message.includes("Duplicate route")) {
+		suggestions.push("Routes in the app take precedence over layer routes");
+		suggestions.push("Use a different path or remove the conflicting route");
+	}
+	let formatted = `\n${title}\n`;
+	if (location) formatted += `\n${pc.dim("Location:")} ${location}\n`;
+	formatted += `\n${message}\n`;
+	if (context?.snippet) formatted += `\n${pc.dim("Code:")}\n${context.snippet}\n`;
+	if (suggestions.length > 0) {
+		formatted += `\n${pc.yellow("Suggestions:")}\n`;
+		for (const suggestion of suggestions) formatted += `  ${pc.dim("•")} ${suggestion}\n`;
+	}
+	return {
+		title: error.name || "Error",
+		message,
+		location,
+		suggestions: suggestions.length > 0 ? suggestions : void 0,
+		formatted
+	};
+}
+/**
+* Format a warning message
+*/
+function formatWarning(message, context) {
+	let output = pc.yellow(pc.bold("⚠ Warning"));
+	if (context?.layer) output += pc.dim(` [${context.layer.name}]`);
+	output += `\n${message}`;
+	if (context?.file) output += pc.dim(`\n  at ${context.file}`);
+	return output;
+}
+/**
+* Get suggestions for resolving a conflict based on type
+*/
+function getConflictSuggestions(type, name, winner) {
+	if (type === "route") return ["Use different route paths", "Configure basePath in layer config"];
+	return [`Use prefixed imports: ${name} → ${winner}${capitalize(name)}`, `Add prefix in layer config: components.prefix: '${capitalize(winner)}'`];
+}
+/**
+* Format a conflict warning
+*/
+function formatConflictWarning(type, name, sources, winner) {
+	let output = pc.yellow(pc.bold(`⚠ ${capitalize(type)} Conflict`));
+	output += `\n\n${pc.bold(name)} is defined in multiple layers:\n`;
+	for (const source of sources) {
+		const isWinner = source.layer === winner;
+		const marker = isWinner ? pc.green("✓") : pc.dim("○");
+		const layerName = isWinner ? pc.green(source.layer) : pc.dim(source.layer);
+		output += `  ${marker} ${layerName}\n`;
+		output += pc.dim(`    ${source.path}\n`);
+	}
+	output += `\n${pc.dim("Using:")} ${pc.green(winner)} (highest priority)\n`;
+	output += `\n${pc.yellow("Suggestions:")}\n`;
+	for (const suggestion of getConflictSuggestions(type, name, winner)) output += `  ${pc.dim("•")} ${suggestion}\n`;
+	return output;
+}
+/**
+* Format timing info for debug
+*/
+function formatTiming(operation, timeMs, details) {
+	const color = timeMs < 50 ? pc.green : timeMs < 200 ? pc.yellow : pc.red;
+	let output = `${pc.dim("[timing]")} ${operation}: ${color(`${timeMs.toFixed(1)}ms`)}`;
+	if (details) {
+		const detailStr = Object.entries(details).map(([k, v]) => `${k}=${v}`).join(", ");
+		output += pc.dim(` (${detailStr})`);
+	}
+	return output;
+}
+/**
+* Create a timing logger
+*/
+function createTimer(operation, debug$1 = false) {
+	const start = performance.now();
+	return { end(details) {
+		const elapsed = performance.now() - start;
+		if (debug$1) console.log(formatTiming(operation, elapsed, details));
+		return elapsed;
+	} };
+}
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+//#region src/vite/plugin.ts
+/**
+* Find workspace root by traversing up and looking for workspaces config
+*/
+function findWorkspaceRoot(startDir) {
+	let current = startDir;
+	for (let i = 0; i < 10; i++) {
+		const pkgPath = join$1(current, "package.json");
+		if (existsSync(pkgPath)) try {
+			if (JSON.parse(readFileSync(pkgPath, "utf-8")).workspaces || existsSync(join$1(current, "pnpm-workspace.yaml"))) return current;
+		} catch {}
+		const parent = resolve$1(current, "..");
+		if (parent === current) break;
+		current = parent;
+	}
+	return startDir;
+}
+/**
+* Process all configured modules using the new v2 system
+*/
+async function processModules(kimesh, debug$1) {
+	const modules = kimesh.options.config.modules;
+	if (!modules || modules.length === 0) return;
+	const moduleTimer = createTimer("Module processing", debug$1);
+	try {
+		await executeModules(modules, kimesh);
+		moduleTimer.end({ count: modules.length });
+	} catch (error) {
+		moduleTimer.end({ error: true });
+		consola.error("[Kimesh] Module processing failed:", error);
+	}
+}
+/**
+* Extract module names from config (filters out inline module objects)
+*/
+function extractModuleNames$1(modules) {
+	if (!modules) return [];
+	const names = [];
+	for (const mod of modules) if (typeof mod === "string") names.push(mod);
+	else if (Array.isArray(mod) && typeof mod[0] === "string") names.push(mod[0]);
+	return names;
+}
+/**
+* Generate modules.ts that imports all configured modules
+* AND references their augment.d.ts files for type declarations
+*/
+function generateModulesTypeDeclaration(modules, buildDir) {
+	const moduleNames = extractModuleNames$1(modules);
+	if (moduleNames.length === 0) return;
+	const imports = moduleNames.map((name) => `import "${name}";`).join("\n");
+	const content = `/**
+ * Module type declarations - Auto-generated by Kimesh
+ * This file imports all modules to enable their type augmentations.
+ *
+ * DO NOT EDIT - This file is regenerated when modules change.
+ */
+
+${moduleNames.map((name) => `/// <reference path="../node_modules/${name}/augment.d.ts" />`).join("\n")}
+
+${imports}
+`;
+	mkdirSync(buildDir, { recursive: true });
+	writeFileSync(join$1(buildDir, "modules.ts"), content, "utf-8");
+}
+/**
+* Kimesh Vite plugin
+* Sets up Vue with Vite 8 + Rolldown + File-based routing + Layers + Auto-Import
+*/
+function kimeshPlugin(options = {}) {
+	const config = options.config || {};
+	const debug$1 = options.debug ?? false;
+	const { plugins: userPlugins = [], ...userViteOptions } = config.vite || {};
+	const allUserPlugins = [...userPlugins, ...options.additionalPlugins || []];
+	const state = {
+		resolvedLayers: [],
+		root: "",
+		generatedDir: "",
+		kimesh: null,
+		hasPlugins: false
+	};
+	const layersConfig = {
+		enabled: options.layers?.enabled ?? config.layers?.enabled ?? "all",
+		excluded: options.layers?.excluded ?? config.layers?.excluded ?? []
+	};
+	const mainPlugin = {
+		name: "kimesh:main",
+		enforce: "pre",
+		async config(viteConfig, { command, mode }) {
+			consola.debug(`[Kimesh] Configuring for ${command} mode`);
+			const configRoot = viteConfig.root || process.cwd();
+			state.root = configRoot;
+			const resolvedDirs = resolveDirectories(config, configRoot);
+			state.generatedDir = resolvedDirs.buildDir;
+			const resolvedBuildConfig = resolveBuildConfig(config.build);
+			const resolvedDevConfig = resolveDevConfig(config.dev);
+			const resolvedWatchConfig = resolveWatchConfig(config.watch, config.watchers);
+			if (debug$1) {
+				consola.info(`[Kimesh] Resolved directories:`);
+				consola.info(`  - srcDir: ${resolvedDirs.srcDir}`);
+				consola.info(`  - buildDir: ${resolvedDirs.buildDir}`);
+				consola.info(`  - pluginsDir: ${resolvedDirs.pluginsDir}`);
+			}
+			const envVars = loadEnv(mode, configRoot, "KIMESH_");
+			const layerTimer = createTimer("Layer resolution", debug$1);
+			try {
+				state.resolvedLayers = await prepareLayers$1(configRoot, {
+					enabled: layersConfig.enabled,
+					excluded: layersConfig.excluded
+				});
+				layerTimer.end({ count: state.resolvedLayers.length });
+				if (debug$1 || state.resolvedLayers.length > 1) {
+					consola.info(`[Kimesh] Resolved ${state.resolvedLayers.length} layers:`);
+					for (const layer of state.resolvedLayers) consola.info(`  - ${layer.name} (priority: ${layer.priority}, path: ${layer.path})`);
+				}
+			} catch (error) {
+				layerTimer.end({ error: true });
+				consola.warn(`[Kimesh] Layer resolution failed: ${error}`);
+				state.resolvedLayers = [];
+			}
+			const layerAliases = generateLayerAliases$1(state.resolvedLayers);
+			state.kimesh = createKimesh({
+				config,
+				layers: state.resolvedLayers,
+				root: configRoot,
+				buildDir: state.generatedDir,
+				dev: command === "serve"
+			});
+			await processModules(state.kimesh, debug$1);
+			if (config.app?.head) {
+				const headPluginSrc = "@kimesh/head/plugin";
+				if (!state.kimesh._registries.runtimePlugins.some((p) => p.src === headPluginSrc)) {
+					state.kimesh._registries.runtimePlugins.unshift({
+						src: headPluginSrc,
+						name: "head"
+					});
+					if (debug$1) consola.info("[Kimesh] Auto-registered @kimesh/head plugin (app.head configured)");
+				}
+			}
+			let discoveredPlugins = await scanPluginsDir(resolvedDirs.pluginsDir);
+			for (const layer of state.resolvedLayers) {
+				const layerPlugins = await scanPluginsDir(join$1(layer.path, "src", "plugins"));
+				discoveredPlugins = discoveredPlugins.concat(layerPlugins);
+			}
+			const hasRegisteredPlugins = state.kimesh._registries.runtimePlugins.length > 0;
+			state.hasPlugins = discoveredPlugins.length > 0 || hasRegisteredPlugins;
+			if (state.hasPlugins) {
+				addPluginsTemplate(state.kimesh, discoveredPlugins);
+				if (debug$1) {
+					consola.info(`[Kimesh] Found ${discoveredPlugins.length} auto-discovered plugins`);
+					consola.info(`[Kimesh] Found ${state.kimesh._registries.runtimePlugins.length} module-registered plugins`);
+				}
+			}
+			generateModulesTypeDeclaration(config.modules, state.generatedDir);
+			await writeTemplates(state.kimesh);
+			const userAliases = buildAliases(config, resolvedDirs.srcDir, configRoot);
+			const moduleAliases = {};
+			for (const alias of state.kimesh._registries.aliases) if (typeof alias.find === "string") moduleAliases[alias.find] = alias.replacement;
+			const appVuePath = resolve$1(resolvedDirs.srcDir, "app.vue");
+			const internalAliases = {
+				"#kimesh/routes": join$1(resolvedDirs.buildDir, "routes.gen.ts"),
+				"#kimesh/app": existsSync(appVuePath) ? appVuePath : "@kimesh/router-runtime/default-app",
+				"#kimesh/context": join$1(resolvedDirs.srcDir, "app.context.ts"),
+				"#kimesh/plugins": join$1(resolvedDirs.buildDir, "plugins.mjs")
+			};
+			writeTsConfig({
+				rootDir: configRoot,
+				srcDir: resolvedDirs.srcDir,
+				buildDir: state.generatedDir,
+				aliases: userAliases,
+				layerAliases,
+				moduleAliases,
+				internalAliases,
+				include: [
+					"../src/**/*",
+					"./**/*",
+					"../kimesh.config.ts"
+				],
+				exclude: ["../node_modules"]
+			});
+			if (debug$1) consola.info(`[Kimesh] Generated .kimesh/tsconfig.json with ${Object.keys(userAliases).length} aliases`);
+			const layerDirs = state.resolvedLayers.map((layer) => layer.path);
+			const workspaceRoot = findWorkspaceRoot(configRoot);
+			const workspacePackages = resolve$1(workspaceRoot, "packages");
+			const nodeModules = resolve$1(workspaceRoot, "node_modules");
+			if (command === "build") {
+				if (!existsSync(resolvedDirs.buildDir)) mkdirSync(resolvedDirs.buildDir, { recursive: true });
+				writeFileSync(join$1(resolvedDirs.buildDir, "index.html"), generateHtml(config.name || "Kimesh App"), "utf-8");
+				const hasContext = existsSync(join$1(resolvedDirs.srcDir, "app.context.ts"));
+				writeFileSync(join$1(resolvedDirs.buildDir, "entry.ts"), generateEntryCode({
+					hasContext,
+					hasPlugins: state.hasPlugins
+				}), "utf-8");
+				if (hasContext) writeFileSync(join$1(resolvedDirs.buildDir, "context.d.ts"), generateContextTypes(), "utf-8");
+			}
+			const layerRuntimeConfigs = state.resolvedLayers.slice().sort((a, b) => b.priority - a.priority).map((layer) => layer.runtimeConfig).filter(Boolean);
+			const processedRuntimeConfig = applyEnv(defu(config.runtimeConfig || createDefaultRuntimeConfig(), ...layerRuntimeConfigs), { env: envVars });
+			const layerConfigMap = {};
+			for (const layer of state.resolvedLayers) if (layer.runtimeConfig) layerConfigMap[layer.name] = layer.runtimeConfig;
+			return mergeConfig({
+				define: {
+					__KIMESH_DEV__: command === "serve",
+					__KIMESH_NAME__: JSON.stringify(config.name || "kimesh-app"),
+					__KIMESH_LAYERS__: JSON.stringify(state.resolvedLayers.map((l) => l.name)),
+					__KIMESH_CONFIG__: JSON.stringify(processedRuntimeConfig),
+					__KIMESH_LAYERS_CONFIG__: JSON.stringify(layerConfigMap)
+				},
+				resolve: { alias: {
+					"#kimesh/routes": join$1(resolvedDirs.buildDir, "routes.gen.ts"),
+					"#kimesh/app": existsSync(appVuePath) ? appVuePath : "@kimesh/router-runtime/default-app",
+					"#kimesh/context": join$1(resolvedDirs.srcDir, "app.context.ts"),
+					"#kimesh/plugins": join$1(resolvedDirs.buildDir, "plugins.mjs"),
+					...userAliases,
+					...layerAliases,
+					...moduleAliases
+				} },
+				server: {
+					port: resolvedDevConfig.port,
+					host: resolvedDevConfig.host,
+					open: resolvedDevConfig.open,
+					strictPort: resolvedDevConfig.strictPort,
+					fs: { allow: [
+						configRoot,
+						...layerDirs,
+						workspaceRoot,
+						workspacePackages,
+						nodeModules
+					] },
+					watch: toViteWatchOptions(resolvedWatchConfig)
+				},
+				build: {
+					target: resolvedBuildConfig.target,
+					sourcemap: resolvedBuildConfig.sourcemap,
+					minify: resolvedBuildConfig.minify,
+					rollupOptions: command === "build" ? { input: join$1(resolvedDirs.buildDir, "index.html") } : void 0
+				}
+			}, userViteOptions);
+		},
+		configResolved(resolvedConfig) {
+			state.root = resolvedConfig.root;
+			state.generatedDir = resolveDirectories(config, state.root).buildDir;
+			consola.debug(`[Kimesh] Config resolved, mode: ${resolvedConfig.mode}`);
+		},
+		async buildStart() {
+			if (!existsSync(state.generatedDir)) mkdirSync(state.generatedDir, { recursive: true });
+			const contextPath = join$1(state.root, "src", "app.context.ts");
+			const hasContext = existsSync(contextPath);
+			const entryPath = join$1(state.generatedDir, "entry.ts");
+			writeFileSync(entryPath, generateEntryCode({
+				hasContext,
+				hasPlugins: state.hasPlugins
+			}), "utf-8");
+			consola.debug(`[Kimesh] Generated entry file: ${entryPath}`);
+			if (hasContext) {
+				const contextTypesPath = join$1(state.generatedDir, "context.d.ts");
+				writeFileSync(contextTypesPath, generateContextTypes(), "utf-8");
+				consola.debug(`[Kimesh] Generated context types: ${contextTypesPath}`);
+				for (const layer of state.resolvedLayers) {
+					if (layer.isApp) continue;
+					let layerRoot = layer.path;
+					try {
+						layerRoot = realpathSync(layer.path);
+					} catch {}
+					const layerKimeshDir = join$1(layerRoot, ".kimesh");
+					if (!existsSync(layerKimeshDir)) mkdirSync(layerKimeshDir, { recursive: true });
+					const hostContextPath = relative(layerKimeshDir, contextPath).replace(/\.ts$/, "");
+					const layerContextTypesPath = join$1(layerKimeshDir, "context.d.ts");
+					writeFileSync(layerContextTypesPath, generateLayerContextTypes(hostContextPath), "utf-8");
+					consola.debug(`[Kimesh] Generated layer context types: ${layerContextTypesPath}`);
+				}
+			}
+			const htmlPath = join$1(state.generatedDir, "index.html");
+			writeFileSync(htmlPath, generateHtml(config.name || "Kimesh App"), "utf-8");
+			consola.debug(`[Kimesh] Generated HTML file: ${htmlPath}`);
+		},
+		configureServer(server) {
+			const hmrWatcher = createHMRWatcher({
+				server,
+				layers: state.resolvedLayers,
+				debug: debug$1
+			});
+			for (const layer of state.resolvedLayers) if (!layer.isApp) {
+				server.watcher.add(layer.path);
+				consola.debug(`[Kimesh] Watching layer: ${layer.name}`);
+			}
+			const handleWatchEvent = (event) => (file) => {
+				const layer = hmrWatcher.detectLayer(file);
+				if (layer && !layer.isApp) hmrWatcher.handleChange(file, event);
+			};
+			server.watcher.on("change", handleWatchEvent("change"));
+			server.watcher.on("add", handleWatchEvent("add"));
+			server.watcher.on("unlink", handleWatchEvent("unlink"));
+			server.middlewares.use(async (req, res, next) => {
+				const url = req.url || "/";
+				if (url.includes(".") || url.startsWith("/@") || url.startsWith("/__") || url.startsWith("/node_modules")) return next();
+				try {
+					const html = readFileSync(join$1(state.generatedDir, "index.html"), "utf-8");
+					const transformed = await server.transformIndexHtml(url, html);
+					res.setHeader("Content-Type", "text/html");
+					res.end(transformed);
+				} catch (e) {
+					next(e);
+				}
+			});
+		}
+	};
+	const routerPlugin = kimeshRouterGenerator({
+		routesDir: config.router?.routesDir ?? "routes",
+		importMode: config.router?.importMode ?? "async",
+		debug: debug$1,
+		getLayerRoutes: () => {
+			return state.resolvedLayers.filter((l) => !l.isApp).map((layer) => {
+				const routesFolder = layer.config.routes?.folder || "routes";
+				const routesDir = join$1(layer.path, "src", routesFolder);
+				return {
+					layerName: layer.name,
+					routesDir,
+					layerPath: layer.path,
+					basePath: layer.config.routes?.basePath,
+					priority: layer.priority
+				};
+			});
+		}
+	});
+	const internalPlugins = [
+		mainPlugin,
+		kimeshAutoImport$1({
+			getSources: () => {
+				return state.resolvedLayers.map((layer) => ({
+					layer: layer.name,
+					priority: layer.priority,
+					layerPath: layer.path,
+					config: {
+						composables: { dirs: layer.config.composables?.dirs || ["composables"] },
+						components: {
+							dirs: layer.config.components?.dirs || ["components"],
+							prefix: layer.isApp ? void 0 : layer.config.components?.prefix
+						},
+						utils: { dirs: layer.config.utils?.dirs || ["utils"] },
+						stores: { dirs: layer.config.stores?.dirs || ["stores"] },
+						presets: layer.isApp ? config.autoImport?.presets || [
+							"vue",
+							"vue-router",
+							"kimesh"
+						] : void 0
+					}
+				}));
+			},
+			getLayers: () => {
+				return state.resolvedLayers.map((layer) => ({
+					name: layer.name,
+					path: layer.path,
+					isApp: layer.isApp
+				}));
+			},
+			dts: config.autoImport?.dts !== false ? state.generatedDir || ".kimesh" : false,
+			debug: debug$1
+		}),
+		vue(),
+		routerPlugin
+	];
+	const modulePluginsWrapper = {
+		name: "kimesh:module-plugins-wrapper",
+		async resolveId(id, importer, options$1) {
+			const modulePlugins = state.kimesh?._registries.vitePlugins ?? [];
+			for (const entry of modulePlugins) {
+				const plugin = entry.plugin;
+				if (typeof plugin.resolveId === "function") {
+					const result = await plugin.resolveId.call(this, id, importer, options$1);
+					if (result != null) return result;
+				}
+			}
+			return null;
+		},
+		async load(id, options$1) {
+			const modulePlugins = state.kimesh?._registries.vitePlugins ?? [];
+			for (const entry of modulePlugins) {
+				const plugin = entry.plugin;
+				if (typeof plugin.load === "function") {
+					const result = await plugin.load.call(this, id, options$1);
+					if (result != null) return result;
+				}
+			}
+			return null;
+		},
+		async transform(code, id, options$1) {
+			let currentCode = code;
+			const modulePlugins = state.kimesh?._registries.vitePlugins ?? [];
+			for (const entry of modulePlugins) {
+				const plugin = entry.plugin;
+				if (typeof plugin.transform === "function") {
+					const result = await plugin.transform.call(this, currentCode, id, options$1);
+					if (result != null) currentCode = typeof result === "string" ? result : result.code;
+				}
+			}
+			return currentCode !== code ? currentCode : null;
+		}
+	};
+	return [
+		...internalPlugins,
+		modulePluginsWrapper,
+		...allUserPlugins
+	];
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* Load kimesh.config.ts using c12
+*/
+async function loadConfig(options = {}) {
+	const { config, configFile } = await loadConfig$1({
+		name: "kimesh",
+		cwd: options.root || process.cwd(),
+		configFile: options.configFile,
+		defaultConfig: {
+			name: "kimesh-app",
+			dev: {
+				port: 3e3,
+				host: "localhost"
+			}
+		}
+	});
+	if (configFile) consola.debug(`[Kimesh] Config loaded from: ${configFile}`);
+	return config || {};
+}
+
+//#endregion
+//#region src/prepare.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.
+*/
+/**
+* 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() })
+* ```
+*/
+async function prepare(options = {}) {
+	const root = resolve$1(options.root || process.cwd());
+	const buildDir = join$1(root, ".kimesh");
+	const srcDir = join$1(root, "src");
+	const verbose = options.verbose ?? false;
+	const generatedFiles = [];
+	if (verbose) consola.info(`[Kimesh] Preparing project at ${root}`);
+	const config = await loadConfig({
+		root,
+		configFile: options.configFile
+	});
+	if (verbose) consola.info(`[Kimesh] Loaded config: ${config.name || "kimesh-app"}`);
+	if (!existsSync(buildDir)) mkdirSync(buildDir, { recursive: true });
+	let resolvedLayers = [];
+	try {
+		resolvedLayers = await prepareLayers$1(root, {
+			enabled: config.layers?.enabled ?? "all",
+			excluded: config.layers?.excluded ?? []
+		});
+		if (verbose) consola.info(`[Kimesh] Resolved ${resolvedLayers.length} layers`);
+	} catch (error) {
+		consola.warn(`[Kimesh] Layer resolution failed: ${error}`);
+	}
+	const layerAliases = generateLayerAliases$1(resolvedLayers);
+	const userAliases = buildAliases(config, srcDir, root);
+	const kimeshDir = resolve$1(root, ".kimesh");
+	const appVuePath = resolve$1(root, "src/app.vue");
+	const internalAliases = {
+		"#kimesh/routes": join$1(kimeshDir, "routes.gen.ts"),
+		"#kimesh/app": existsSync(appVuePath) ? appVuePath : "@kimesh/router-runtime/default-app",
+		"#kimesh/context": join$1(root, "src", "app.context.ts"),
+		"#kimesh/plugins": join$1(kimeshDir, "plugins.mjs")
+	};
+	writeTsConfig({
+		rootDir: root,
+		srcDir,
+		buildDir,
+		aliases: userAliases,
+		layerAliases,
+		moduleAliases: {},
+		internalAliases,
+		include: [
+			"../src/**/*",
+			"./**/*",
+			"../kimesh.config.ts"
+		],
+		exclude: ["../node_modules"]
+	});
+	generatedFiles.push("tsconfig.json");
+	if (verbose) consola.success(`[Kimesh] Generated .kimesh/tsconfig.json`);
+	const routesStubPath = join$1(buildDir, "routes.gen.ts");
+	if (!existsSync(routesStubPath)) {
+		writeFileSync(routesStubPath, `/**
+ * Kimesh Routes - Auto-generated
+ *
+ * This file is a stub generated by 'km prepare'.
+ * It will be populated with actual routes when running 'km dev' or 'km build'.
+ *
+ * DO NOT EDIT - This file is regenerated automatically.
+ */
+
+import type { RouteRecordRaw } from 'vue-router'
+
+export const routes: RouteRecordRaw[] = []
+`, "utf-8");
+		generatedFiles.push("routes.gen.ts");
+		if (verbose) consola.success(`[Kimesh] Generated .kimesh/routes.gen.ts (stub)`);
+	}
+	const pluginsStubPath = join$1(buildDir, "plugins.mjs");
+	if (!existsSync(pluginsStubPath)) {
+		writeFileSync(pluginsStubPath, `/**
+ * Kimesh Plugins - Auto-generated
+ *
+ * This file is a stub generated by 'km prepare'.
+ * It will be populated with actual plugins when running 'km dev' or 'km build'.
+ *
+ * DO NOT EDIT - This file is regenerated automatically.
+ */
+
+export default []
+`, "utf-8");
+		generatedFiles.push("plugins.mjs");
+		if (verbose) consola.success(`[Kimesh] Generated .kimesh/plugins.mjs (stub)`);
+	}
+	const modulesPath = join$1(buildDir, "modules.ts");
+	const moduleNames = extractModuleNames(config.modules);
+	if (moduleNames.length > 0) {
+		const imports = moduleNames.map((name) => `import "${name}";`).join("\n");
+		writeFileSync(modulesPath, `/**
+ * Module type declarations - Auto-generated by Kimesh
+ *
+ * DO NOT EDIT - This file is regenerated when modules change.
+ */
+
+${moduleNames.map((name) => `/// <reference path="../node_modules/${name}/augment.d.ts" />`).join("\n")}
+
+${imports}
+`, "utf-8");
+		generatedFiles.push("modules.ts");
+		if (verbose) consola.success(`[Kimesh] Generated .kimesh/modules.ts`);
+	}
+	if (existsSync(join$1(root, "src", "app.context.ts"))) {
+		writeFileSync(join$1(buildDir, "context.d.ts"), `/**
+ * Kimesh Context Types - Auto-generated
+ *
+ * DO NOT EDIT - This file is regenerated automatically.
+ */
+
+import type { AppContext as UserAppContext } from '../src/app.context'
+
+declare module '@kimesh/router-runtime' {
+  interface AppContext extends UserAppContext {}
+}
+`, "utf-8");
+		generatedFiles.push("context.d.ts");
+		if (verbose) consola.success(`[Kimesh] Generated .kimesh/context.d.ts`);
+	}
+	const autoImportsPath = join$1(buildDir, "auto-imports.d.ts");
+	if (!existsSync(autoImportsPath)) {
+		writeFileSync(autoImportsPath, `/**
+ * Kimesh Auto-Imports - Auto-generated
+ *
+ * This file is a stub generated by 'km prepare'.
+ * It will be populated with actual imports when running 'km dev' or 'km build'.
+ *
+ * DO NOT EDIT - This file is regenerated automatically.
+ */
+
+export {}
+
+declare global {
+  // Vue imports will be auto-detected
+  const ref: typeof import('vue')['ref']
+  const reactive: typeof import('vue')['reactive']
+  const computed: typeof import('vue')['computed']
+  const watch: typeof import('vue')['watch']
+  const watchEffect: typeof import('vue')['watchEffect']
+  const onMounted: typeof import('vue')['onMounted']
+  const onUnmounted: typeof import('vue')['onUnmounted']
+  const defineProps: typeof import('vue')['defineProps']
+  const defineEmits: typeof import('vue')['defineEmits']
+  const withDefaults: typeof import('vue')['withDefaults']
+
+  // Vue Router imports
+  const useRoute: typeof import('vue-router')['useRoute']
+  const useRouter: typeof import('vue-router')['useRouter']
+}
+`, "utf-8");
+		generatedFiles.push("auto-imports.d.ts");
+		if (verbose) consola.success(`[Kimesh] Generated .kimesh/auto-imports.d.ts (stub)`);
+	}
+	const componentsPath = join$1(buildDir, "components.d.ts");
+	if (!existsSync(componentsPath)) {
+		writeFileSync(componentsPath, `/**
+ * Kimesh Components - Auto-generated
+ *
+ * This file is a stub generated by 'km prepare'.
+ * It will be populated with actual components when running 'km dev' or 'km build'.
+ *
+ * DO NOT EDIT - This file is regenerated automatically.
+ */
+
+export {}
+
+declare module 'vue' {
+  export interface GlobalComponents {
+    // Component types will be populated by auto-import
+  }
+}
+`, "utf-8");
+		generatedFiles.push("components.d.ts");
+		if (verbose) consola.success(`[Kimesh] Generated .kimesh/components.d.ts (stub)`);
+	}
+	const aliasCount = Object.keys(userAliases).length + Object.keys(layerAliases).length + Object.keys(internalAliases).length;
+	return {
+		buildDir,
+		layerCount: resolvedLayers.length,
+		aliasCount,
+		generatedFiles
+	};
+}
+/**
+* Extract module names from config (filters out inline module objects)
+*/
+function extractModuleNames(modules) {
+	if (!modules) return [];
+	const names = [];
+	for (const mod of modules) if (typeof mod === "string") names.push(mod);
+	else if (Array.isArray(mod) && typeof mod[0] === "string") names.push(mod[0]);
+	return names;
+}
+
+//#endregion
+export { DEFAULT_ALIASES, DEFAULT_IGNORE_PATTERNS, 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.mjs.map