@kimesh/layers 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# @kimesh/layers
+
+Part of the [Kimesh](https://github.com/kimesh/kimesh) framework.

package/dist/index.d.mts

@@ -0,0 +1,357 @@
+//#region src/types.d.ts
+/**
+ * @kimesh/layers - Type definitions
+ *
+ * This module defines the core types for the Kimesh layer system.
+ */
+/**
+ * Configuration for a single layer in kimesh.config.ts
+ */
+interface KimeshLayerConfig {
+  /** Layer name (e.g., '@kimesh-layers/cms' or 'cms') */
+  name: string;
+  /** Path to the layer root directory */
+  path: string;
+  /** Routes configuration for this layer */
+  routes?: LayerRouteConfig;
+  /** Component configuration for this layer */
+  components?: LayerComponentConfig;
+  /** Composable configuration for this layer */
+  composables?: LayerComposableConfig;
+  /** Utils configuration for this layer */
+  utils?: LayerUtilsConfig;
+  /** Stores configuration for this layer */
+  stores?: LayerStoresConfig;
+  /** Auto-import configuration for this layer */
+  autoImport?: LayerAutoImportConfig;
+  /** CSS files to include from this layer */
+  css?: string[];
+  /** Dependencies required by this layer */
+  dependencies?: string[];
+}
+/**
+ * Extended layer configuration (from `extends` array)
+ * Can be a string path or full config object
+ */
+type ExtendedLayerConfig = string | KimeshLayerConfig;
+/**
+ * Route configuration for a layer
+ */
+interface LayerRouteConfig {
+  /** Routes directory within the layer (default: 'routes') */
+  folder?: string;
+  /** Base path prefix for this layer's routes (e.g., '/blog') */
+  basePath?: string;
+  /** Include patterns for route files */
+  include?: string[];
+  /** Exclude patterns for route files */
+  exclude?: string[];
+}
+/**
+ * Component configuration for a layer
+ */
+interface LayerComponentConfig {
+  /** Component directories to scan */
+  dirs?: string[];
+  /** Prefix for component names (e.g., 'Cms' → CmsButton) */
+  prefix?: string | false;
+  /** Register components globally */
+  global?: boolean;
+  /** File extensions to scan */
+  extensions?: string[];
+}
+/**
+ * Composable configuration for a layer
+ */
+interface LayerComposableConfig {
+  /** Composable directories to scan */
+  dirs?: string[];
+  /** File extensions to scan */
+  extensions?: string[];
+}
+/**
+ * Utils configuration for a layer
+ */
+interface LayerUtilsConfig {
+  /** Utils directories to scan */
+  dirs?: string[];
+  /** File extensions to scan */
+  extensions?: string[];
+}
+/**
+ * Stores configuration for a layer
+ */
+interface LayerStoresConfig {
+  /** Stores directories to scan */
+  dirs?: string[];
+}
+/**
+ * Auto-import configuration for a layer
+ */
+interface LayerAutoImportConfig {
+  /** Additional imports specific to this layer */
+  imports?: Array<string | {
+    from: string;
+    imports: string[];
+  }>;
+}
+/**
+ * Resolved layer with all metadata
+ */
+interface ResolvedLayer {
+  /** Layer name */
+  name: string;
+  /** Absolute path to layer root */
+  path: string;
+  /** Priority (0 = app level, highest priority) */
+  priority: number;
+  /** Original configuration */
+  config: KimeshLayerConfig;
+  /** Layers this layer extends */
+  extends: string[];
+  /** Whether this is the app layer (priority 0) */
+  isApp: boolean;
+  /** Source type: 'local', 'npm', or 'workspace' */
+  source: "local" | "npm" | "workspace";
+  /** Alias mappings for this layer */
+  aliases: Record<string, string>;
+  /** Runtime config from this layer's kimesh.config.ts */
+  runtimeConfig?: Record<string, unknown>;
+}
+/**
+ * Layer stack - ordered list of resolved layers
+ */
+interface LayerStack {
+  /** All layers ordered by priority (0 = highest) */
+  layers: ResolvedLayer[];
+  /** App layer (priority 0) */
+  app: ResolvedLayer;
+  /** Layer lookup by name */
+  byName: Map<string, ResolvedLayer>;
+  /** Total layer count */
+  count: number;
+}
+/**
+ * Layer resolution options
+ */
+interface LayerResolveOptions {
+  /** Root directory of the application */
+  root: string;
+  /** Extended layers from config */
+  extends?: ExtendedLayerConfig[];
+  /** Auto-scan layers directory */
+  autoScan?: boolean;
+  /** Layers directory name (default: 'layers') */
+  layersDir?: string;
+}
+/**
+ * Layer merge result
+ */
+interface MergedLayerConfig {
+  /** All resolved layers */
+  layers: ResolvedLayer[];
+  /** Merged routes configuration */
+  routes: {
+    /** All route directories to scan */dirs: Array<{
+      path: string;
+      layer: string;
+    }>;
+  };
+  /** Merged component configuration */
+  components: {
+    /** All component directories to scan */dirs: Array<{
+      path: string;
+      layer: string;
+      prefix?: string;
+    }>;
+  };
+  /** Merged composable configuration */
+  composables: {
+    /** All composable directories to scan */dirs: Array<{
+      path: string;
+      layer: string;
+    }>;
+  };
+  /** All CSS files from layers */
+  css: string[];
+  /** Vite aliases for all layers */
+  aliases: Record<string, string>;
+  /** Vite fs.allow paths */
+  fsAllow: string[];
+  /** Merged runtime config from all layers (app layer has highest priority) */
+  runtimeConfig: Record<string, unknown>;
+}
+/**
+ * Layer conflict information
+ */
+interface LayerConflict {
+  /** Type of conflict */
+  type: "route" | "component" | "composable";
+  /** Name of the conflicting item */
+  name: string;
+  /** Winning layer */
+  winner: {
+    layer: string;
+    path: string;
+  };
+  /** Losing layers */
+  losers: Array<{
+    layer: string;
+    path: string;
+  }>;
+}
+//#endregion
+//#region src/resolve.d.ts
+/**
+ * Resolve all layers from configuration and auto-scanning
+ *
+ * Priority order (0 = highest):
+ * - 0: App (application src/)
+ * - 1+: Layers from extends[] array (order preserved)
+ * - N+: Auto-scanned layers/ directory (alphabetical)
+ */
+declare function resolveLayers(options: LayerResolveOptions): Promise<LayerStack>;
+/**
+ * Filter layers by enabled list
+ */
+declare function filterLayersByEnabled(stack: LayerStack, enabled: string[] | 'all' | 'none'): LayerStack;
+/**
+ * Get layer by name
+ */
+declare function getLayer(stack: LayerStack, name: string): ResolvedLayer | undefined;
+/**
+ * Check if a layer exists in the stack
+ */
+declare function hasLayer(stack: LayerStack, name: string): boolean;
+//#endregion
+//#region src/merge.d.ts
+/**
+ * Merge all layer configurations into a single unified config
+ *
+ * Merge strategy:
+ * - Routes: Collect from all layers (routes must be in correct directory structure)
+ * - Components: Collect from all layers, apply prefixes
+ * - Composables: Collect from all layers
+ * - CSS: Concatenate all CSS files
+ * - Aliases: Build complete alias map
+ */
+declare function mergeLayerConfigs(stack: LayerStack): MergedLayerConfig;
+/**
+ * Merge two configs with priority (using defu)
+ * Higher priority config values take precedence
+ */
+declare function mergeConfigs<T extends object>(highPriority: T, lowPriority: T): T;
+/**
+ * Detect conflicts between layers
+ */
+declare function detectConflicts(merged: MergedLayerConfig): LayerConflict[];
+//#endregion
+//#region src/aliases.d.ts
+/**
+ * Standard alias patterns for layers
+ */
+declare const ALIAS_PATTERNS: {
+  /** Layer root: #layer-name -> /path/to/layer */readonly LAYER_ROOT: "#"; /** Layer root with tilde: ~layer-name -> /path/to/layer */
+  readonly LAYER_TILDE: "~"; /** Layer source: @layer-name -> /path/to/layer/src (or layer root) */
+  readonly LAYER_AT: "@";
+};
+/**
+ * Create aliases for a single layer
+ *
+ * Generated aliases:
+ * - #layer-name -> layer root
+ * - ~layer-name -> layer root
+ * - @layer-name -> layer src/ or root
+ * - #layer-name/routes -> layer routes/
+ * - #layer-name/components -> layer components/
+ * - #layer-name/composables -> layer composables/
+ */
+declare function createLayerAliases(layerName: string, layerPath: string): Record<string, string>;
+/**
+ * Build all aliases from merged layer config
+ */
+declare function buildViteAliases(merged: MergedLayerConfig): Record<string, string>;
+/**
+ * Generate aliases from a ResolvedLayer array
+ * This is a convenience function for kit integration
+ */
+declare function generateLayerAliasesFromLayers(layers: ResolvedLayer[]): Record<string, string>;
+/**
+ * Build Vite fs.allow array from layer paths
+ */
+declare function buildFsAllow(merged: MergedLayerConfig): string[];
+/**
+ * Generate Vite resolve.alias configuration
+ */
+declare function generateViteAliasConfig(merged: MergedLayerConfig): Array<{
+  find: string | RegExp;
+  replacement: string;
+}>;
+/**
+ * Generate TypeScript paths configuration for tsconfig.json
+ */
+declare function generateTsConfigPaths(merged: MergedLayerConfig, baseUrl?: string): Record<string, string[]>;
+/**
+ * Generate virtual module resolving layer information
+ */
+declare function generateLayerInfoModule(stack: LayerStack): string;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Options for prepareLayers when using (root, options) signature
+ */
+interface PrepareLayersOptions {
+  enabled?: string[] | "all" | "none";
+  excluded?: string[];
+}
+/**
+ * Result type for prepareLayers with options object signature
+ */
+interface PrepareLayersResult {
+  merged: MergedLayerConfig;
+  aliases: Record<string, string>;
+  fsAllow: string[];
+}
+/**
+ * Prepare layers from a root directory with filtering options.
+ * Returns an array of resolved layers.
+ *
+ * @example
+ * ```ts
+ * const layers = await prepareLayersFromRoot(process.cwd(), {
+ *   enabled: ['blog', 'auth'],
+ *   excluded: [],
+ * });
+ * ```
+ */
+declare function prepareLayersFromRoot(root: string, options?: PrepareLayersOptions): Promise<ResolvedLayer[]>;
+/**
+ * Prepare layers with full configuration options.
+ * Returns merged config, aliases, and fsAllow paths.
+ *
+ * @example
+ * ```ts
+ * const { merged, aliases, fsAllow } = await prepareLayersWithConfig({
+ *   root: process.cwd(),
+ *   extends: ['./layers/cms'],
+ * });
+ * ```
+ */
+declare function prepareLayersWithConfig(options: LayerResolveOptions & {
+  enabled?: string[] | "all" | "none";
+}): Promise<PrepareLayersResult>;
+/**
+ * High-level utility to resolve and filter layers.
+ *
+ * Supports two call signatures:
+ * - `prepareLayers(root, options)` - Returns ResolvedLayer[]
+ * - `prepareLayers(options)` - Returns { merged, aliases, fsAllow }
+ *
+ * @deprecated Use prepareLayersFromRoot or prepareLayersWithConfig for clearer intent
+ */
+declare function prepareLayers(rootOrOptions: string | (LayerResolveOptions & {
+  enabled?: string[] | "all" | "none";
+}), options?: PrepareLayersOptions): Promise<ResolvedLayer[] | PrepareLayersResult>;
+//#endregion
+export { ALIAS_PATTERNS, type ExtendedLayerConfig, type KimeshLayerConfig, type LayerAutoImportConfig, type LayerComponentConfig, type LayerComposableConfig, type LayerConflict, type LayerResolveOptions, type LayerRouteConfig, type LayerStack, type LayerStoresConfig, type LayerUtilsConfig, type MergedLayerConfig, PrepareLayersOptions, PrepareLayersResult, type ResolvedLayer, buildFsAllow, buildViteAliases, createLayerAliases, detectConflicts, filterLayersByEnabled, generateLayerAliasesFromLayers as generateLayerAliases, generateLayerInfoModule, generateTsConfigPaths, generateViteAliasConfig, getLayer, hasLayer, mergeConfigs, mergeLayerConfigs, prepareLayers, prepareLayersFromRoot, prepareLayersWithConfig, resolveLayers };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/resolve.ts","../src/merge.ts","../src/aliases.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,750 @@
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+import * as path from "pathe";
+import { loadConfig } from "c12";
+import { consola } from "consola";
+import { defu } from "defu";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/aliases.ts
+/**
+* @kimesh/layers - Path Aliasing
+*
+* This module generates per-layer path aliases for Vite configuration.
+*/
+/**
+* Standard alias patterns for layers
+*/
+const ALIAS_PATTERNS = {
+	LAYER_ROOT: "#",
+	LAYER_TILDE: "~",
+	LAYER_AT: "@"
+};
+const SUB_DIRS = [
+	"routes",
+	"components",
+	"composables",
+	"utils",
+	"types",
+	"stores"
+];
+/**
+* Create aliases for a single layer
+*
+* Generated aliases:
+* - #layer-name -> layer root
+* - ~layer-name -> layer root
+* - @layer-name -> layer src/ or root
+* - #layer-name/routes -> layer routes/
+* - #layer-name/components -> layer components/
+* - #layer-name/composables -> layer composables/
+*/
+function createLayerAliases(layerName, layerPath) {
+	const aliases = {};
+	const aliasName = sanitizeLayerName(layerName);
+	const srcPath = path.join(layerPath, "src");
+	aliases[`#${aliasName}`] = layerPath;
+	aliases[`~${aliasName}`] = layerPath;
+	aliases[`@${aliasName}`] = getLayerSourcePath(layerPath);
+	for (const subDir of SUB_DIRS) {
+		const rootSubDir = path.join(layerPath, subDir);
+		const srcSubDir = path.join(srcPath, subDir);
+		if (fs.existsSync(rootSubDir)) aliases[`#${aliasName}/${subDir}`] = rootSubDir;
+		if (fs.existsSync(srcSubDir)) aliases[`@${aliasName}/${subDir}`] = srcSubDir;
+	}
+	return aliases;
+}
+/**
+* Sanitize layer name for use in aliases
+*
+* @example
+* '@kimesh-layers/cms' -> 'kimesh-layers-cms'
+* '@company/layer-auth' -> 'company-layer-auth'
+* 'my-layer' -> 'my-layer'
+*/
+function sanitizeLayerName(layerName) {
+	return layerName.replace(/^@/, "").replace(/\//g, "-");
+}
+/**
+* Get source path for a layer (src/ if exists, otherwise root)
+*/
+function getLayerSourcePath(layerPath) {
+	const srcPath = path.join(layerPath, "src");
+	return fs.existsSync(srcPath) ? srcPath : layerPath;
+}
+/**
+* Add global app aliases (@ and ~) for the app layer
+*/
+function addAppAliases(aliases, appLayer) {
+	aliases["@"] = getLayerSourcePath(appLayer.path);
+	aliases["~"] = appLayer.path;
+}
+/**
+* Build all aliases from merged layer config
+*/
+function buildViteAliases(merged) {
+	const aliases = { ...merged.aliases };
+	const appLayer = merged.layers.find((l) => l.isApp);
+	if (appLayer) addAppAliases(aliases, appLayer);
+	return aliases;
+}
+/**
+* Generate aliases from a ResolvedLayer array
+* This is a convenience function for kit integration
+*/
+function generateLayerAliasesFromLayers(layers) {
+	const aliases = {};
+	for (const layer of layers) Object.assign(aliases, createLayerAliases(layer.name, layer.path));
+	const appLayer = layers.find((l) => l.isApp);
+	if (appLayer) addAppAliases(aliases, appLayer);
+	return aliases;
+}
+/**
+* Build Vite fs.allow array from layer paths
+*/
+function buildFsAllow(merged) {
+	const allow = new Set(merged.fsAllow);
+	for (const layer of merged.layers) if (layer.source === "npm" || layer.source === "workspace") {
+		const nodeModulesPath = findNodeModulesParent(layer.path);
+		if (nodeModulesPath) allow.add(nodeModulesPath);
+	}
+	return Array.from(allow);
+}
+/**
+* Find the nearest node_modules parent directory
+*/
+function findNodeModulesParent(filePath) {
+	let current = filePath;
+	while (current !== path.dirname(current)) {
+		if (path.basename(current) === "node_modules") return current;
+		current = path.dirname(current);
+	}
+	return null;
+}
+/**
+* Generate Vite resolve.alias configuration
+*/
+function generateViteAliasConfig(merged) {
+	const aliases = buildViteAliases(merged);
+	return Object.keys(aliases).sort((a, b) => b.length - a.length).map((key) => ({
+		find: key,
+		replacement: aliases[key]
+	}));
+}
+/**
+* Generate TypeScript paths configuration for tsconfig.json
+*/
+function generateTsConfigPaths(merged, baseUrl = ".") {
+	const paths = {};
+	const aliases = buildViteAliases(merged);
+	for (const [alias, target] of Object.entries(aliases)) {
+		const relativePath = path.relative(baseUrl, target);
+		paths[alias] = [relativePath];
+		paths[`${alias}/*`] = [`${relativePath}/*`];
+	}
+	return paths;
+}
+/**
+* Generate virtual module resolving layer information
+*/
+function generateLayerInfoModule(stack) {
+	const layersInfo = stack.layers.map((layer) => ({
+		name: layer.name,
+		path: layer.path,
+		priority: layer.priority,
+		source: layer.source,
+		isApp: layer.isApp
+	}));
+	return `
+// Auto-generated by @kimesh/layers
+// DO NOT EDIT
+
+export const layers = ${JSON.stringify(layersInfo, null, 2)} as const;
+
+export type LayerName = typeof layers[number]['name'];
+
+export function getLayer(name: LayerName) {
+  return layers.find(l => l.name === name);
+}
+
+export const appLayer = ${JSON.stringify(layersInfo.find((l) => l.isApp))} as const;
+`.trim();
+}
+
+//#endregion
+//#region src/resolve.ts
+/**
+* @kimesh/layers - Layer Resolution
+*
+* This module handles layer discovery, resolution, and priority ordering.
+*/
+const logger$1 = consola.withTag("kimesh:layers");
+/**
+* Resolve all layers from configuration and auto-scanning
+*
+* Priority order (0 = highest):
+* - 0: App (application src/)
+* - 1+: Layers from extends[] array (order preserved)
+* - N+: Auto-scanned layers/ directory (alphabetical)
+*/
+async function resolveLayers(options) {
+	const { root, extends: extendedLayers = [], autoScan = true, layersDir = "layers" } = options;
+	const startTime = performance.now();
+	const layers = [];
+	const visited = /* @__PURE__ */ new Set();
+	const resolving = /* @__PURE__ */ new Set();
+	const appLayer = createAppLayer(root);
+	layers.push(appLayer);
+	visited.add("app");
+	let priority = 1;
+	for (const extendedConfig of extendedLayers) {
+		const resolved = await resolveExtendedLayer(extendedConfig, root, priority, visited, resolving);
+		if (resolved) {
+			layers.push(resolved);
+			visited.add(resolved.name);
+			priority++;
+		}
+	}
+	if (autoScan) {
+		const autoScanned = await scanLayersDirectory(path.join(root, layersDir), priority, visited);
+		layers.push(...autoScanned);
+	}
+	const byName = /* @__PURE__ */ new Map();
+	for (const layer of layers) byName.set(layer.name, layer);
+	const elapsed = performance.now() - startTime;
+	logger$1.debug(`Resolved ${layers.length} layers in ${elapsed.toFixed(1)}ms`);
+	return {
+		layers,
+		app: appLayer,
+		byName,
+		count: layers.length
+	};
+}
+/**
+* Create the app layer (priority 0)
+*/
+function createAppLayer(root) {
+	const srcPath = path.join(root, "src");
+	return {
+		name: "app",
+		path: fs.existsSync(srcPath) ? srcPath : root,
+		priority: 0,
+		config: {
+			name: "app",
+			path: root
+		},
+		extends: [],
+		isApp: true,
+		source: "local",
+		aliases: createLayerAliases("app", root)
+	};
+}
+/**
+* Resolve a single extended layer configuration
+*/
+async function resolveExtendedLayer(config, root, priority, visited, resolving) {
+	const layerConfig = normalizeLayerConfig(config, root);
+	if (!layerConfig) {
+		logger$1.warn(`Could not normalize layer config: ${JSON.stringify(config)}`);
+		return null;
+	}
+	if (visited.has(layerConfig.name)) {
+		logger$1.debug(`Layer '${layerConfig.name}' already resolved, skipping`);
+		return null;
+	}
+	if (resolving.has(layerConfig.name)) throw new Error(`Circular dependency detected: ${[...resolving, layerConfig.name].join(" -> ")}`);
+	if (!fs.existsSync(layerConfig.path)) {
+		logger$1.warn(`Layer path does not exist: ${layerConfig.path}`);
+		return null;
+	}
+	const loaded = await loadLayerConfig(layerConfig.path);
+	const mergedConfig = {
+		...layerConfig,
+		...loaded?.config || {},
+		path: layerConfig.path,
+		name: loaded?.config?.name || layerConfig.name
+	};
+	const source = determineLayerSource(layerConfig.path, root);
+	return {
+		name: mergedConfig.name,
+		path: mergedConfig.path,
+		priority,
+		config: mergedConfig,
+		extends: [],
+		isApp: false,
+		source,
+		aliases: createLayerAliases(mergedConfig.name, mergedConfig.path),
+		runtimeConfig: loaded?.runtimeConfig
+	};
+}
+/**
+* Normalize layer config from string path
+*/
+function normalizeStringConfig(configPath, root) {
+	if (configPath.startsWith(".") || configPath.startsWith("/")) {
+		const absolutePath = path.isAbsolute(configPath) ? configPath : path.resolve(root, configPath);
+		return {
+			name: path.basename(absolutePath),
+			path: absolutePath
+		};
+	}
+	const packagePath = resolvePackagePath(configPath, root);
+	if (!packagePath) {
+		logger$1.warn(`Could not resolve package: ${configPath}`);
+		return null;
+	}
+	return {
+		name: configPath,
+		path: packagePath
+	};
+}
+/**
+* Normalize layer config from object
+*/
+function normalizeObjectConfig(config, root) {
+	if (!config.path) {
+		logger$1.warn(`Layer config missing path: ${JSON.stringify(config)}`);
+		return null;
+	}
+	const absolutePath = path.isAbsolute(config.path) ? config.path : path.resolve(root, config.path);
+	return {
+		...config,
+		path: absolutePath
+	};
+}
+/**
+* Normalize layer config from string or object
+*/
+function normalizeLayerConfig(config, root) {
+	if (typeof config === "string") return normalizeStringConfig(config, root);
+	return normalizeObjectConfig(config, root);
+}
+/**
+* Resolve NPM package path
+*/
+function resolvePackagePath(packageName, root) {
+	const possiblePaths = [path.join(root, "node_modules", packageName), path.join(root, "..", "node_modules", packageName)];
+	for (const p of possiblePaths) if (fs.existsSync(p)) return p;
+	try {
+		const resolved = __require.resolve(`${packageName}/package.json`, { paths: [root] });
+		return path.dirname(resolved);
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if a path is a symlink
+*/
+function isSymlink(filePath) {
+	try {
+		return fs.lstatSync(filePath).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+/**
+* Determine layer source type
+*/
+function determineLayerSource(layerPath, _root) {
+	if (!layerPath.includes("node_modules")) return "local";
+	return isSymlink(layerPath) ? "workspace" : "npm";
+}
+const LAYER_STRUCTURE_MARKERS = [
+	"kimesh.config.ts",
+	"routes",
+	"components",
+	"composables"
+];
+/**
+* Check if a directory has valid layer structure
+*/
+function hasLayerStructure(layerPath) {
+	return LAYER_STRUCTURE_MARKERS.some((marker) => fs.existsSync(path.join(layerPath, marker)));
+}
+/**
+* Scan layers/ directory for auto-discovered layers
+*/
+async function scanLayersDirectory(layersDir, startPriority, visited) {
+	if (!fs.existsSync(layersDir)) return [];
+	const directories = fs.readdirSync(layersDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+	const layers = [];
+	let priority = startPriority;
+	for (const entry of directories) {
+		const layerName = entry.name;
+		const layerPath = path.join(layersDir, layerName);
+		if (visited.has(layerName)) continue;
+		if (!hasLayerStructure(layerPath)) {
+			logger$1.debug(`Skipping '${layerName}' - no layer structure detected`);
+			continue;
+		}
+		const loaded = await loadLayerConfig(layerPath);
+		const resolved = {
+			name: loaded?.config?.name ?? layerName,
+			path: layerPath,
+			priority,
+			config: loaded?.config ?? {
+				name: layerName,
+				path: layerPath
+			},
+			extends: [],
+			isApp: false,
+			source: "local",
+			aliases: createLayerAliases(layerName, layerPath),
+			runtimeConfig: loaded?.runtimeConfig
+		};
+		layers.push(resolved);
+		visited.add(resolved.name);
+		priority++;
+		logger$1.debug(`Auto-discovered layer: ${layerName} (priority: ${resolved.priority})`);
+	}
+	return layers;
+}
+/**
+* Load kimesh.config.ts from a layer directory using c12
+*/
+async function loadLayerConfig(layerPath) {
+	const configPath = path.join(layerPath, "kimesh.config.ts");
+	if (!fs.existsSync(configPath)) return null;
+	try {
+		const { loadConfig: loadConfig$1 } = await import("c12");
+		const { config } = await loadConfig$1({
+			name: "kimesh",
+			cwd: layerPath,
+			extend: false
+		});
+		if (config) {
+			logger$1.debug(`Loaded config from ${configPath}`);
+			const { runtimeConfig, ...layerConfig } = config;
+			return {
+				config: {
+					...layerConfig,
+					path: layerPath
+				},
+				runtimeConfig
+			};
+		}
+	} catch (error) {
+		logger$1.warn(`Failed to load config from ${configPath}: ${error}`);
+	}
+	return null;
+}
+/**
+* Filter layers by enabled list
+*/
+function filterLayersByEnabled(stack, enabled) {
+	if (enabled === "all") return stack;
+	if (enabled === "none") return {
+		layers: [stack.app],
+		app: stack.app,
+		byName: new Map([["app", stack.app]]),
+		count: 1
+	};
+	const enabledSet = new Set(["app", ...enabled]);
+	const filtered = stack.layers.filter((layer) => enabledSet.has(layer.name));
+	const byName = /* @__PURE__ */ new Map();
+	for (const layer of filtered) byName.set(layer.name, layer);
+	return {
+		layers: filtered,
+		app: stack.app,
+		byName,
+		count: filtered.length
+	};
+}
+/**
+* Get layer by name
+*/
+function getLayer(stack, name) {
+	return stack.byName.get(name);
+}
+/**
+* Check if a layer exists in the stack
+*/
+function hasLayer(stack, name) {
+	return stack.byName.has(name);
+}
+
+//#endregion
+//#region src/merge.ts
+/**
+* @kimesh/layers - Configuration Merging
+*
+* This module handles merging layer configurations with priority-based resolution.
+* Uses defu for deep merging with array concatenation.
+*/
+const logger = consola.withTag("kimesh:layers:merge");
+/**
+* Find an existing directory from a list of candidate paths
+*/
+function findExistingDir(paths) {
+	return paths.find((p) => fs.existsSync(p));
+}
+/**
+* Collect directories from a layer for a given directory name.
+* Checks both root and src/ locations.
+*/
+function collectDirsForLayer(layer, dirName, customDirs = [], prefix) {
+	const dirs = [];
+	const layerPath = layer.path;
+	const srcPath = path.join(layerPath, "src");
+	const rootDir = path.join(layerPath, dirName);
+	const srcDir = path.join(srcPath, dirName);
+	if (fs.existsSync(rootDir)) dirs.push({
+		path: rootDir,
+		layer: layer.name,
+		prefix
+	});
+	if (fs.existsSync(srcDir) && srcDir !== rootDir) dirs.push({
+		path: srcDir,
+		layer: layer.name,
+		prefix
+	});
+	for (const customDir of customDirs) {
+		if (customDir === dirName) continue;
+		const customPath = findExistingDir([path.join(layerPath, customDir), path.join(srcPath, customDir)]);
+		if (customPath) dirs.push({
+			path: customPath,
+			layer: layer.name,
+			prefix
+		});
+	}
+	return dirs;
+}
+/**
+* Merge all layer configurations into a single unified config
+*
+* Merge strategy:
+* - Routes: Collect from all layers (routes must be in correct directory structure)
+* - Components: Collect from all layers, apply prefixes
+* - Composables: Collect from all layers
+* - CSS: Concatenate all CSS files
+* - Aliases: Build complete alias map
+*/
+function mergeLayerConfigs(stack) {
+	const startTime = performance.now();
+	const routes = { dirs: [] };
+	const components = { dirs: [] };
+	const composables = { dirs: [] };
+	const css = [];
+	const aliases = {};
+	const fsAllow = [];
+	const sortedLayers = [...stack.layers].sort((a, b) => b.priority - a.priority);
+	let runtimeConfig = {};
+	for (const layer of sortedLayers) if (layer.runtimeConfig) runtimeConfig = defu(runtimeConfig, layer.runtimeConfig);
+	for (const layer of sortedLayers) {
+		const routeDirs = collectRouteDirs(layer);
+		routes.dirs.push(...routeDirs);
+		const componentDirs = collectComponentDirs(layer);
+		components.dirs.push(...componentDirs);
+		const composableDirs = collectComposableDirs(layer);
+		composables.dirs.push(...composableDirs);
+		const cssFiles = collectCssFiles(layer);
+		css.push(...cssFiles);
+		Object.assign(aliases, layer.aliases);
+		fsAllow.push(layer.path);
+	}
+	const sortByPriority = (a, b) => {
+		return (stack.byName.get(a.layer)?.priority ?? 999) - (stack.byName.get(b.layer)?.priority ?? 999);
+	};
+	routes.dirs.sort(sortByPriority);
+	components.dirs.sort(sortByPriority);
+	composables.dirs.sort(sortByPriority);
+	const elapsed = performance.now() - startTime;
+	logger.debug(`Merged ${stack.count} layers in ${elapsed.toFixed(1)}ms`);
+	logger.debug(`  Routes dirs: ${routes.dirs.length}`);
+	logger.debug(`  Component dirs: ${components.dirs.length}`);
+	logger.debug(`  Composable dirs: ${composables.dirs.length}`);
+	logger.debug(`  CSS files: ${css.length}`);
+	logger.debug(`  RuntimeConfig keys: ${Object.keys(runtimeConfig).length}`);
+	return {
+		layers: stack.layers,
+		routes,
+		components,
+		composables,
+		css,
+		aliases,
+		fsAllow,
+		runtimeConfig
+	};
+}
+/**
+* Collect route directories from a layer
+*/
+function collectRouteDirs(layer) {
+	const customFolder = layer.config.routes?.folder;
+	return collectDirsForLayer(layer, "routes", customFolder ? [customFolder] : []);
+}
+/**
+* Collect component directories from a layer
+*/
+function collectComponentDirs(layer) {
+	const prefix = resolveComponentPrefix(layer);
+	return collectDirsForLayer(layer, "components", layer.config.components?.dirs ?? [], prefix);
+}
+/**
+* Collect composable directories from a layer
+*/
+function collectComposableDirs(layer) {
+	const composableDirs = collectDirsForLayer(layer, "composables", layer.config.composables?.dirs ?? []);
+	const hooksDirs = collectDirsForLayer(layer, "hooks");
+	return [...composableDirs, ...hooksDirs];
+}
+/**
+* Collect CSS files from a layer
+*/
+function collectCssFiles(layer) {
+	const files = [];
+	const configCss = layer.config.css || [];
+	for (const cssFile of configCss) {
+		const absolutePath = path.isAbsolute(cssFile) ? cssFile : path.join(layer.path, cssFile);
+		if (fs.existsSync(absolutePath)) files.push(absolutePath);
+		else logger.warn(`CSS file not found: ${absolutePath} (layer: ${layer.name})`);
+	}
+	return files;
+}
+/**
+* Resolve component prefix for a layer
+*
+* Priority:
+* 1. Explicit prefix in config.components.prefix
+* 2. Derived from layer name: '@kimesh-layers/cms' -> 'Cms'
+* 3. App layer: no prefix
+*/
+function resolveComponentPrefix(layer) {
+	if (layer.isApp) return;
+	const configPrefix = layer.config.components?.prefix;
+	if (configPrefix === false) return;
+	if (typeof configPrefix === "string") return configPrefix;
+	return derivePrefix(layer.name);
+}
+/**
+* Derive a component prefix from layer name
+*
+* Examples:
+* - '@kimesh-layers/cms' -> 'Cms'
+* - '@company/layer-auth' -> 'Auth'
+* - 'cms' -> 'Cms'
+* - 'my-layer' -> 'MyLayer'
+*/
+function derivePrefix(layerName) {
+	const patterns = [/^@[\w-]+\/(?:layer-)?(.+)$/, /^(?:layer-)?(.+)$/];
+	let baseName = layerName;
+	for (const pattern of patterns) {
+		const match = layerName.match(pattern);
+		if (match) {
+			baseName = match[1];
+			break;
+		}
+	}
+	return toPascalCase(baseName);
+}
+/**
+* Convert string to PascalCase
+*/
+function toPascalCase(str) {
+	return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+/**
+* Merge two configs with priority (using defu)
+* Higher priority config values take precedence
+*/
+function mergeConfigs(highPriority, lowPriority) {
+	return defu(highPriority, lowPriority);
+}
+/**
+* Detect conflicts between layers
+*/
+function detectConflicts(merged) {
+	return [];
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* @kimesh/layers - Layer System for Kimesh Framework
+*
+* This package provides layer discovery, resolution, and configuration merging
+* for the Kimesh framework's Nuxt-inspired layer architecture.
+*
+* @packageDocumentation
+*/
+/**
+* Extract extends array from config file without c12 merging
+*/
+async function extractExtendsFromConfig(root) {
+	const configPath = path.join(root, "kimesh.config.ts");
+	if (!fs.existsSync(configPath)) return [];
+	const { config } = await loadConfig({
+		name: "kimesh",
+		cwd: root,
+		extend: false
+	});
+	return config?.extends ?? [];
+}
+/**
+* Prepare layers from a root directory with filtering options.
+* Returns an array of resolved layers.
+*
+* @example
+* ```ts
+* const layers = await prepareLayersFromRoot(process.cwd(), {
+*   enabled: ['blog', 'auth'],
+*   excluded: [],
+* });
+* ```
+*/
+async function prepareLayersFromRoot(root, options = {}) {
+	let stack = await resolveLayers({
+		root,
+		extends: await extractExtendsFromConfig(root),
+		layersDir: "layers"
+	});
+	if (options.enabled && options.enabled !== "all") stack = filterLayersByEnabled(stack, options.enabled);
+	const merged = mergeLayerConfigs(stack);
+	if (options.excluded && options.excluded.length > 0) {
+		const excludeSet = new Set(options.excluded);
+		return merged.layers.filter((layer) => !excludeSet.has(layer.name));
+	}
+	return merged.layers;
+}
+/**
+* Prepare layers with full configuration options.
+* Returns merged config, aliases, and fsAllow paths.
+*
+* @example
+* ```ts
+* const { merged, aliases, fsAllow } = await prepareLayersWithConfig({
+*   root: process.cwd(),
+*   extends: ['./layers/cms'],
+* });
+* ```
+*/
+async function prepareLayersWithConfig(options) {
+	let stack = await resolveLayers(options);
+	if (options.enabled) stack = filterLayersByEnabled(stack, options.enabled);
+	const merged = mergeLayerConfigs(stack);
+	return {
+		merged,
+		aliases: buildViteAliases(merged),
+		fsAllow: buildFsAllow(merged)
+	};
+}
+/**
+* High-level utility to resolve and filter layers.
+*
+* Supports two call signatures:
+* - `prepareLayers(root, options)` - Returns ResolvedLayer[]
+* - `prepareLayers(options)` - Returns { merged, aliases, fsAllow }
+*
+* @deprecated Use prepareLayersFromRoot or prepareLayersWithConfig for clearer intent
+*/
+async function prepareLayers(rootOrOptions, options) {
+	if (typeof rootOrOptions === "string") return prepareLayersFromRoot(rootOrOptions, options);
+	return prepareLayersWithConfig(rootOrOptions);
+}
+
+//#endregion
+export { ALIAS_PATTERNS, buildFsAllow, buildViteAliases, createLayerAliases, detectConflicts, filterLayersByEnabled, generateLayerAliasesFromLayers as generateLayerAliases, generateLayerInfoModule, generateTsConfigPaths, generateViteAliasConfig, getLayer, hasLayer, mergeConfigs, mergeLayerConfigs, prepareLayers, prepareLayersFromRoot, prepareLayersWithConfig, resolveLayers };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["logger","loadConfig","loadC12Config"],"sources":["../src/aliases.ts","../src/resolve.ts","../src/merge.ts","../src/index.ts"],"sourcesContent":["/**\n * @kimesh/layers - Path Aliasing\n *\n * This module generates per-layer path aliases for Vite configuration.\n */\n\nimport * as fs from 'node:fs';\nimport * as path from 'pathe';\n\nimport type { LayerStack, MergedLayerConfig, ResolvedLayer } from './types.js';\n\n/**\n * Standard alias patterns for layers\n */\nexport const ALIAS_PATTERNS = {\n  /** Layer root: #layer-name -> /path/to/layer */\n  LAYER_ROOT: '#',\n\n  /** Layer root with tilde: ~layer-name -> /path/to/layer */\n  LAYER_TILDE: '~',\n\n  /** Layer source: @layer-name -> /path/to/layer/src (or layer root) */\n  LAYER_AT: '@',\n} as const;\n\nconst SUB_DIRS = ['routes', 'components', 'composables', 'utils', 'types', 'stores'] as const;\n\n/**\n * Create aliases for a single layer\n *\n * Generated aliases:\n * - #layer-name -> layer root\n * - ~layer-name -> layer root\n * - @layer-name -> layer src/ or root\n * - #layer-name/routes -> layer routes/\n * - #layer-name/components -> layer components/\n * - #layer-name/composables -> layer composables/\n */\nexport function createLayerAliases(\n  layerName: string,\n  layerPath: string\n): Record<string, string> {\n  const aliases: Record<string, string> = {};\n  const aliasName = sanitizeLayerName(layerName);\n  const srcPath = path.join(layerPath, 'src');\n\n  aliases[`#${aliasName}`] = layerPath;\n  aliases[`~${aliasName}`] = layerPath;\n  aliases[`@${aliasName}`] = getLayerSourcePath(layerPath);\n\n  for (const subDir of SUB_DIRS) {\n    const rootSubDir = path.join(layerPath, subDir);\n    const srcSubDir = path.join(srcPath, subDir);\n\n    if (fs.existsSync(rootSubDir)) {\n      aliases[`#${aliasName}/${subDir}`] = rootSubDir;\n    }\n    if (fs.existsSync(srcSubDir)) {\n      aliases[`@${aliasName}/${subDir}`] = srcSubDir;\n    }\n  }\n\n  return aliases;\n}\n\n/**\n * Sanitize layer name for use in aliases\n *\n * @example\n * '@kimesh-layers/cms' -> 'kimesh-layers-cms'\n * '@company/layer-auth' -> 'company-layer-auth'\n * 'my-layer' -> 'my-layer'\n */\nfunction sanitizeLayerName(layerName: string): string {\n  return layerName\n    .replace(/^@/, '')\n    .replace(/\\//g, '-');\n}\n\n/**\n * Get source path for a layer (src/ if exists, otherwise root)\n */\nfunction getLayerSourcePath(layerPath: string): string {\n  const srcPath = path.join(layerPath, 'src');\n  return fs.existsSync(srcPath) ? srcPath : layerPath;\n}\n\n/**\n * Add global app aliases (@ and ~) for the app layer\n */\nfunction addAppAliases(\n  aliases: Record<string, string>,\n  appLayer: ResolvedLayer\n): void {\n  aliases['@'] = getLayerSourcePath(appLayer.path);\n  aliases['~'] = appLayer.path;\n}\n\n/**\n * Build all aliases from merged layer config\n */\nexport function buildViteAliases(merged: MergedLayerConfig): Record<string, string> {\n  const aliases: Record<string, string> = { ...merged.aliases };\n\n  const appLayer = merged.layers.find((l) => l.isApp);\n  if (appLayer) {\n    addAppAliases(aliases, appLayer);\n  }\n\n  return aliases;\n}\n\n/**\n * Generate aliases from a ResolvedLayer array\n * This is a convenience function for kit integration\n */\nexport function generateLayerAliasesFromLayers(layers: ResolvedLayer[]): Record<string, string> {\n  const aliases: Record<string, string> = {};\n\n  for (const layer of layers) {\n    Object.assign(aliases, createLayerAliases(layer.name, layer.path));\n  }\n\n  const appLayer = layers.find((l) => l.isApp);\n  if (appLayer) {\n    addAppAliases(aliases, appLayer);\n  }\n\n  return aliases;\n}\n\n/**\n * Build Vite fs.allow array from layer paths\n */\nexport function buildFsAllow(merged: MergedLayerConfig): string[] {\n  const allow = new Set<string>(merged.fsAllow);\n\n  // Add node_modules for npm layers\n  for (const layer of merged.layers) {\n    if (layer.source === 'npm' || layer.source === 'workspace') {\n      // Add the layer's parent node_modules\n      const nodeModulesPath = findNodeModulesParent(layer.path);\n      if (nodeModulesPath) {\n        allow.add(nodeModulesPath);\n      }\n    }\n  }\n\n  return Array.from(allow);\n}\n\n/**\n * Find the nearest node_modules parent directory\n */\nfunction findNodeModulesParent(filePath: string): string | null {\n  let current = filePath;\n\n  while (current !== path.dirname(current)) {\n    if (path.basename(current) === 'node_modules') {\n      return current;\n    }\n    current = path.dirname(current);\n  }\n\n  return null;\n}\n\n/**\n * Generate Vite resolve.alias configuration\n */\nexport function generateViteAliasConfig(\n  merged: MergedLayerConfig\n): Array<{ find: string | RegExp; replacement: string }> {\n  const aliases = buildViteAliases(merged);\n\n  // Convert to Vite alias format\n  // Sort by key length descending to match longer paths first\n  const sortedKeys = Object.keys(aliases).sort((a, b) => b.length - a.length);\n\n  return sortedKeys.map((key) => ({\n    find: key,\n    replacement: aliases[key],\n  }));\n}\n\n/**\n * Generate TypeScript paths configuration for tsconfig.json\n */\nexport function generateTsConfigPaths(\n  merged: MergedLayerConfig,\n  baseUrl: string = '.'\n): Record<string, string[]> {\n  const paths: Record<string, string[]> = {};\n  const aliases = buildViteAliases(merged);\n\n  for (const [alias, target] of Object.entries(aliases)) {\n    // TypeScript paths need relative paths\n    const relativePath = path.relative(baseUrl, target);\n\n    paths[alias] = [relativePath];\n    paths[`${alias}/*`] = [`${relativePath}/*`];\n  }\n\n  return paths;\n}\n\n/**\n * Generate virtual module resolving layer information\n */\nexport function generateLayerInfoModule(stack: LayerStack): string {\n  const layersInfo = stack.layers.map((layer) => ({\n    name: layer.name,\n    path: layer.path,\n    priority: layer.priority,\n    source: layer.source,\n    isApp: layer.isApp,\n  }));\n\n  return `\n// Auto-generated by @kimesh/layers\n// DO NOT EDIT\n\nexport const layers = ${JSON.stringify(layersInfo, null, 2)} as const;\n\nexport type LayerName = typeof layers[number]['name'];\n\nexport function getLayer(name: LayerName) {\n  return layers.find(l => l.name === name);\n}\n\nexport const appLayer = ${JSON.stringify(layersInfo.find((l) => l.isApp))} as const;\n`.trim();\n}\n","/**\n * @kimesh/layers - Layer Resolution\n *\n * This module handles layer discovery, resolution, and priority ordering.\n */\n\nimport * as fs from 'node:fs';\nimport * as path from 'pathe';\nimport { consola } from 'consola';\n\nimport type {\n  ExtendedLayerConfig,\n  KimeshLayerConfig,\n  LayerResolveOptions,\n  LayerStack,\n  ResolvedLayer,\n} from './types.js';\nimport { createLayerAliases } from './aliases.js';\n\nconst logger = consola.withTag('kimesh:layers');\n\n/**\n * Resolve all layers from configuration and auto-scanning\n *\n * Priority order (0 = highest):\n * - 0: App (application src/)\n * - 1+: Layers from extends[] array (order preserved)\n * - N+: Auto-scanned layers/ directory (alphabetical)\n */\nexport async function resolveLayers(\n  options: LayerResolveOptions\n): Promise<LayerStack> {\n  const { root, extends: extendedLayers = [], autoScan = true, layersDir = 'layers' } = options;\n  const startTime = performance.now();\n\n  const layers: ResolvedLayer[] = [];\n  const visited = new Set<string>();\n  const resolving = new Set<string>(); // For circular dependency detection\n\n  // Priority 0: App layer\n  const appLayer = createAppLayer(root);\n  layers.push(appLayer);\n  visited.add('app');\n\n  // Priority 1+: Extended layers from config\n  let priority = 1;\n  for (const extendedConfig of extendedLayers) {\n    const resolved = await resolveExtendedLayer(\n      extendedConfig,\n      root,\n      priority,\n      visited,\n      resolving\n    );\n    if (resolved) {\n      layers.push(resolved);\n      visited.add(resolved.name);\n      priority++;\n    }\n  }\n\n  // Auto-scan layers/ directory\n  if (autoScan) {\n    const layersDirPath = path.join(root, layersDir);\n    const autoScanned = await scanLayersDirectory(layersDirPath, priority, visited);\n    layers.push(...autoScanned);\n  }\n\n  // Build lookup map\n  const byName = new Map<string, ResolvedLayer>();\n  for (const layer of layers) {\n    byName.set(layer.name, layer);\n  }\n\n  const elapsed = performance.now() - startTime;\n  logger.debug(`Resolved ${layers.length} layers in ${elapsed.toFixed(1)}ms`);\n\n  return {\n    layers,\n    app: appLayer,\n    byName,\n    count: layers.length,\n  };\n}\n\n/**\n * Create the app layer (priority 0)\n */\nfunction createAppLayer(root: string): ResolvedLayer {\n  const srcPath = path.join(root, 'src');\n\n  return {\n    name: 'app',\n    path: fs.existsSync(srcPath) ? srcPath : root,\n    priority: 0,\n    config: {\n      name: 'app',\n      path: root,\n    },\n    extends: [],\n    isApp: true,\n    source: 'local',\n    aliases: createLayerAliases('app', root),\n  };\n}\n\n/**\n * Resolve a single extended layer configuration\n */\nasync function resolveExtendedLayer(\n  config: ExtendedLayerConfig,\n  root: string,\n  priority: number,\n  visited: Set<string>,\n  resolving: Set<string>\n): Promise<ResolvedLayer | null> {\n  // Normalize config\n  const layerConfig = normalizeLayerConfig(config, root);\n\n  if (!layerConfig) {\n    logger.warn(`Could not normalize layer config: ${JSON.stringify(config)}`);\n    return null;\n  }\n\n  // Skip if already visited\n  if (visited.has(layerConfig.name)) {\n    logger.debug(`Layer '${layerConfig.name}' already resolved, skipping`);\n    return null;\n  }\n\n  // Check for circular dependencies\n  if (resolving.has(layerConfig.name)) {\n    throw new Error(\n      `Circular dependency detected: ${[...resolving, layerConfig.name].join(' -> ')}`\n    );\n  }\n\n  // Validate layer path exists\n  if (!fs.existsSync(layerConfig.path)) {\n    logger.warn(`Layer path does not exist: ${layerConfig.path}`);\n    return null;\n  }\n\n  // Load the layer's actual config if it has one\n  const loaded = await loadLayerConfig(layerConfig.path);\n\n  // Merge loaded config with the basic config (loaded config takes precedence)\n  const mergedConfig: KimeshLayerConfig = {\n    ...layerConfig,\n    ...(loaded?.config || {}),\n    // Ensure path is set\n    path: layerConfig.path,\n    // Use loaded name if available, otherwise keep original\n    name: loaded?.config?.name || layerConfig.name,\n  };\n\n  // Determine source type\n  const source = determineLayerSource(layerConfig.path, root);\n\n  // Create resolved layer\n  const resolved: ResolvedLayer = {\n    name: mergedConfig.name,\n    path: mergedConfig.path,\n    priority,\n    config: mergedConfig,\n    extends: [], // TODO: Recursively resolve layer's extends\n    isApp: false,\n    source,\n    aliases: createLayerAliases(mergedConfig.name, mergedConfig.path),\n    runtimeConfig: loaded?.runtimeConfig,\n  };\n\n  return resolved;\n}\n\n/**\n * Normalize layer config from string path\n */\nfunction normalizeStringConfig(\n  configPath: string,\n  root: string\n): KimeshLayerConfig | null {\n  const isLocalPath = configPath.startsWith('.') || configPath.startsWith('/');\n\n  if (isLocalPath) {\n    const absolutePath = path.isAbsolute(configPath)\n      ? configPath\n      : path.resolve(root, configPath);\n\n    return {\n      name: path.basename(absolutePath),\n      path: absolutePath,\n    };\n  }\n\n  const packagePath = resolvePackagePath(configPath, root);\n  if (!packagePath) {\n    logger.warn(`Could not resolve package: ${configPath}`);\n    return null;\n  }\n\n  return {\n    name: configPath,\n    path: packagePath,\n  };\n}\n\n/**\n * Normalize layer config from object\n */\nfunction normalizeObjectConfig(\n  config: KimeshLayerConfig,\n  root: string\n): KimeshLayerConfig | null {\n  if (!config.path) {\n    logger.warn(`Layer config missing path: ${JSON.stringify(config)}`);\n    return null;\n  }\n\n  const absolutePath = path.isAbsolute(config.path)\n    ? config.path\n    : path.resolve(root, config.path);\n\n  return {\n    ...config,\n    path: absolutePath,\n  };\n}\n\n/**\n * Normalize layer config from string or object\n */\nfunction normalizeLayerConfig(\n  config: ExtendedLayerConfig,\n  root: string\n): KimeshLayerConfig | null {\n  if (typeof config === 'string') {\n    return normalizeStringConfig(config, root);\n  }\n  return normalizeObjectConfig(config, root);\n}\n\n/**\n * Resolve NPM package path\n */\nfunction resolvePackagePath(packageName: string, root: string): string | null {\n  // Try node_modules resolution\n  const possiblePaths = [\n    path.join(root, 'node_modules', packageName),\n    path.join(root, '..', 'node_modules', packageName), // Monorepo root\n  ];\n\n  for (const p of possiblePaths) {\n    if (fs.existsSync(p)) {\n      return p;\n    }\n  }\n\n  // Try require.resolve (handles symlinks in monorepos)\n  try {\n    const resolved = require.resolve(`${packageName}/package.json`, {\n      paths: [root],\n    });\n    return path.dirname(resolved);\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Check if a path is a symlink\n */\nfunction isSymlink(filePath: string): boolean {\n  try {\n    return fs.lstatSync(filePath).isSymbolicLink();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Determine layer source type\n */\nfunction determineLayerSource(\n  layerPath: string,\n  _root: string\n): 'local' | 'npm' | 'workspace' {\n  if (!layerPath.includes('node_modules')) {\n    return 'local';\n  }\n\n  return isSymlink(layerPath) ? 'workspace' : 'npm';\n}\n\nconst LAYER_STRUCTURE_MARKERS = ['kimesh.config.ts', 'routes', 'components', 'composables'] as const;\n\n/**\n * Check if a directory has valid layer structure\n */\nfunction hasLayerStructure(layerPath: string): boolean {\n  return LAYER_STRUCTURE_MARKERS.some((marker) =>\n    fs.existsSync(path.join(layerPath, marker))\n  );\n}\n\n/**\n * Scan layers/ directory for auto-discovered layers\n */\nasync function scanLayersDirectory(\n  layersDir: string,\n  startPriority: number,\n  visited: Set<string>\n): Promise<ResolvedLayer[]> {\n  if (!fs.existsSync(layersDir)) {\n    return [];\n  }\n\n  const entries = fs.readdirSync(layersDir, { withFileTypes: true });\n  const directories = entries\n    .filter((entry) => entry.isDirectory())\n    .sort((a, b) => a.name.localeCompare(b.name));\n\n  const layers: ResolvedLayer[] = [];\n  let priority = startPriority;\n\n  for (const entry of directories) {\n    const layerName = entry.name;\n    const layerPath = path.join(layersDir, layerName);\n\n    if (visited.has(layerName)) {\n      continue;\n    }\n\n    if (!hasLayerStructure(layerPath)) {\n      logger.debug(`Skipping '${layerName}' - no layer structure detected`);\n      continue;\n    }\n\n    const loaded = await loadLayerConfig(layerPath);\n\n    const resolved: ResolvedLayer = {\n      name: loaded?.config?.name ?? layerName,\n      path: layerPath,\n      priority,\n      config: loaded?.config ?? { name: layerName, path: layerPath },\n      extends: [],\n      isApp: false,\n      source: 'local',\n      aliases: createLayerAliases(layerName, layerPath),\n      runtimeConfig: loaded?.runtimeConfig,\n    };\n\n    layers.push(resolved);\n    visited.add(resolved.name);\n    priority++;\n\n    logger.debug(`Auto-discovered layer: ${layerName} (priority: ${resolved.priority})`);\n  }\n\n  return layers;\n}\n\n/**\n * Full config type (includes runtimeConfig from KimeshConfig)\n */\ninterface FullLayerConfig extends KimeshLayerConfig {\n  runtimeConfig?: Record<string, unknown>;\n}\n\n/**\n * Loaded layer config result\n */\ninterface LoadedLayerConfig {\n  config: KimeshLayerConfig;\n  runtimeConfig?: Record<string, unknown>;\n}\n\n/**\n * Load kimesh.config.ts from a layer directory using c12\n */\nasync function loadLayerConfig(layerPath: string): Promise<LoadedLayerConfig | null> {\n  const configPath = path.join(layerPath, 'kimesh.config.ts');\n\n  if (!fs.existsSync(configPath)) {\n    return null;\n  }\n\n  try {\n    const { loadConfig } = await import('c12');\n    const { config } = await loadConfig<FullLayerConfig>({\n      name: 'kimesh',\n      cwd: layerPath,\n      extend: false, // Don't auto-extend nested configs\n    });\n\n    if (config) {\n      logger.debug(`Loaded config from ${configPath}`);\n      const { runtimeConfig, ...layerConfig } = config;\n      return {\n        config: {\n          ...layerConfig,\n          path: layerPath,\n        },\n        runtimeConfig,\n      };\n    }\n  } catch (error) {\n    logger.warn(`Failed to load config from ${configPath}: ${error}`);\n  }\n\n  return null;\n}\n\n/**\n * Filter layers by enabled list\n */\nexport function filterLayersByEnabled(\n  stack: LayerStack,\n  enabled: string[] | 'all' | 'none'\n): LayerStack {\n  if (enabled === 'all') {\n    return stack;\n  }\n\n  if (enabled === 'none') {\n    // Only keep app layer\n    return {\n      layers: [stack.app],\n      app: stack.app,\n      byName: new Map([['app', stack.app]]),\n      count: 1,\n    };\n  }\n\n  // Filter to enabled layers + always include app\n  const enabledSet = new Set(['app', ...enabled]);\n  const filtered = stack.layers.filter((layer) => enabledSet.has(layer.name));\n\n  const byName = new Map<string, ResolvedLayer>();\n  for (const layer of filtered) {\n    byName.set(layer.name, layer);\n  }\n\n  return {\n    layers: filtered,\n    app: stack.app,\n    byName,\n    count: filtered.length,\n  };\n}\n\n/**\n * Get layer by name\n */\nexport function getLayer(stack: LayerStack, name: string): ResolvedLayer | undefined {\n  return stack.byName.get(name);\n}\n\n/**\n * Check if a layer exists in the stack\n */\nexport function hasLayer(stack: LayerStack, name: string): boolean {\n  return stack.byName.has(name);\n}\n","/**\n * @kimesh/layers - Configuration Merging\n *\n * This module handles merging layer configurations with priority-based resolution.\n * Uses defu for deep merging with array concatenation.\n */\n\nimport * as fs from 'node:fs';\nimport * as path from 'pathe';\nimport { defu } from 'defu';\nimport { consola } from 'consola';\n\nimport type {\n  LayerStack,\n  MergedLayerConfig,\n  ResolvedLayer,\n  LayerConflict,\n} from './types.js';\n\nconst logger = consola.withTag('kimesh:layers:merge');\n\n/**\n * Directory entry with layer information\n */\ninterface LayerDirEntry {\n  path: string;\n  layer: string;\n  prefix?: string;\n}\n\n/**\n * Find an existing directory from a list of candidate paths\n */\nfunction findExistingDir(paths: string[]): string | undefined {\n  return paths.find((p) => fs.existsSync(p));\n}\n\n/**\n * Collect directories from a layer for a given directory name.\n * Checks both root and src/ locations.\n */\nfunction collectDirsForLayer(\n  layer: ResolvedLayer,\n  dirName: string,\n  customDirs: string[] = [],\n  prefix?: string\n): LayerDirEntry[] {\n  const dirs: LayerDirEntry[] = [];\n  const layerPath = layer.path;\n  const srcPath = path.join(layerPath, 'src');\n\n  const rootDir = path.join(layerPath, dirName);\n  const srcDir = path.join(srcPath, dirName);\n\n  if (fs.existsSync(rootDir)) {\n    dirs.push({ path: rootDir, layer: layer.name, prefix });\n  }\n\n  if (fs.existsSync(srcDir) && srcDir !== rootDir) {\n    dirs.push({ path: srcDir, layer: layer.name, prefix });\n  }\n\n  for (const customDir of customDirs) {\n    if (customDir === dirName) continue;\n\n    const customPath = findExistingDir([\n      path.join(layerPath, customDir),\n      path.join(srcPath, customDir),\n    ]);\n\n    if (customPath) {\n      dirs.push({ path: customPath, layer: layer.name, prefix });\n    }\n  }\n\n  return dirs;\n}\n\n/**\n * Merge all layer configurations into a single unified config\n *\n * Merge strategy:\n * - Routes: Collect from all layers (routes must be in correct directory structure)\n * - Components: Collect from all layers, apply prefixes\n * - Composables: Collect from all layers\n * - CSS: Concatenate all CSS files\n * - Aliases: Build complete alias map\n */\nexport function mergeLayerConfigs(stack: LayerStack): MergedLayerConfig {\n  const startTime = performance.now();\n\n  const routes: MergedLayerConfig['routes'] = { dirs: [] };\n  const components: MergedLayerConfig['components'] = { dirs: [] };\n  const composables: MergedLayerConfig['composables'] = { dirs: [] };\n  const css: string[] = [];\n  const aliases: Record<string, string> = {};\n  const fsAllow: string[] = [];\n\n  // Process layers in reverse priority order (lowest priority first)\n  // This ensures higher priority layers override lower priority ones\n  const sortedLayers = [...stack.layers].sort((a, b) => b.priority - a.priority);\n\n  // Merge runtimeConfig from all layers (lowest priority first, so higher priority wins)\n  // Using defu for deep merge\n  let runtimeConfig: Record<string, unknown> = {};\n  for (const layer of sortedLayers) {\n    if (layer.runtimeConfig) {\n      runtimeConfig = defu(runtimeConfig, layer.runtimeConfig) as Record<string, unknown>;\n    }\n  }\n\n  for (const layer of sortedLayers) {\n    // Collect routes directories\n    const routeDirs = collectRouteDirs(layer);\n    routes.dirs.push(...routeDirs);\n\n    // Collect component directories\n    const componentDirs = collectComponentDirs(layer);\n    components.dirs.push(...componentDirs);\n\n    // Collect composable directories\n    const composableDirs = collectComposableDirs(layer);\n    composables.dirs.push(...composableDirs);\n\n    // Collect CSS files\n    const cssFiles = collectCssFiles(layer);\n    css.push(...cssFiles);\n\n    // Merge aliases\n    Object.assign(aliases, layer.aliases);\n\n    // Add layer path to fs.allow\n    fsAllow.push(layer.path);\n  }\n\n  // Sort all dirs by priority (highest first) for conflict resolution\n  const sortByPriority = (a: LayerDirEntry, b: LayerDirEntry): number => {\n    const priorityA = stack.byName.get(a.layer)?.priority ?? 999;\n    const priorityB = stack.byName.get(b.layer)?.priority ?? 999;\n    return priorityA - priorityB;\n  };\n\n  routes.dirs.sort(sortByPriority);\n  components.dirs.sort(sortByPriority);\n  composables.dirs.sort(sortByPriority);\n\n  const elapsed = performance.now() - startTime;\n  logger.debug(`Merged ${stack.count} layers in ${elapsed.toFixed(1)}ms`);\n  logger.debug(`  Routes dirs: ${routes.dirs.length}`);\n  logger.debug(`  Component dirs: ${components.dirs.length}`);\n  logger.debug(`  Composable dirs: ${composables.dirs.length}`);\n  logger.debug(`  CSS files: ${css.length}`);\n  logger.debug(`  RuntimeConfig keys: ${Object.keys(runtimeConfig).length}`);\n\n  return {\n    layers: stack.layers,\n    routes,\n    components,\n    composables,\n    css,\n    aliases,\n    fsAllow,\n    runtimeConfig,\n  };\n}\n\n/**\n * Collect route directories from a layer\n */\nfunction collectRouteDirs(layer: ResolvedLayer): LayerDirEntry[] {\n  const customFolder = layer.config.routes?.folder;\n  const customDirs = customFolder ? [customFolder] : [];\n  return collectDirsForLayer(layer, 'routes', customDirs);\n}\n\n/**\n * Collect component directories from a layer\n */\nfunction collectComponentDirs(layer: ResolvedLayer): LayerDirEntry[] {\n  const prefix = resolveComponentPrefix(layer);\n  const customDirs = layer.config.components?.dirs ?? [];\n  return collectDirsForLayer(layer, 'components', customDirs, prefix);\n}\n\n/**\n * Collect composable directories from a layer\n */\nfunction collectComposableDirs(layer: ResolvedLayer): LayerDirEntry[] {\n  const customDirs = layer.config.composables?.dirs ?? [];\n  const composableDirs = collectDirsForLayer(layer, 'composables', customDirs);\n  const hooksDirs = collectDirsForLayer(layer, 'hooks');\n  return [...composableDirs, ...hooksDirs];\n}\n\n/**\n * Collect CSS files from a layer\n */\nfunction collectCssFiles(layer: ResolvedLayer): string[] {\n  const files: string[] = [];\n\n  // CSS files from config\n  const configCss = layer.config.css || [];\n  for (const cssFile of configCss) {\n    const absolutePath = path.isAbsolute(cssFile)\n      ? cssFile\n      : path.join(layer.path, cssFile);\n\n    if (fs.existsSync(absolutePath)) {\n      files.push(absolutePath);\n    } else {\n      logger.warn(`CSS file not found: ${absolutePath} (layer: ${layer.name})`);\n    }\n  }\n\n  return files;\n}\n\n/**\n * Resolve component prefix for a layer\n *\n * Priority:\n * 1. Explicit prefix in config.components.prefix\n * 2. Derived from layer name: '@kimesh-layers/cms' -> 'Cms'\n * 3. App layer: no prefix\n */\nfunction resolveComponentPrefix(layer: ResolvedLayer): string | undefined {\n  // App layer never has a prefix\n  if (layer.isApp) {\n    return undefined;\n  }\n\n  // Explicit config\n  const configPrefix = layer.config.components?.prefix;\n  if (configPrefix === false) {\n    return undefined;\n  }\n  if (typeof configPrefix === 'string') {\n    return configPrefix;\n  }\n\n  // Derive from layer name\n  return derivePrefix(layer.name);\n}\n\n/**\n * Derive a component prefix from layer name\n *\n * Examples:\n * - '@kimesh-layers/cms' -> 'Cms'\n * - '@company/layer-auth' -> 'Auth'\n * - 'cms' -> 'Cms'\n * - 'my-layer' -> 'MyLayer'\n */\nfunction derivePrefix(layerName: string): string {\n  // Extract the meaningful part from scoped packages\n  const patterns = [\n    /^@[\\w-]+\\/(?:layer-)?(.+)$/, // @scope/layer-name or @scope/name\n    /^(?:layer-)?(.+)$/, // layer-name or name\n  ];\n\n  let baseName = layerName;\n  for (const pattern of patterns) {\n    const match = layerName.match(pattern);\n    if (match) {\n      baseName = match[1];\n      break;\n    }\n  }\n\n  // Convert to PascalCase\n  return toPascalCase(baseName);\n}\n\n/**\n * Convert string to PascalCase\n */\nfunction toPascalCase(str: string): string {\n  return str\n    .split(/[-_]/)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())\n    .join('');\n}\n\n/**\n * Merge two configs with priority (using defu)\n * Higher priority config values take precedence\n */\nexport function mergeConfigs<T extends object>(\n  highPriority: T,\n  lowPriority: T\n): T {\n  return defu(highPriority, lowPriority) as T;\n}\n\n/**\n * Detect conflicts between layers\n */\nexport function detectConflicts(merged: MergedLayerConfig): LayerConflict[] {\n  const conflicts: LayerConflict[] = [];\n\n  // Route conflicts would be detected at route generation time\n  // Component conflicts would be detected at auto-import time\n  // This is a placeholder for future conflict detection\n\n  return conflicts;\n}\n","/**\n * @kimesh/layers - Layer System for Kimesh Framework\n *\n * This package provides layer discovery, resolution, and configuration merging\n * for the Kimesh framework's Nuxt-inspired layer architecture.\n *\n * @packageDocumentation\n */\n\nimport * as fs from \"node:fs\";\nimport * as path from \"pathe\";\nimport { loadConfig as loadC12Config } from \"c12\";\n\nimport type {\n  ExtendedLayerConfig,\n  LayerResolveOptions,\n  MergedLayerConfig,\n  ResolvedLayer,\n} from \"./types.js\";\nimport { resolveLayers, filterLayersByEnabled } from \"./resolve.js\";\nimport { mergeLayerConfigs } from \"./merge.js\";\nimport { buildViteAliases, buildFsAllow } from \"./aliases.js\";\n\n// Type exports\nexport type {\n  KimeshLayerConfig,\n  ExtendedLayerConfig,\n  ResolvedLayer,\n  LayerStack,\n  LayerRouteConfig,\n  LayerComponentConfig,\n  LayerComposableConfig,\n  LayerUtilsConfig,\n  LayerStoresConfig,\n  LayerAutoImportConfig,\n  MergedLayerConfig,\n  LayerConflict,\n  LayerResolveOptions,\n} from \"./types.js\";\n\n// Layer resolution\nexport {\n  resolveLayers,\n  filterLayersByEnabled,\n  getLayer,\n  hasLayer,\n} from \"./resolve.js\";\n\n// Configuration merging\nexport { mergeLayerConfigs, mergeConfigs, detectConflicts } from \"./merge.js\";\n\n// Path aliasing\nexport {\n  ALIAS_PATTERNS,\n  createLayerAliases,\n  buildViteAliases,\n  generateLayerAliasesFromLayers as generateLayerAliases,\n  buildFsAllow,\n  generateViteAliasConfig,\n  generateTsConfigPaths,\n  generateLayerInfoModule,\n} from \"./aliases.js\";\n\n/**\n * Options for prepareLayers when using (root, options) signature\n */\nexport interface PrepareLayersOptions {\n  enabled?: string[] | \"all\" | \"none\";\n  excluded?: string[];\n}\n\n/**\n * Result type for prepareLayers with options object signature\n */\nexport interface PrepareLayersResult {\n  merged: MergedLayerConfig;\n  aliases: Record<string, string>;\n  fsAllow: string[];\n}\n\n/**\n * Extract extends array from config file without c12 merging\n */\nasync function extractExtendsFromConfig(\n  root: string\n): Promise<ExtendedLayerConfig[]> {\n  const configPath = path.join(root, \"kimesh.config.ts\");\n\n  if (!fs.existsSync(configPath)) {\n    return [];\n  }\n\n  const { config } = await loadC12Config<{ extends?: ExtendedLayerConfig[] }>({\n    name: \"kimesh\",\n    cwd: root,\n    extend: false,\n  });\n\n  return config?.extends ?? [];\n}\n\n/**\n * Prepare layers from a root directory with filtering options.\n * Returns an array of resolved layers.\n *\n * @example\n * ```ts\n * const layers = await prepareLayersFromRoot(process.cwd(), {\n *   enabled: ['blog', 'auth'],\n *   excluded: [],\n * });\n * ```\n */\nexport async function prepareLayersFromRoot(\n  root: string,\n  options: PrepareLayersOptions = {}\n): Promise<ResolvedLayer[]> {\n  const extendsLayers = await extractExtendsFromConfig(root);\n\n  const resolveOpts: LayerResolveOptions = {\n    root,\n    extends: extendsLayers,\n    layersDir: \"layers\",\n  };\n\n  let stack = await resolveLayers(resolveOpts);\n\n  if (options.enabled && options.enabled !== \"all\") {\n    stack = filterLayersByEnabled(stack, options.enabled);\n  }\n\n  const merged = mergeLayerConfigs(stack);\n\n  if (options.excluded && options.excluded.length > 0) {\n    const excludeSet = new Set(options.excluded);\n    return merged.layers.filter((layer) => !excludeSet.has(layer.name));\n  }\n\n  return merged.layers;\n}\n\n/**\n * Prepare layers with full configuration options.\n * Returns merged config, aliases, and fsAllow paths.\n *\n * @example\n * ```ts\n * const { merged, aliases, fsAllow } = await prepareLayersWithConfig({\n *   root: process.cwd(),\n *   extends: ['./layers/cms'],\n * });\n * ```\n */\nexport async function prepareLayersWithConfig(\n  options: LayerResolveOptions & { enabled?: string[] | \"all\" | \"none\" }\n): Promise<PrepareLayersResult> {\n  let stack = await resolveLayers(options);\n\n  if (options.enabled) {\n    stack = filterLayersByEnabled(stack, options.enabled);\n  }\n\n  const merged = mergeLayerConfigs(stack);\n  const aliases = buildViteAliases(merged);\n  const fsAllow = buildFsAllow(merged);\n\n  return { merged, aliases, fsAllow };\n}\n\n/**\n * High-level utility to resolve and filter layers.\n *\n * Supports two call signatures:\n * - `prepareLayers(root, options)` - Returns ResolvedLayer[]\n * - `prepareLayers(options)` - Returns { merged, aliases, fsAllow }\n *\n * @deprecated Use prepareLayersFromRoot or prepareLayersWithConfig for clearer intent\n */\nexport async function prepareLayers(\n  rootOrOptions:\n    | string\n    | (LayerResolveOptions & { enabled?: string[] | \"all\" | \"none\" }),\n  options?: PrepareLayersOptions\n): Promise<ResolvedLayer[] | PrepareLayersResult> {\n  if (typeof rootOrOptions === \"string\") {\n    return prepareLayersFromRoot(rootOrOptions, options);\n  }\n  return prepareLayersWithConfig(rootOrOptions);\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@kimesh/layers",
+  "version": "0.0.1",
+  "description": "Layer system for Kimesh framework - layer discovery, resolution, and configuration merging",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "c12": "^3.3.3",
+    "defu": "^6.1.4",
+    "pathe": "^2.0.3",
+    "consola": "^3.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.8",
+    "typescript": "^5.9.3",
+    "tsdown": "^0.20.0-beta.3",
+    "vitest": "^4.0.17"
+  }
+}