@kimesh/kit 0.2.23 → 0.2.24

package/dist/index.d.mts

@@ -613,6 +613,12 @@ interface KimeshViteConfig extends Omit<UserConfig, 'root' | 'configFile'> {
  * Default aliases provided by Kimesh.
  * Templates use placeholders: <srcDir>, <rootDir>
  * These are replaced at build time with actual paths.
+ *
+ * NOTE: `~` and `@` are NOT included here because they are handled by
+ * the layer-alias-plugin for context-aware resolution. The plugin resolves
+ * these aliases relative to the importing file's layer, not globally.
+ *
+ * @see packages/kit/src/vite/layer-alias-plugin.ts
  */
 declare const DEFAULT_ALIASES: Record<string, string>;
 /**
@@ -1146,7 +1152,11 @@ interface KimeshConfig extends KimeshModuleOptions {
    * 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" }
+   * NOTE: `~` and `@` are NOT included in default aliases. They are handled
+   * by layer-alias-plugin for context-aware resolution - resolving to the
+   * current layer's path, not the global host app path.
+   *
+   * @default { "~~": "/<rootDir>", "@@": "/<rootDir>", "#build": "/<rootDir>/.kimesh" }
    *
    * @example
    * ```ts

package/dist/index.mjs

@@ -8,7 +8,7 @@ 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, dirname as dirname$1, extname, isAbsolute as isAbsolute$1, join as join$1, relative, resolve as resolve$1 } from "pathe";
+import { basename, dirname as dirname$1, extname, isAbsolute as isAbsolute$1, join as join$1, normalize, relative, resolve as resolve$1 } from "pathe";
 import { resolveModulePath } from "exsolve";
 import ignore from "ignore";
 import pc from "picocolors";
@@ -1310,10 +1310,14 @@ function buildInternalAliasMap(buildDir) {
 * Default aliases provided by Kimesh.
 * Templates use placeholders: <srcDir>, <rootDir>
 * These are replaced at build time with actual paths.
+*
+* NOTE: `~` and `@` are NOT included here because they are handled by
+* the layer-alias-plugin for context-aware resolution. The plugin resolves
+* these aliases relative to the importing file's layer, not globally.
+*
+* @see packages/kit/src/vite/layer-alias-plugin.ts
 */
 const DEFAULT_ALIASES = {
-	"~": "<srcDir>",
-	"@": "<srcDir>",
 	"~~": "<rootDir>",
 	"@@": "<rootDir>",
 	"#build": "<rootDir>/.kimesh",
@@ -1974,6 +1978,54 @@ declare module '*?route' {
 `;
 }
 
+//#endregion
+//#region src/vite/module-types-generator.ts
+/**
+* @kimesh/kit - Module Types Generation
+*
+* Generates modules.ts for type augmentation from configured modules.
+* Extracted from plugin.ts for better maintainability.
+*/
+/**
+* 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;
+}
+/**
+* Generate modules.ts that imports all configured modules
+* AND references their augment.d.ts files for type declarations
+*/
+function generateModulesTypeDeclaration(modules, buildDir, rootDir) {
+	const moduleNames = extractModuleNames(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) => {
+		const pkgDir = resolvePackageDir(name, rootDir);
+		if (pkgDir) {
+			const relativePath = relative(buildDir, pkgDir);
+			return `/// <reference path="${relativePath.startsWith("..") ? relativePath : "./" + relativePath}/augment.d.ts" />`;
+		}
+		return `/// <reference path="../node_modules/${name}/augment.d.ts" />`;
+	}).join("\n")}
+
+${imports}
+`;
+	mkdirSync(buildDir, { recursive: true });
+	writeFileSync(join$1(buildDir, "modules.ts"), content, "utf-8");
+}
+
 //#endregion
 //#region src/kit/phase2-utils.ts
 /**
@@ -2538,31 +2590,267 @@ function capitalize(str) {
 }
 
 //#endregion
-//#region src/vite/plugin.ts
+//#region src/vite/layer-alias-plugin.ts
 /**
-* Find workspace root by traversing up and looking for workspaces config
+* @kimesh/kit - Context-Aware Layer Alias Plugin
+*
+* This Vite plugin intercepts `~/` and `@/` alias resolution and resolves them
+* relative to the **importing file's layer** instead of globally to the host app.
+*
+* Problem it solves:
+* ```typescript
+* // In layer: 1s-km/apps/remotes/okr/src/routes/okr.vue
+* import OkrSidebar from '~/components/okr-sidebar/OkrSidebar.vue'
+* // Without this plugin: Resolves to 1s-km/apps/host/src/components/... ❌
+* // With this plugin: Resolves to 1s-km/apps/remotes/okr/src/components/... ✅
+* ```
+*
+* Resolution rules:
+* - `~` → layer root path (e.g., `/path/to/layer`)
+* - `@` → layer source path (e.g., `/path/to/layer/src` or layer root if no src)
+* - Falls back to app/host layer if file is not in any layer
 */
-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;
+/**
+* Cache for resolved real paths to avoid repeated syscalls
+*/
+const realPathCache = /* @__PURE__ */ new Map();
+/**
+* Get the real path (resolving symlinks) with caching
+*/
+function getRealPath(filePath) {
+	const cached = realPathCache.get(filePath);
+	if (cached !== void 0) return cached;
+	try {
+		const realPath = realpathSync(filePath);
+		realPathCache.set(filePath, realPath);
+		return realPath;
+	} catch {
+		realPathCache.set(filePath, filePath);
+		return filePath;
 	}
-	return startDir;
 }
 /**
-* Try to resolve a package or subpath export using exsolve.
-* This handles various package manager layouts (npm, pnpm, bun, yarn)
-* and properly resolves subpath exports like "@kimesh/head/plugin"
+* Strip any virtual module prefixes from the file path
+* Handles cases like '\0kimesh-route:' prefix added by router generator
+* Note: Vite uses \0 prefix to mark virtual modules internally
+*/
+function stripVirtualPrefixes(filePath) {
+	let result = filePath;
+	if (result.charCodeAt(0) === 0 || result.startsWith("\0")) result = result.slice(1);
+	const kimeshRouteIdx = result.indexOf("kimesh-route:");
+	if (kimeshRouteIdx !== -1 && kimeshRouteIdx <= 1) result = result.slice(kimeshRouteIdx + 13);
+	if (result.startsWith("virtual:")) result = result.slice(8);
+	if (result.includes("/@fs/")) result = result.split("/@fs/").pop() || result;
+	return result;
+}
+/**
+* Find which layer a file belongs to by checking if the file path starts with
+* any layer's path. Sorts layers by path length (longest first) to match the
+* most specific layer.
+*
+* This function handles both symlinked and real paths by comparing both:
+* - Original paths (for symlink matching)
+* - Real paths (for resolved symlink matching)
+*
+* @param filePath - Absolute path of the importing file (may be symlink or real)
+* @param layers - Array of resolved layers
+* @returns The layer the file belongs to, or null if not in any layer
+*/
+function findLayerForFile(filePath, layers) {
+	if (!filePath || layers.length === 0) return null;
+	const strippedPath = stripVirtualPrefixes(filePath);
+	const normalizedFilePath = normalize(strippedPath);
+	const realFilePath = normalize(getRealPath(strippedPath));
+	const sortedLayers = [...layers].sort((a, b) => b.path.length - a.path.length);
+	for (const layer of sortedLayers) {
+		const normalizedLayerPath = normalize(layer.path);
+		const realLayerPath = normalize(getRealPath(layer.path));
+		if (normalizedFilePath.startsWith(normalizedLayerPath + "/") || normalizedFilePath === normalizedLayerPath || realFilePath.startsWith(realLayerPath + "/") || realFilePath === realLayerPath || normalizedFilePath.startsWith(realLayerPath + "/") || realFilePath.startsWith(normalizedLayerPath + "/")) return layer;
+	}
+	return null;
+}
+/**
+* Get the source path for a layer (src/ if exists, otherwise layer root)
+*
+* @param layerPath - Absolute path to the layer root
+* @returns Path to src/ directory or layer root
+*/
+function getLayerSourcePath(layerPath) {
+	const srcPath = join$1(layerPath, "src");
+	return existsSync(srcPath) ? srcPath : layerPath;
+}
+/**
+* Resolve a `~/` or `@/` alias relative to the given layer
+* Tries common extensions if the exact path doesn't exist
 *
-* @param specifier - Full package specifier (e.g., "@kimesh/head" or "@kimesh/head/plugin")
-* @param fromDir - Directory to resolve from
-* @returns Resolved file path or null if not found
+* @param id - The import specifier (e.g., '~/components/Foo.vue')
+* @param layer - The layer to resolve relative to
+* @returns The resolved absolute path, or null if not an alias
+*/
+function resolveLayerAlias(id, layer) {
+	let basePath = null;
+	if (id.startsWith("~/")) {
+		const relativePath = id.slice(2);
+		basePath = join$1(layer.path, relativePath);
+	}
+	if (id.startsWith("@/")) {
+		const relativePath = id.slice(2);
+		basePath = join$1(getLayerSourcePath(layer.path), relativePath);
+	}
+	if (!basePath) return null;
+	if (existsSync(basePath)) return basePath;
+	for (const ext of [
+		".ts",
+		".js",
+		".vue",
+		".tsx",
+		".jsx",
+		".mjs",
+		".mts"
+	]) {
+		const withExt = basePath + ext;
+		if (existsSync(withExt)) return withExt;
+	}
+	for (const indexFile of [
+		"index.ts",
+		"index.js",
+		"index.vue",
+		"index.mjs",
+		"index.mts"
+	]) {
+		const indexPath = join$1(basePath, indexFile);
+		if (existsSync(indexPath)) return indexPath;
+	}
+	return basePath;
+}
+/**
+* Create the context-aware layer alias Vite plugin
+*
+* This plugin intercepts `~/` and `@/` imports and resolves them based on
+* which layer the importing file belongs to.
+*/
+/**
+* Regex to match ~/ or @/ imports in code
+* Captures: full import statement, specifier, import path
+*/
+const ALIAS_IMPORT_RE = /from\s+['"]([~@]\/[^'"]+)['"]/g;
+/**
+* Create the context-aware layer alias Vite plugin
+*
+* This plugin intercepts `~/` and `@/` imports and resolves them based on
+* which layer the importing file belongs to.
+*
+* It uses both resolveId (for regular imports) and transform (for virtual modules)
+* to handle all cases.
+*/
+function layerAliasPlugin(options) {
+	const { getLayers, debug = false } = options;
+	/**
+	* Resolve an alias import given the importer path
+	*/
+	function resolveAliasImport(id, importer) {
+		const layers = getLayers();
+		if (layers.length === 0) return null;
+		const targetLayer = findLayerForFile(importer, layers) || layers.find((l) => l.isApp) || layers[0];
+		if (!targetLayer) return null;
+		return resolveLayerAlias(id, targetLayer);
+	}
+	return {
+		name: "kimesh:layer-alias",
+		enforce: "pre",
+		resolveId(id, importer) {
+			if (!id.startsWith("~/") && !id.startsWith("@/")) return null;
+			if (!importer) {
+				if (debug) consola.debug(`[layer-alias] No importer for ${id}, skipping`);
+				return null;
+			}
+			const resolved = resolveAliasImport(id, importer);
+			if (resolved) {
+				if (debug) consola.debug(`[layer-alias] resolveId: ${id} -> ${resolved} (from: ${importer.slice(-60)})`);
+				return resolved;
+			}
+			return null;
+		},
+		transform(code, id) {
+			if (!id.includes("kimesh-route:")) return null;
+			if (!code.includes("~/") && !code.includes("@/")) return null;
+			const filePath = stripVirtualPrefixes(id);
+			if (debug) {
+				const layers = getLayers();
+				consola.debug(`[layer-alias] transform: processing ${filePath.slice(-80)}`);
+				consola.debug(`[layer-alias] transform: layers=${layers.map((l) => l.name).join(", ")}`);
+			}
+			const transformedCode = code.replace(ALIAS_IMPORT_RE, (match, importPath) => {
+				const resolved = resolveAliasImport(importPath, filePath);
+				if (resolved) {
+					if (debug) consola.debug(`[layer-alias] transform: ${importPath} -> ${resolved}`);
+					return `from '${resolved}'`;
+				}
+				return match;
+			});
+			if (transformedCode !== code) return {
+				code: transformedCode,
+				map: null
+			};
+			return null;
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/kimesh-package-resolver.ts
+/**
+* @kimesh/kit - Kimesh Package Resolution
+*
+* Handles resolution of @kimesh/* packages across different package managers.
+* Extracted from plugin.ts for better maintainability.
+*/
+/**
+* Map from @kimesh/* package name to the directory name in kimesh/packages/
+*/
+const PACKAGE_DIR_MAP = {
+	"@kimesh/router-runtime": "router-runtime",
+	"@kimesh/head": "head",
+	"@kimesh/query": "query",
+	"@kimesh/kit": "kit",
+	"@kimesh/layers": "layers",
+	"@kimesh/auto-import": "auto-import",
+	"@kimesh/router-generator": "router-generator"
+};
+/**
+* Map subpath exports to their actual dist file paths
+*
+* Used for workspace development (link:kimesh) where symlinked packages
+* don't resolve subpath exports correctly via Vite's alias system.
+*/
+const SUBPATH_EXPORT_MAP = {
+	"@kimesh/head/plugin": {
+		pkg: "head",
+		file: "dist/plugin.mjs"
+	},
+	"@kimesh/router-runtime/default-app": {
+		pkg: "router-runtime",
+		file: "dist/default-app.mjs"
+	},
+	"@kimesh/router-runtime/middleware/plugin": {
+		pkg: "router-runtime",
+		file: "dist/middleware/plugin.mjs"
+	},
+	"kimesh/head/plugin": {
+		pkg: "head",
+		file: "dist/plugin.mjs"
+	},
+	"kimesh/router-runtime/default-app": {
+		pkg: "router-runtime",
+		file: "dist/default-app.mjs"
+	},
+	"kimesh/router-runtime/middleware/plugin": {
+		pkg: "router-runtime",
+		file: "dist/middleware/plugin.mjs"
+	}
+};
+/**
+* Try to resolve a package or subpath export using exsolve
 */
 function tryResolveModule(specifier, fromUrl) {
 	try {
@@ -2579,8 +2867,7 @@ function tryResolveModule(specifier, fromUrl) {
 	}
 }
 /**
-* Try to resolve a package directory (not a specific file).
-* Used for aliasing the base package.
+* Try to resolve a package directory (not a specific file)
 */
 function tryResolvePackage(packageName, fromUrl) {
 	try {
@@ -2601,14 +2888,23 @@ function tryResolvePackage(packageName, fromUrl) {
 	return null;
 }
 /**
-* Find the kimesh packages location.
-* This handles both installed packages (in node_modules) and workspace development.
-*
-* The search strategy:
-* 1. Check if we're in a workspace development setup (kimesh/packages/*)
-* 2. From @kimesh/kit's location, traverse up to find the parent "kimesh" package
-* 3. In pnpm/bun workspace: kit -> ../kimesh/node_modules
-* 4. In npm flat layout: kit is in node_modules/@kimesh/kit, umbrella is in node_modules/kimesh
+* 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;
+}
+/**
+* Find the kimesh packages location
 */
 function findKimeshPackagesLocation(kitPath, debug) {
 	const kitDir = dirname$1(dirname$1(kitPath.replace(/^file:\/\//, "")));
@@ -2665,70 +2961,7 @@ function findKimeshPackagesLocation(kitPath, debug) {
 	return null;
 }
 /**
-* Map from @kimesh/* package name to the directory name in kimesh/packages/
-* Most follow the pattern @kimesh/{name} -> {name}, but some differ
-*/
-const PACKAGE_DIR_MAP = {
-	"@kimesh/router-runtime": "router-runtime",
-	"@kimesh/head": "head",
-	"@kimesh/query": "query",
-	"@kimesh/kit": "kit",
-	"@kimesh/layers": "layers",
-	"@kimesh/auto-import": "auto-import",
-	"@kimesh/router-generator": "router-generator"
-};
-/**
-* Map subpath exports to their actual dist file paths
-*
-* This map is used for workspace development (link:kimesh) where we need to
-* resolve subpath exports directly to dist files since symlinked packages
-* don't resolve subpath exports correctly via Vite's alias system.
-*
-* NOTE: We now prefer using `kimesh/head/plugin` (umbrella package subpath)
-* over `@kimesh/head/plugin` (direct internal package) because the umbrella
-* package re-exports work correctly in PR preview packages and all setups.
-*/
-const SUBPATH_EXPORT_MAP = {
-	"@kimesh/head/plugin": {
-		pkg: "head",
-		file: "dist/plugin.mjs"
-	},
-	"@kimesh/router-runtime/default-app": {
-		pkg: "router-runtime",
-		file: "dist/default-app.mjs"
-	},
-	"@kimesh/router-runtime/middleware/plugin": {
-		pkg: "router-runtime",
-		file: "dist/middleware/plugin.mjs"
-	},
-	"kimesh/head/plugin": {
-		pkg: "head",
-		file: "dist/plugin.mjs"
-	},
-	"kimesh/router-runtime/default-app": {
-		pkg: "router-runtime",
-		file: "dist/default-app.mjs"
-	},
-	"kimesh/router-runtime/middleware/plugin": {
-		pkg: "router-runtime",
-		file: "dist/middleware/plugin.mjs"
-	}
-};
-/**
-* Build aliases for @kimesh/* packages and their subpath exports.
-* This ensures Vite can resolve these packages regardless of package manager.
-*
-* KEY INSIGHT: We find the "kimesh" umbrella package's node_modules, then
-* resolve all @kimesh/* packages from there. This works because:
-* 1. User's project depends on the umbrella "kimesh" package
-* 2. The umbrella package has @kimesh/kit, @kimesh/head, etc. as dependencies
-* 3. Those dependencies are installed in the umbrella's node_modules
-*
-* For workspace development (link:kimesh), we directly resolve from sibling packages.
-*
-* Unlike simple package aliases, this also handles subpath exports like:
-* - "@kimesh/head/plugin" -> actual file path
-* - "@kimesh/router-runtime/default-app" -> actual file path
+* Build aliases for @kimesh/* packages and their subpath exports
 */
 function buildKimeshPackageAliases(_rootDir, debug) {
 	const kitUrl = import.meta.url;
@@ -2784,8 +3017,178 @@ function buildKimeshPackageAliases(_rootDir, debug) {
 	}
 	return aliases;
 }
+
+//#endregion
+//#region src/vite/middleware-generator.ts
+/**
+* @kimesh/kit - Middleware Generation
+*
+* Handles middleware scanning and code generation.
+* Extracted from plugin.ts for better maintainability.
+*/
 /**
-* Process all configured modules using the new v2 system
+* Scan and generate middleware from host app and all layers
+*/
+async function generateMiddleware(kimesh, resolvedDirs, resolvedLayers, debug) {
+	const middlewareDir = join$1(resolvedDirs.srcDir, "middleware");
+	try {
+		const middlewareResult = await scanLayerMiddleware([{
+			layerName: "app",
+			layerPath: resolvedDirs.rootDir,
+			middlewareDir,
+			priority: 0
+		}, ...resolvedLayers.filter((l) => !l.isApp).map((layer) => ({
+			layerName: layer.name,
+			layerPath: layer.path,
+			middlewareDir: join$1(layer.path, "src", "middleware"),
+			priority: layer.priority
+		}))], { orderStrategy: "alphabetical" });
+		if (middlewareResult.middleware.length === 0) return {
+			hasMiddleware: false,
+			pluginPath: null
+		};
+		if (!existsSync(resolvedDirs.buildDir)) mkdirSync(resolvedDirs.buildDir, { recursive: true });
+		const registryCode = generateMiddlewareRegistry(middlewareResult);
+		writeFileSync(join$1(resolvedDirs.buildDir, "middleware.gen.ts"), registryCode, "utf-8");
+		const typesCode = generateMiddlewareTypes(middlewareResult);
+		writeFileSync(join$1(resolvedDirs.buildDir, "middleware.d.ts"), typesCode, "utf-8");
+		const middlewarePluginCode = `/**
+ * Kimesh Middleware Plugin - Auto-generated
+ * DO NOT EDIT - This file is regenerated when middleware files change
+ */
+
+import { createMiddlewarePlugin } from '@kimesh/router-runtime'
+import { globalMiddleware, namedMiddleware } from './middleware.gen'
+
+export default createMiddlewarePlugin({
+  globalMiddleware,
+  namedMiddleware,
+})
+`;
+		const middlewarePluginPath = join$1(resolvedDirs.buildDir, "middleware-plugin.mjs");
+		writeFileSync(middlewarePluginPath, middlewarePluginCode, "utf-8");
+		if (debug) consola.info(`[Kimesh] Middleware: ${middlewareResult.globalMiddleware.length} global, ${middlewareResult.namedMiddleware.length} named`);
+		if (!kimesh._registries.runtimePlugins.some((p) => p.name === "middleware")) {
+			kimesh._registries.runtimePlugins.push({
+				src: middlewarePluginPath,
+				name: "middleware"
+			});
+			if (debug) consola.info(`[Kimesh] Auto-registered middleware plugin`);
+		}
+		return {
+			hasMiddleware: true,
+			pluginPath: middlewarePluginPath
+		};
+	} catch (error) {
+		if (debug) consola.warn(`[Kimesh] Middleware scanning failed:`, error);
+		return {
+			hasMiddleware: false,
+			pluginPath: null
+		};
+	}
+}
+
+//#endregion
+//#region src/vite/spa-middleware.ts
+/**
+* @kimesh/kit - SPA Fallback Middleware
+*
+* Handles SPA routing in development mode.
+* Extracted from plugin.ts for better maintainability.
+*/
+/**
+* Known static file extensions that should NOT be served as HTML
+*/
+const STATIC_EXTENSIONS = new Set([
+	"js",
+	"mjs",
+	"cjs",
+	"ts",
+	"mts",
+	"cts",
+	"jsx",
+	"tsx",
+	"css",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"json",
+	"xml",
+	"yaml",
+	"yml",
+	"toml",
+	"html",
+	"htm",
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"woff",
+	"woff2",
+	"ttf",
+	"eot",
+	"otf",
+	"mp3",
+	"mp4",
+	"webm",
+	"ogg",
+	"wav",
+	"pdf",
+	"zip",
+	"tar",
+	"gz",
+	"map",
+	"wasm"
+]);
+/**
+* Check if a URL should skip SPA handling
+*/
+function shouldSkipSpaHandling(url) {
+	if (url.startsWith("/@") || url.startsWith("/__") || url.startsWith("/node_modules")) return true;
+	if (url.split("?")[0].startsWith("/.")) return true;
+	return false;
+}
+/**
+* Check if pathname looks like a static file
+*/
+function isStaticFile(pathname) {
+	const extMatch = (pathname.split("/").pop() || "").match(/\.([a-zA-Z0-9]+)$/);
+	if (extMatch) {
+		const ext = extMatch[1].toLowerCase();
+		return STATIC_EXTENSIONS.has(ext);
+	}
+	return false;
+}
+/**
+* Create SPA fallback middleware for Vite dev server
+*/
+function createSpaFallbackMiddleware(server, generatedDir) {
+	return async (req, res, next) => {
+		const url = req.url || "/";
+		if (shouldSkipSpaHandling(url)) return next();
+		if (!(req.headers.accept || "").includes("text/html")) return next();
+		const pathname = url.split("?")[0];
+		if (isStaticFile(pathname)) return next();
+		try {
+			const html = readFileSync(`${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);
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/plugin.ts
+/**
+* Process all configured modules using the v2 system
 */
 async function processModules(kimesh, debug) {
 	const modules = kimesh.options.config.modules;
@@ -2800,45 +3203,6 @@ async function processModules(kimesh, debug) {
 	}
 }
 /**
-* 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, rootDir) {
-	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) => {
-		const pkgDir = resolvePackageDir(name, rootDir);
-		if (pkgDir) {
-			const relativePath = relative(buildDir, pkgDir);
-			return `/// <reference path="${relativePath.startsWith("..") ? relativePath : "./" + relativePath}/augment.d.ts" />`;
-		}
-		return `/// <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
 */
@@ -2951,54 +3315,7 @@ function kimeshPlugin(options = {}) {
 					consola.info(`[Kimesh] Found ${state.kimesh._registries.runtimePlugins.length} module-registered plugins`);
 				}
 			}
-			const middlewareDir = join$1(resolvedDirs.srcDir, "middleware");
-			let hasMiddleware = false;
-			try {
-				const middlewareResult = await scanLayerMiddleware([{
-					layerName: "app",
-					layerPath: configRoot,
-					middlewareDir,
-					priority: 0
-				}, ...state.resolvedLayers.filter((l) => !l.isApp).map((layer) => ({
-					layerName: layer.name,
-					layerPath: layer.path,
-					middlewareDir: join$1(layer.path, "src", "middleware"),
-					priority: layer.priority
-				}))], { orderStrategy: "alphabetical" });
-				hasMiddleware = middlewareResult.middleware.length > 0;
-				if (hasMiddleware) {
-					const registryCode = generateMiddlewareRegistry(middlewareResult);
-					const registryPath = join$1(resolvedDirs.buildDir, "middleware.gen.ts");
-					if (!existsSync(resolvedDirs.buildDir)) mkdirSync(resolvedDirs.buildDir, { recursive: true });
-					writeFileSync(registryPath, registryCode, "utf-8");
-					const typesCode = generateMiddlewareTypes(middlewareResult);
-					writeFileSync(join$1(resolvedDirs.buildDir, "middleware.d.ts"), typesCode, "utf-8");
-					writeFileSync(join$1(resolvedDirs.buildDir, "middleware-plugin.mjs"), `/**
- * Kimesh Middleware Plugin - Auto-generated
- * DO NOT EDIT - This file is regenerated when middleware files change
- */
-
-import { createMiddlewarePlugin } from '@kimesh/router-runtime'
-import { globalMiddleware, namedMiddleware } from './middleware.gen'
-
-export default createMiddlewarePlugin({
-  globalMiddleware,
-  namedMiddleware,
-})
-`, "utf-8");
-					if (debug) consola.info(`[Kimesh] Middleware: ${middlewareResult.globalMiddleware.length} global, ${middlewareResult.namedMiddleware.length} named`);
-					const middlewarePluginSrc = join$1(resolvedDirs.buildDir, "middleware-plugin.mjs");
-					if (!state.kimesh._registries.runtimePlugins.some((p) => p.name === "middleware")) {
-						state.kimesh._registries.runtimePlugins.push({
-							src: middlewarePluginSrc,
-							name: "middleware"
-						});
-						if (debug) consola.info(`[Kimesh] Auto-registered middleware plugin`);
-					}
-				}
-			} catch (error) {
-				if (debug) consola.warn(`[Kimesh] Middleware scanning failed:`, error);
-			}
+			await generateMiddleware(state.kimesh, resolvedDirs, state.resolvedLayers, debug);
 			generateModulesTypeDeclaration(config.modules, state.generatedDir, configRoot);
 			await writeTemplates(state.kimesh);
 			const userAliases = buildAliases(config, resolvedDirs.srcDir, configRoot);
@@ -3014,11 +3331,18 @@ export default createMiddlewarePlugin({
 				"#kimesh/plugins": join$1(resolvedDirs.buildDir, "plugins.mjs"),
 				"#kimesh/middleware": join$1(resolvedDirs.buildDir, "middleware.gen.ts")
 			};
+			const hostAppAliases = {
+				"@": resolvedDirs.srcDir,
+				"~": configRoot
+			};
 			writeTsConfig({
 				rootDir: configRoot,
 				srcDir: resolvedDirs.srcDir,
 				buildDir: state.generatedDir,
-				aliases: userAliases,
+				aliases: {
+					...userAliases,
+					...hostAppAliases
+				},
 				layerAliases,
 				moduleAliases,
 				internalAliases,
@@ -3145,7 +3469,14 @@ export default createMiddlewarePlugin({
 						esModuleInterop: true,
 						lib: ["ESNext", "DOM"],
 						skipLibCheck: true,
-						noEmit: true
+						noEmit: true,
+						baseUrl: "..",
+						paths: {
+							"~": ["."],
+							"~/*": ["./*"],
+							"@": ["./src"],
+							"@/*": ["./src/*"]
+						}
 					},
 					include: ["../src/**/*", "./**/*"],
 					exclude: ["../node_modules"]
@@ -3173,70 +3504,7 @@ export default createMiddlewarePlugin({
 			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 || "/";
-				const pathname = url.split("?")[0];
-				if (url.startsWith("/@") || url.startsWith("/__") || url.startsWith("/node_modules") || pathname.startsWith("/.")) return next();
-				if (!(req.headers.accept || "").includes("text/html")) return next();
-				const extMatch = (pathname.split("/").pop() || "").match(/\.([a-zA-Z0-9]+)$/);
-				if (extMatch) {
-					const ext = extMatch[1].toLowerCase();
-					if ([
-						"js",
-						"mjs",
-						"cjs",
-						"ts",
-						"mts",
-						"cts",
-						"jsx",
-						"tsx",
-						"css",
-						"scss",
-						"sass",
-						"less",
-						"styl",
-						"json",
-						"xml",
-						"yaml",
-						"yml",
-						"toml",
-						"html",
-						"htm",
-						"png",
-						"jpg",
-						"jpeg",
-						"gif",
-						"svg",
-						"ico",
-						"webp",
-						"avif",
-						"woff",
-						"woff2",
-						"ttf",
-						"eot",
-						"otf",
-						"mp3",
-						"mp4",
-						"webm",
-						"ogg",
-						"wav",
-						"pdf",
-						"zip",
-						"tar",
-						"gz",
-						"map",
-						"wasm"
-					].includes(ext)) 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);
-				}
-			});
+			server.middlewares.use(createSpaFallbackMiddleware(server, state.generatedDir));
 		}
 	};
 	const routerPlugin = kimeshRouterGenerator({
@@ -3257,41 +3525,46 @@ export default createMiddlewarePlugin({
 			});
 		}
 	});
+	const autoImportPlugin = 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
+			}));
+		},
+		getKimesh: () => state.kimesh,
+		dts: config.autoImport?.dts !== false ? state.generatedDir || ".kimesh" : false,
+		debug
+	});
 	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
-				}));
-			},
-			getKimesh: () => state.kimesh,
-			dts: config.autoImport?.dts !== false ? state.generatedDir || ".kimesh" : false,
+		layerAliasPlugin({
+			getLayers: () => state.resolvedLayers,
 			debug
 		}),
+		mainPlugin,
+		autoImportPlugin,
 		vue(),
 		routerPlugin
 	];
@@ -3450,11 +3723,18 @@ async function prepare(options = {}) {
 		"#kimesh/context": join$1(root, "src", "app.context.ts"),
 		"#kimesh/plugins": join$1(kimeshDir, "plugins.mjs")
 	};
+	const appAliases = {
+		"@": srcDir,
+		"~": root
+	};
 	writeTsConfig({
 		rootDir: root,
 		srcDir,
 		buildDir,
-		aliases: userAliases,
+		aliases: {
+			...userAliases,
+			...appAliases
+		},
 		layerAliases,
 		moduleAliases: {},
 		internalAliases,
@@ -3655,16 +3935,6 @@ declare module 'vue' {
 	};
 }
 /**
-* 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;
-}
-/**
 * Generate stub routes.gen.ts when route scanning is not available
 */
 function generateRoutesStub(buildDir, generatedFiles, verbose) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimesh/kit",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "Build-time engine for Kimesh framework",
   "repository": {
     "type": "git",
@@ -27,9 +27,9 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@kimesh/auto-import": "0.2.23",
-    "@kimesh/layers": "0.2.23",
-    "@kimesh/router-generator": "0.2.23",
+    "@kimesh/auto-import": "0.2.24",
+    "@kimesh/layers": "0.2.24",
+    "@kimesh/router-generator": "0.2.24",
     "@vitejs/plugin-vue": "^6.0.3",
     "c12": "^3.3.3",
     "consola": "^3.4.2",