@kimesh/router-generator 0.2.23 → 0.2.24

package/dist/index.d.mts

@@ -95,6 +95,12 @@ interface ParsedRoute {
   isLayout: boolean;
   /** Raw route script content */
   routeScriptContent: string | null;
+  /** beforeLoad function exists */
+  hasBeforeLoad: boolean;
+  /** pendingComponent is defined */
+  hasPendingComponent: boolean;
+  /** head configuration exists */
+  hasHead: boolean;
 }
 /**
  * Generated routes output
@@ -164,21 +170,6 @@ declare class RouteScanner {
    * Process a single route file
    */
   private processFile;
-  /**
-   * Parse filename to determine route type and path
-   *
-   * Kimesh file-based routing conventions:
-   * - __root.vue → root layout (wraps everything)
-   * - index.vue → index route
-   * - about.vue → regular page (/about)
-   * - $id.vue → dynamic param (/users/:id)
-   * - $.vue → catch-all (splat route)
-   * - _auth.vue → pathless layout (underscore prefix, no URL segment)
-   * - posts.vue + posts/ → layout route (file + matching directory)
-   * - posts.index.vue → flat route notation (dot separator)
-   */
-  private parseFileName;
-  private parseDotNotationRoute;
   /**
    * Generate a valid JavaScript variable name from file path
    */
@@ -230,6 +221,22 @@ interface ExtendedParsedRoute extends ParsedRoute {
     keepAlive?: boolean;
     meta?: Record<string, unknown>;
   };
+  /** beforeLoad function options */
+  beforeLoadOptions?: {
+    isAsync: boolean;
+    hasContextParam: boolean;
+  };
+  /** pendingComponent configuration */
+  pendingOptions?: {
+    hasPendingComponent: boolean;
+    pendingMs?: number;
+    pendingMinMs?: number;
+  };
+  /** head configuration type */
+  headOptions?: {
+    isFunction: boolean;
+    isStatic: boolean;
+  };
 }
 /**
  * Parse a Vue SFC file to extract route definition information using OXC
@@ -370,6 +377,30 @@ declare function createCatchAllParam(): RouteParam;
  * Build a glob pattern for route file scanning
  */
 declare function buildGlobPattern(extensions: string[]): string;
+/**
+ * Check if a route is a pathless layout (no URL segment contribution)
+ * Pathless layouts have routePath '' or '/' and rawSegment starting with '_'
+ */
+declare function isPathlessLayout(route: RouteNode): boolean;
+/**
+ * Parse filename to determine route type and path
+ *
+ * File-based routing conventions:
+ * - __root.vue -> root layout (wraps all routes)
+ * - index.vue -> index route
+ * - route.vue -> alternative index route
+ * - about.vue -> regular page
+ * - $id.vue -> dynamic param
+ * - $.vue -> catch-all (splat route)
+ * - (group)/ -> pathless group folder (route group)
+ * - _pathless.vue + _pathless/ -> pathless layout (underscore prefix)
+ * - posts.vue + posts/ -> layout route
+ * - posts.index.vue -> flat route notation (dot separator)
+ * - posts_/ -> layout escape (underscore suffix)
+ * - -utils.vue -> excluded from routing (dash prefix)
+ * - [x] -> escape special characters (e.g., script[.]js.vue -> /script.js)
+ */
+declare function parseFileName(fileName: string, dirPath: string, hasMatchingDirectory?: boolean): ParsedFileName;
 //#endregion
 //#region src/layer-collector.d.ts
 /**
@@ -619,4 +650,4 @@ declare function generateMiddlewareTypes(result: MiddlewareScanResult): string;
  */
 declare function generateMiddlewareModule(file: MiddlewareFile): string;
 //#endregion
-export { type ExtendedParsedRoute, type GeneratedOutput, type KimeshRouterConfig, type KimeshRouterPluginOptions, type LayerMiddlewareConfig, type LayerRouteConfig, type LayerRouteNode, type LayerRouteSource, type LayerRoutesResult, type LayoutChain, LayoutResolver, type MiddlewareFile, type MiddlewareScanOptions, type MiddlewareScanResult, MiddlewareScanner, type ParsedFileName, type ParsedRoute, type ResolvedLayout, type ResolvedRouterConfig, type RouteNode, type RouteNodeType, type RouteParam, RouteScanner, RouteTreeBuilder, type TreeNode, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateMiddlewareModule, generateMiddlewareRegistry, generateMiddlewareTypes, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, mergeRoutes, parseRouteFile, processDirectoryPath, processPathSegment, scanLayerMiddleware, scanMiddlewareDir, scanMiddlewareFiles, unescapeBrackets };
+export { type ExtendedParsedRoute, type GeneratedOutput, type KimeshRouterConfig, type KimeshRouterPluginOptions, type LayerMiddlewareConfig, type LayerRouteConfig, type LayerRouteNode, type LayerRouteSource, type LayerRoutesResult, type LayoutChain, LayoutResolver, type MiddlewareFile, type MiddlewareScanOptions, type MiddlewareScanResult, MiddlewareScanner, type ParsedFileName, type ParsedRoute, type ResolvedLayout, type ResolvedRouterConfig, type RouteNode, type RouteNodeType, type RouteParam, RouteScanner, RouteTreeBuilder, type TreeNode, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateMiddlewareModule, generateMiddlewareRegistry, generateMiddlewareTypes, generateRouteTypes, generateRoutes, isDotNotationRoute, isPathlessLayout, isRootDir, kimeshRouterGenerator, mergeRoutes, parseFileName, parseRouteFile, processDirectoryPath, processPathSegment, scanLayerMiddleware, scanMiddlewareDir, scanMiddlewareFiles, unescapeBrackets };

package/dist/index.mjs

@@ -1,50 +1,15 @@
-import * as path from "pathe";
+import * as path$1 from "pathe";
 import { basename, extname, join } from "pathe";
 import * as fs from "node:fs";
 import { existsSync } from "node:fs";
 import { watch } from "chokidar";
 import fg from "fast-glob";
+import path from "path";
 import { parse } from "@vue/compiler-sfc";
 import { parseSync } from "oxc-parser";
 import { consola } from "consola";
 import { readdir } from "node:fs/promises";
 
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __exportAll = (all, symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-//#endregion
 //#region src/parser.ts
 /**
 * @kimesh/router-generator - OXC-Powered Route Parser
@@ -63,7 +28,7 @@ function parseRouteFile(code, filePath) {
 			logger$2.debug(`SFC parse errors in ${filePath}:`, errors);
 			return createEmptyParsedRoute(filePath);
 		}
-		const isLayout = filePath.includes("_layout") || filePath.includes("layout.vue");
+		const isLayout = filePath.includes("_layout") || filePath.includes("layout.vue") || isLayoutFilename(filePath);
 		const scriptContent = descriptor.script?.content || "";
 		const result = parseWithOxc(scriptContent, descriptor.scriptSetup?.content || "", filePath);
 		return {
@@ -74,9 +39,15 @@ function parseRouteFile(code, filePath) {
 			hasValidateSearch: result.hasValidateSearch ?? false,
 			isLayout,
 			routeScriptContent: result.hasRouteDefinition ? scriptContent : null,
+			hasBeforeLoad: result.hasBeforeLoad ?? false,
+			hasPendingComponent: result.hasPendingComponent ?? false,
+			hasHead: result.hasHead ?? false,
 			loaderOptions: result.loaderOptions,
 			middleware: result.middleware,
-			pageMeta: result.pageMeta
+			pageMeta: result.pageMeta,
+			beforeLoadOptions: result.beforeLoadOptions,
+			pendingOptions: result.pendingOptions,
+			headOptions: result.headOptions
 		};
 	} catch (error) {
 		logger$2.debug(`Failed to parse ${filePath}:`, error);
@@ -92,7 +63,10 @@ function parseWithOxc(scriptContent, scriptSetupContent, filePath) {
 		routePath: null,
 		hasLoader: false,
 		hasMeta: false,
-		hasValidateSearch: false
+		hasValidateSearch: false,
+		hasBeforeLoad: false,
+		hasPendingComponent: false,
+		hasHead: false
 	};
 	if (scriptContent) try {
 		const parsed = parseSync(filePath + ".ts", scriptContent, { sourceType: "module" });
@@ -136,6 +110,24 @@ function extractFromAST(program, result) {
 										case "validateSearch":
 											result.hasValidateSearch = true;
 											break;
+										case "beforeLoad":
+											result.hasBeforeLoad = true;
+											result.beforeLoadOptions = extractBeforeLoadOptions(prop.value);
+											break;
+										case "pendingComponent":
+											result.hasPendingComponent = true;
+											extractPendingOptions(routeOptions, result);
+											break;
+										case "pendingMs":
+										case "pendingMinMs":
+											if (!result.pendingOptions) result.pendingOptions = { hasPendingComponent: false };
+											if (prop.key.name === "pendingMs" && prop.value?.type === "Literal") result.pendingOptions.pendingMs = prop.value.value;
+											if (prop.key.name === "pendingMinMs" && prop.value?.type === "Literal") result.pendingOptions.pendingMinMs = prop.value.value;
+											break;
+										case "head":
+											result.hasHead = true;
+											result.headOptions = extractHeadOptions(prop.value);
+											break;
 									}
 								}
 							}
@@ -381,6 +373,54 @@ function extractIdentifierValue(node) {
 	return NOT_SERIALIZABLE;
 }
 /**
+* Check if filename indicates a layout route
+*/
+function isLayoutFilename(filePath) {
+	const fileName = path.basename(filePath, path.extname(filePath));
+	return fileName === "__root" || fileName.startsWith("_") && !fileName.startsWith("__");
+}
+/**
+* Extract beforeLoad options
+*/
+function extractBeforeLoadOptions(value) {
+	const options = {
+		isAsync: false,
+		hasContextParam: false
+	};
+	if (isFunctionExpression(value)) {
+		options.isAsync = value.async === true;
+		const firstParam = value.params?.[0];
+		if (firstParam?.type === "ObjectPattern") {
+			for (const prop of firstParam.properties || []) if (prop.type === "Property" && prop.key?.name === "context") {
+				options.hasContextParam = true;
+				break;
+			}
+		}
+	}
+	return options;
+}
+/**
+* Extract pending options from route config
+*/
+function extractPendingOptions(routeOptions, result) {
+	if (!result.pendingOptions) result.pendingOptions = { hasPendingComponent: false };
+	result.pendingOptions.hasPendingComponent = true;
+	for (const prop of routeOptions.properties || []) {
+		if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+		if (prop.key.name === "pendingMs" && prop.value?.type === "Literal") result.pendingOptions.pendingMs = prop.value.value;
+		if (prop.key.name === "pendingMinMs" && prop.value?.type === "Literal") result.pendingOptions.pendingMinMs = prop.value.value;
+	}
+}
+/**
+* Extract head options
+*/
+function extractHeadOptions(value) {
+	return {
+		isFunction: isFunctionExpression(value),
+		isStatic: value?.type === "ObjectExpression"
+	};
+}
+/**
 * Create an empty parsed route
 */
 function createEmptyParsedRoute(filePath) {
@@ -390,8 +430,11 @@ function createEmptyParsedRoute(filePath) {
 		hasLoader: false,
 		hasMeta: false,
 		hasValidateSearch: false,
-		isLayout: filePath.includes("_layout") || filePath.includes("layout.vue"),
-		routeScriptContent: null
+		isLayout: filePath.includes("_layout") || filePath.includes("layout.vue") || isLayoutFilename(filePath),
+		routeScriptContent: null,
+		hasBeforeLoad: false,
+		hasPendingComponent: false,
+		hasHead: false
 	};
 }
 
@@ -529,6 +572,120 @@ function buildGlobPattern(extensions) {
 	if (exts.length === 1) return `**/*${exts[0]}`;
 	return `**/*.{${exts.map((e) => e.slice(1)).join(",")}}`;
 }
+/**
+* Check if a route is a pathless layout (no URL segment contribution)
+* Pathless layouts have routePath '' or '/' and rawSegment starting with '_'
+*/
+function isPathlessLayout(route) {
+	if (route.type !== "layout") return false;
+	const hasEmptyPath = route.routePath === "" || route.routePath === "/";
+	const hasPathlessSegment = route.rawSegment?.startsWith("_") ?? false;
+	return hasEmptyPath && hasPathlessSegment;
+}
+/**
+* Parse filename to determine route type and path
+*
+* File-based routing conventions:
+* - __root.vue -> root layout (wraps all routes)
+* - index.vue -> index route
+* - route.vue -> alternative index route
+* - about.vue -> regular page
+* - $id.vue -> dynamic param
+* - $.vue -> catch-all (splat route)
+* - (group)/ -> pathless group folder (route group)
+* - _pathless.vue + _pathless/ -> pathless layout (underscore prefix)
+* - posts.vue + posts/ -> layout route
+* - posts.index.vue -> flat route notation (dot separator)
+* - posts_/ -> layout escape (underscore suffix)
+* - -utils.vue -> excluded from routing (dash prefix)
+* - [x] -> escape special characters (e.g., script[.]js.vue -> /script.js)
+*/
+function parseFileName(fileName, dirPath, hasMatchingDirectory = false) {
+	let rawSegment = fileName;
+	if (fileName.endsWith(".lazy")) {
+		fileName = fileName.slice(0, -5);
+		rawSegment = fileName;
+	}
+	if (fileName.startsWith("-")) return {
+		type: "page",
+		routePath: "",
+		params: [],
+		rawSegment
+	};
+	if (fileName === "__root") return {
+		type: "layout",
+		routePath: "/",
+		params: [],
+		rawSegment
+	};
+	if (fileName.startsWith("_") && !fileName.startsWith("__")) return {
+		type: "layout",
+		routePath: buildRoutePath(dirPath, ""),
+		params: [],
+		rawSegment,
+		isPathlessLayout: true
+	};
+	if (fileName === "index" || fileName === "route") return {
+		type: "index",
+		routePath: buildRoutePath(dirPath, ""),
+		params: [],
+		rawSegment
+	};
+	if (isDotNotationRoute(fileName)) return parseDotNotationRoute(fileName, dirPath, rawSegment);
+	if (fileName === "$") return {
+		type: "catch-all",
+		routePath: buildRoutePath(dirPath, ":pathMatch(.*)*"),
+		params: [createCatchAllParam()],
+		rawSegment
+	};
+	const dynamicParam = extractDynamicParam(fileName);
+	if (dynamicParam) return {
+		type: "dynamic",
+		routePath: buildRoutePath(dirPath, `:${dynamicParam}`),
+		params: [createDynamicParam(dynamicParam)],
+		rawSegment
+	};
+	if (hasMatchingDirectory) return {
+		type: "layout",
+		routePath: buildRoutePath(dirPath, fileName),
+		params: [],
+		rawSegment
+	};
+	return {
+		type: "page",
+		routePath: buildRoutePath(dirPath, unescapeBrackets(fileName)),
+		params: [],
+		rawSegment
+	};
+}
+/**
+* Parse dot notation route (e.g., posts.index.vue, posts.$postId.vue)
+*/
+function parseDotNotationRoute(fileName, dirPath, rawSegment) {
+	const segments = fileName.split(".");
+	const lastSegment = segments[segments.length - 1];
+	const parentSegments = segments.slice(0, -1);
+	const virtualDir = isRootDir(dirPath) ? parentSegments.join("/") : `${dirPath}/${parentSegments.join("/")}`;
+	if (lastSegment === "index") return {
+		type: "index",
+		routePath: buildRoutePath(virtualDir, ""),
+		params: [],
+		rawSegment
+	};
+	const dynamicParam = extractDynamicParam(lastSegment);
+	if (dynamicParam) return {
+		type: "dynamic",
+		routePath: buildRoutePath(virtualDir, `:${dynamicParam}`),
+		params: [createDynamicParam(dynamicParam)],
+		rawSegment
+	};
+	return {
+		type: "page",
+		routePath: buildRoutePath(virtualDir, unescapeBrackets(lastSegment)),
+		params: [],
+		rawSegment
+	};
+}
 
 //#endregion
 //#region src/scanner.ts
@@ -568,12 +725,11 @@ var RouteScanner = class {
 	* Process a single route file
 	*/
 	async processFile(filePath, dirSet) {
-		const fullPath = path.join(this.config.routesDirPath, filePath);
-		const fileName = path.basename(filePath, path.extname(filePath));
-		const dirPath = path.dirname(filePath);
+		const fullPath = path$1.join(this.config.routesDirPath, filePath);
+		const fileName = path$1.basename(filePath, path$1.extname(filePath));
+		const dirPath = path$1.dirname(filePath);
 		const potentialDirPath = isRootDir(dirPath) ? fileName : `${dirPath}/${fileName}`;
-		const hasMatchingDirectory = dirSet.has(potentialDirPath);
-		const { type, routePath, params, rawSegment } = this.parseFileName(fileName, dirPath, hasMatchingDirectory);
+		const { type, routePath, params, rawSegment } = parseFileName(fileName, dirPath, dirSet.has(potentialDirPath));
 		let content = fs.readFileSync(fullPath, "utf-8");
 		if (needsScaffolding(content)) {
 			const isLayout = type === "layout";
@@ -604,91 +760,6 @@ var RouteScanner = class {
 		};
 	}
 	/**
-	* Parse filename to determine route type and path
-	*
-	* Kimesh file-based routing conventions:
-	* - __root.vue → root layout (wraps everything)
-	* - index.vue → index route
-	* - about.vue → regular page (/about)
-	* - $id.vue → dynamic param (/users/:id)
-	* - $.vue → catch-all (splat route)
-	* - _auth.vue → pathless layout (underscore prefix, no URL segment)
-	* - posts.vue + posts/ → layout route (file + matching directory)
-	* - posts.index.vue → flat route notation (dot separator)
-	*/
-	parseFileName(fileName, dirPath, hasMatchingDirectory = false) {
-		const rawSegment = fileName;
-		if (fileName === "__root") return {
-			type: "layout",
-			routePath: "/",
-			params: [],
-			rawSegment
-		};
-		if (fileName.startsWith("_")) return {
-			type: "layout",
-			routePath: buildRoutePath(dirPath, ""),
-			params: [],
-			rawSegment
-		};
-		if (fileName === "index") return {
-			type: "index",
-			routePath: buildRoutePath(dirPath, ""),
-			params: [],
-			rawSegment
-		};
-		if (isDotNotationRoute(fileName)) return this.parseDotNotationRoute(fileName, dirPath, rawSegment);
-		if (fileName === "$") return {
-			type: "catch-all",
-			routePath: buildRoutePath(dirPath, ":pathMatch(.*)*"),
-			params: [createCatchAllParam()],
-			rawSegment
-		};
-		const dynamicParam = extractDynamicParam(fileName);
-		if (dynamicParam) return {
-			type: "dynamic",
-			routePath: buildRoutePath(dirPath, `:${dynamicParam}`),
-			params: [createDynamicParam(dynamicParam)],
-			rawSegment
-		};
-		if (hasMatchingDirectory) return {
-			type: "layout",
-			routePath: buildRoutePath(dirPath, fileName),
-			params: [],
-			rawSegment
-		};
-		return {
-			type: "page",
-			routePath: buildRoutePath(dirPath, fileName),
-			params: [],
-			rawSegment
-		};
-	}
-	parseDotNotationRoute(fileName, dirPath, rawSegment) {
-		const segments = fileName.split(".");
-		const lastSegment = segments[segments.length - 1];
-		const parentSegments = segments.slice(0, -1);
-		const virtualDir = isRootDir(dirPath) ? parentSegments.join("/") : `${dirPath}/${parentSegments.join("/")}`;
-		if (lastSegment === "index") return {
-			type: "index",
-			routePath: buildRoutePath(virtualDir, ""),
-			params: [],
-			rawSegment
-		};
-		const dynamicParam = extractDynamicParam(lastSegment);
-		if (dynamicParam) return {
-			type: "dynamic",
-			routePath: buildRoutePath(virtualDir, `:${dynamicParam}`),
-			params: [createDynamicParam(dynamicParam)],
-			rawSegment
-		};
-		return {
-			type: "page",
-			routePath: buildRoutePath(virtualDir, lastSegment),
-			params: [],
-			rawSegment
-		};
-	}
-	/**
 	* Generate a valid JavaScript variable name from file path
 	*/
 	generateVariableName(filePath) {
@@ -766,8 +837,8 @@ var RouteTreeBuilder = class {
 		};
 	}
 	registerLayout(node) {
-		const fileName = path.basename(node.filePath, path.extname(node.filePath));
-		const dir = path.dirname(node.filePath);
+		const fileName = path$1.basename(node.filePath, path$1.extname(node.filePath));
+		const dir = path$1.dirname(node.filePath);
 		if (fileName === "__root") {
 			this.layoutNodes.set("", node);
 			return;
@@ -978,12 +1049,12 @@ function collectImports(routes, config, imports, importMap) {
 	}
 }
 /**
-* Collect route definition imports for routes with loaders/meta
+* Collect route definition imports for routes with loaders/meta/layout features
 * Uses ?route query to extract route definitions at build time (Vite 8/rolldown compatible)
 */
 function collectRouteDefinitionImports(routes, config, imports, routeDefImportMap) {
 	for (const route of routes) {
-		if (route.parsed.hasRouteDefinition) {
+		if (route.parsed.hasRouteDefinition || route.parsed.hasLoader || route.parsed.hasBeforeLoad || route.parsed.hasPendingComponent || route.parsed.hasHead) {
 			const importPath = getImportPath(route, config);
 			const defName = `${route.variableName}_def`;
 			imports.push(`import ${defName} from '${importPath}?route'`);
@@ -998,7 +1069,7 @@ function collectRouteDefinitionImports(routes, config, imports, routeDefImportMa
 function getImportPath(route, config) {
 	const fromPath = config.generatedDirPath;
 	const toPath = route.fullPath;
-	let relativePath = path.relative(fromPath, toPath);
+	let relativePath = path$1.relative(fromPath, toPath);
 	if (!relativePath.startsWith(".")) relativePath = "./" + relativePath;
 	return relativePath;
 }
@@ -1013,7 +1084,58 @@ function generateRouteRecords(routes, config, importMap, routeDefImportMap, inde
 	};
 	const pad = "  ".repeat(indent);
 	const innerPad = "  ".repeat(indent + 1);
-	return `[\n${routes.map((route) => generateSingleRouteRecord(route, ctx, innerPad, indent)).join(",\n")}\n${pad}]`;
+	const records = [];
+	for (const route of routes) if (isPathlessLayoutWithoutIndex(route)) {
+		const hoistedRecords = generateHoistedLayoutRoutes(route, ctx, innerPad, indent);
+		records.push(...hoistedRecords);
+	} else records.push(generateSingleRouteRecord(route, ctx, innerPad, indent));
+	return `[\n${records.join(",\n")}\n${pad}]`;
+}
+/**
+* Check if route is a pathless layout without an index route
+* Such layouts should not consume the empty path
+*/
+function isPathlessLayoutWithoutIndex(route) {
+	if (!isPathlessLayout(route)) return false;
+	return !route.children.some((child) => child.routePath === "" || child.routePath === route.routePath || child.type === "index");
+}
+/**
+* Generate routes for a pathless layout by hoisting each child
+* Each child route gets wrapped by the layout component
+*/
+function generateHoistedLayoutRoutes(layout, ctx, innerPad, indent) {
+	const records = [];
+	for (const child of layout.children) {
+		const lines = [`${innerPad}{`];
+		const childPath = child.parent ? getRelativePath(child) : child.routePath;
+		lines.push(`${innerPad}  path: '${childPath}',`);
+		lines.push(generateComponentLine(layout, ctx, innerPad));
+		const layoutMetaLine = generateMetaLine(layout, ctx, innerPad);
+		if (layoutMetaLine) lines.push(layoutMetaLine);
+		const childRecord = generateChildAsIndexRoute(child, ctx, indent + 2);
+		lines.push(`${innerPad}  children: [\n${childRecord}\n${innerPad}  ],`);
+		lines.push(`${innerPad}}`);
+		records.push(lines.join("\n"));
+	}
+	return records;
+}
+/**
+* Generate a child route as an index route (path: '')
+*/
+function generateChildAsIndexRoute(route, ctx, indent) {
+	const innerPad = "  ".repeat(indent + 1);
+	const lines = [`${innerPad}{`];
+	lines.push(`${innerPad}  path: '',`);
+	if (shouldIncludeName(route)) lines.push(`${innerPad}  name: '${route.routeName}',`);
+	lines.push(generateComponentLine(route, ctx, innerPad));
+	const metaLine = generateMetaLine(route, ctx, innerPad);
+	if (metaLine) lines.push(metaLine);
+	if (route.children.length > 0) {
+		const childRecords = generateRouteRecords(route.children, ctx.config, ctx.importMap, ctx.routeDefImportMap, indent + 2);
+		lines.push(`${innerPad}  children: ${childRecords},`);
+	}
+	lines.push(`${innerPad}}`);
+	return lines.join("\n");
 }
 function generateSingleRouteRecord(route, ctx, innerPad, indent) {
 	const lines = [`${innerPad}{`];
@@ -1021,11 +1143,8 @@ function generateSingleRouteRecord(route, ctx, innerPad, indent) {
 	lines.push(`${innerPad}  path: '${routePath}',`);
 	if (shouldIncludeName(route)) lines.push(`${innerPad}  name: '${route.routeName}',`);
 	lines.push(generateComponentLine(route, ctx, innerPad));
-	const routeDefName = ctx.routeDefImportMap.get(route.filePath);
-	const metaProps = [];
-	if (routeDefName) metaProps.push(`__kimesh: ${routeDefName}`);
-	if (route.layer) metaProps.push(`__kimeshLayer: '${route.layer}'`);
-	if (metaProps.length > 0) lines.push(`${innerPad}  meta: { ${metaProps.join(", ")} },`);
+	const metaLine = generateMetaLine(route, ctx, innerPad);
+	if (metaLine) lines.push(metaLine);
 	if (route.children.length > 0) {
 		const childRecords = generateRouteRecords(route.children, ctx.config, ctx.importMap, ctx.routeDefImportMap, indent + 2);
 		lines.push(`${innerPad}  children: ${childRecords},`);
@@ -1041,6 +1160,30 @@ function generateComponentLine(route, ctx, innerPad) {
 	return `${innerPad}  component: ${ctx.importMap.get(route.filePath) || route.variableName},`;
 }
 /**
+* Generate meta line with route definition and layout-specific markers
+*/
+function generateMetaLine(route, ctx, innerPad) {
+	const metaProps = [];
+	const routeDefName = ctx.routeDefImportMap.get(route.filePath);
+	if (routeDefName) metaProps.push(`__kimesh: ${routeDefName}`);
+	if (route.layer) metaProps.push(`__kimeshLayer: '${route.layer}'`);
+	if (route.type === "layout") metaProps.push(`__kimeshIsLayout: true`);
+	if (route.parsed.hasPendingComponent) {
+		metaProps.push(`__kimeshHasPending: true`);
+		const pendingOptions = route.parsed.pendingOptions;
+		if (pendingOptions?.pendingMs !== void 0) metaProps.push(`__kimeshPendingMs: ${pendingOptions.pendingMs}`);
+		if (pendingOptions?.pendingMinMs !== void 0) metaProps.push(`__kimeshPendingMinMs: ${pendingOptions.pendingMinMs}`);
+	}
+	if (route.parsed.hasBeforeLoad) metaProps.push(`__kimeshHasBeforeLoad: true`);
+	if (route.parsed.hasHead) {
+		metaProps.push(`__kimeshHasHead: true`);
+		const headOptions = route.parsed.headOptions;
+		if (headOptions?.isFunction !== void 0) metaProps.push(`__kimeshHeadIsFunction: ${headOptions.isFunction}`);
+	}
+	if (metaProps.length === 0) return null;
+	return `${innerPad}  meta: { ${metaProps.join(", ")} },`;
+}
+/**
 * Get path relative to parent route
 */
 function getRelativePath(route) {
@@ -1106,16 +1249,16 @@ export type RoutePaths = ${routePathsUnion}
 */
 function collectAllRoutes(routes) {
 	const infos = [];
-	collectRoutesRecursively(routes, "", infos);
+	collectRoutesRecursively$1(routes, "", infos);
 	return infos;
 }
-function collectRoutesRecursively(nodes, parentPath, infos) {
+function collectRoutesRecursively$1(nodes, parentPath, infos) {
 	for (const route of nodes) {
 		const fullPath = computeFullPath(route.routePath, parentPath);
 		if (route.type === "layout") {
 			if (route.children.length > 0) {
 				const childParentPath = fullPath === "/" ? "" : fullPath;
-				collectRoutesRecursively(route.children, childParentPath, infos);
+				collectRoutesRecursively$1(route.children, childParentPath, infos);
 			}
 			continue;
 		}
@@ -1125,7 +1268,7 @@ function collectRoutesRecursively(nodes, parentPath, infos) {
 			params: collectParamsFromPath(fullPath),
 			children: collectChildPaths(route.children, fullPath)
 		});
-		if (route.children.length > 0) collectRoutesRecursively(route.children, fullPath, infos);
+		if (route.children.length > 0) collectRoutesRecursively$1(route.children, fullPath, infos);
 	}
 }
 function computeFullPath(routePath, parentPath) {
@@ -1218,7 +1361,7 @@ function extractRouteDefinition(filePath) {
 	if (!match) return EMPTY_EXPORT;
 	const routeObject = extractBalancedObject(code, match.index + match[0].length);
 	if (!routeObject) return EMPTY_EXPORT;
-	return `${extractUsedImports(code, routeObject, path.dirname(filePath))}\nexport default ${routeObject}`;
+	return `${extractUsedImports(code, routeObject, path$1.dirname(filePath))}\nexport default ${routeObject}`;
 }
 /**
 * Extract a balanced object starting from a position in the code
@@ -1334,7 +1477,7 @@ function shouldSkipImport(source) {
 	return false;
 }
 function resolveImportSource(source, fileDir) {
-	if (source.startsWith(".")) return path.resolve(fileDir, source);
+	if (source.startsWith(".")) return path$1.resolve(fileDir, source);
 	return source;
 }
 function addUsedNamedImports(namedImportStr, source, routeObject, namedImports) {
@@ -1486,18 +1629,12 @@ async function scanLayerRoutes(source, config) {
 * When a file like posts.vue has a matching posts/ directory, it becomes a layout
 */
 async function processLayerFile(filePath, routesDir, source, config, dirSet) {
-	const fullPath = path.join(routesDir, filePath);
-	const fileName = path.basename(filePath, path.extname(filePath));
-	const dirPath = path.dirname(filePath);
+	const fullPath = path$1.join(routesDir, filePath);
+	const fileName = path$1.basename(filePath, path$1.extname(filePath));
+	const dirPath = path$1.dirname(filePath);
 	if (fileName.startsWith("-")) return null;
 	const potentialDirPath = isRootDir(dirPath) ? fileName : `${dirPath}/${fileName}`;
-	const hasMatchingDirectory = dirSet.has(potentialDirPath);
-	let { type, routePath, params, rawSegment } = parseFileName(fileName, dirPath);
-	if (hasMatchingDirectory && type === "page") {
-		type = "layout";
-		routePath = buildRoutePath(dirPath, fileName);
-		logger$1.debug(`Layout route detected: ${fileName} -> ${routePath}`);
-	}
+	const { type, routePath, params, rawSegment } = parseFileName(fileName, dirPath, dirSet.has(potentialDirPath));
 	let content;
 	try {
 		content = fs.readFileSync(fullPath, "utf-8");
@@ -1521,16 +1658,14 @@ async function processLayerFile(filePath, routesDir, source, config, dirSet) {
 	const parsed = parseRouteFile(content, fullPath);
 	const variableName = generateVariableName(filePath, source.layer);
 	const finalRoutePath = applyBasePath(routePath, source.basePath);
-	const routeName = generateRouteName(finalRoutePath, source.layer);
-	const isLazy = fileName.endsWith(".lazy") || shouldBeLazy(filePath, config);
 	return {
 		filePath,
 		fullPath,
 		routePath,
 		variableName,
 		type,
-		routeName,
-		isLazy,
+		routeName: generateRouteName(finalRoutePath, source.layer),
+		isLazy: fileName.endsWith(".lazy") || shouldBeLazy(filePath, config),
 		params,
 		parsed,
 		children: [],
@@ -1542,101 +1677,6 @@ async function processLayerFile(filePath, routesDir, source, config, dirSet) {
 	};
 }
 /**
-* Parse filename to determine route type and path
-*
-* File-based routing conventions:
-* - __root.vue → root layout (wraps all routes)
-* - index.vue → index route
-* - route.vue → alternative index route
-* - about.vue → regular page
-* - $id.vue → dynamic param
-* - $.vue → catch-all (splat route)
-* - (group)/ → pathless group folder (route group)
-* - _pathless.vue + _pathless/ → pathless layout (underscore prefix)
-* - posts.vue + posts/ → layout route
-* - posts.index.vue → flat route notation (dot separator)
-* - posts_/ → layout escape (underscore suffix)
-* - -utils.vue → excluded from routing (dash prefix)
-* - [x] → escape special characters (e.g., script[.]js.vue → /script.js)
-*/
-function parseFileName(fileName, dirPath) {
-	let rawSegment = fileName;
-	if (fileName.endsWith(".lazy")) {
-		fileName = fileName.slice(0, -5);
-		rawSegment = fileName;
-	}
-	if (fileName.startsWith("-")) return {
-		type: "page",
-		routePath: "",
-		params: [],
-		rawSegment
-	};
-	if (fileName === "__root") return {
-		type: "layout",
-		routePath: "/",
-		params: [],
-		rawSegment
-	};
-	if (fileName.startsWith("_") && !fileName.startsWith("__")) return {
-		type: "layout",
-		routePath: buildRoutePath(dirPath, ""),
-		params: [],
-		rawSegment,
-		isPathlessLayout: true
-	};
-	if (fileName === "index" || fileName === "route") return {
-		type: "index",
-		routePath: buildRoutePath(dirPath, ""),
-		params: [],
-		rawSegment
-	};
-	if (isDotNotationRoute(fileName)) return parseDotNotationRoute(fileName, dirPath, rawSegment);
-	if (fileName === "$") return {
-		type: "catch-all",
-		routePath: buildRoutePath(dirPath, ":pathMatch(.*)*"),
-		params: [createCatchAllParam()],
-		rawSegment
-	};
-	const dynamicParam = extractDynamicParam(fileName);
-	if (dynamicParam) return {
-		type: "dynamic",
-		routePath: buildRoutePath(dirPath, `:${dynamicParam}`),
-		params: [createDynamicParam(dynamicParam)],
-		rawSegment
-	};
-	return {
-		type: "page",
-		routePath: buildRoutePath(dirPath, unescapeBrackets(fileName)),
-		params: [],
-		rawSegment
-	};
-}
-function parseDotNotationRoute(fileName, dirPath, rawSegment) {
-	const segments = fileName.split(".");
-	const lastSegment = segments[segments.length - 1];
-	const parentSegments = segments.slice(0, -1);
-	const virtualDir = isRootDir(dirPath) ? parentSegments.join("/") : `${dirPath}/${parentSegments.join("/")}`;
-	if (lastSegment === "index") return {
-		type: "index",
-		routePath: buildRoutePath(virtualDir, ""),
-		params: [],
-		rawSegment
-	};
-	const dynamicParam = extractDynamicParam(lastSegment);
-	if (dynamicParam) return {
-		type: "dynamic",
-		routePath: buildRoutePath(virtualDir, `:${dynamicParam}`),
-		params: [createDynamicParam(dynamicParam)],
-		rawSegment
-	};
-	return {
-		type: "page",
-		routePath: buildRoutePath(virtualDir, unescapeBrackets(lastSegment)),
-		params: [],
-		rawSegment
-	};
-}
-/**
 * Apply basePath prefix to route path
 */
 function applyBasePath(routePath, basePath) {
@@ -1678,7 +1718,6 @@ function shouldBeLazy(filePath, config) {
 
 //#endregion
 //#region src/route-merger.ts
-var route_merger_exports = /* @__PURE__ */ __exportAll({ mergeRoutes: () => mergeRoutes });
 /**
 * Merge app routes with layer routes
 * App routes (priority 0) take precedence over layer routes
@@ -1697,20 +1736,53 @@ function mergeWithRootLayout(appRoutes, layerRoutes, rootLayout) {
 	const layoutRoutesByPath = buildLayoutRoutesMap(rootLayout.children);
 	for (const layerRoute of layerRoutes) {
 		const relativePath = normalizeRoutePath(layerRoute.routePath);
-		const hostLayoutRoute = layoutRoutesByPath.get(relativePath);
-		if (hostLayoutRoute) nestLayerUnderHost(layerRoute, hostLayoutRoute);
-		else addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath);
+		const hostRouteInfo = layoutRoutesByPath.get(relativePath);
+		if (hostRouteInfo) nestLayerUnderHost(layerRoute, hostRouteInfo.route);
+		else {
+			const pathlessParent = findPathlessLayoutForLayerRoute(rootLayout.children, relativePath, layerRoute);
+			if (pathlessParent) addLayerUnderPathlessLayout(layerRoute, relativePath, pathlessParent, layoutRoutesByPath);
+			else addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath);
+		}
 	}
 	sortRouteChildren(rootLayout.children);
 	return appRoutes;
 }
 function buildLayoutRoutesMap(children) {
 	const map = /* @__PURE__ */ new Map();
-	for (const child of children) if (child.routePath && !child.routePath.includes(":")) {
+	collectRoutesRecursively(children, map, void 0);
+	return map;
+}
+/**
+* Recursively collect routes from children, including routes nested under pathless layouts.
+* Pathless layouts have empty routePath ('') and their children should be accessible
+* at the same level as their siblings.
+*/
+function collectRoutesRecursively(children, map, pathlessParent) {
+	for (const child of children) {
 		const normalizedPath = normalizeRoutePath(child.routePath);
-		map.set(normalizedPath, child);
+		if (isPathlessLayout(child) && child.children && child.children.length > 0) collectRoutesRecursively(child.children, map, child);
+		if (child.routePath && !child.routePath.includes(":")) map.set(normalizedPath, {
+			route: child,
+			pathlessParent
+		});
 	}
-	return map;
+}
+/**
+* Find a pathless layout that should wrap a layer route based on its structure.
+* A pathless layout should wrap layer routes if the layer's file path starts with
+* the pathless layout's rawSegment (e.g., '_dashboard/blog' matches '_dashboard')
+*/
+function findPathlessLayoutForLayerRoute(children, _relativePath, layerRoute) {
+	if (layerRoute?.filePath) {
+		for (const child of children) if (isPathlessLayout(child) && child.rawSegment) {
+			if (layerRoute.filePath.startsWith(child.rawSegment + "/")) return child;
+		}
+	}
+	for (const child of children) if (isPathlessLayout(child) && child.children && child.children.length > 0) {
+		const nestedPathless = findPathlessLayoutForLayerRoute(child.children, _relativePath, layerRoute);
+		if (nestedPathless) return nestedPathless;
+	}
+	return null;
 }
 function normalizeRoutePath(routePath) {
 	return routePath.startsWith("/") ? routePath.slice(1) : routePath;
@@ -1725,6 +1797,21 @@ function nestLayerUnderHost(layerRoute, hostLayoutRoute) {
 	};
 	hostLayoutRoute.children.push(layerWrapper);
 }
+/**
+* Add layer route under a pathless layout
+*/
+function addLayerUnderPathlessLayout(layerRoute, relativePath, pathlessLayout, layoutRoutesByPath) {
+	const nestedRoute = {
+		...layerRoute,
+		routePath: relativePath,
+		parent: pathlessLayout
+	};
+	pathlessLayout.children.push(nestedRoute);
+	layoutRoutesByPath.set(relativePath, {
+		route: nestedRoute,
+		pathlessParent: pathlessLayout
+	});
+}
 function addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath) {
 	const nestedRoute = {
 		...layerRoute,
@@ -1732,12 +1819,19 @@ function addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByP
 		parent: rootLayout
 	};
 	rootLayout.children.push(nestedRoute);
-	layoutRoutesByPath.set(relativePath, nestedRoute);
+	layoutRoutesByPath.set(relativePath, { route: nestedRoute });
 }
 function sortRouteChildren(children) {
 	children.sort((a, b) => {
-		if (a.routePath === "") return -1;
-		if (b.routePath === "") return 1;
+		if ((a.routePath === "" || a.routePath === "/") && (b.routePath === "" || b.routePath === "/")) {
+			const aHasIndex = a.children?.some((c) => c.routePath === "" && c.type === "page");
+			const bHasIndex = b.children?.some((c) => c.routePath === "" && c.type === "page");
+			if (aHasIndex && !bHasIndex) return 1;
+			if (!aHasIndex && bHasIndex) return -1;
+			return (a.rawSegment || "").localeCompare(b.rawSegment || "");
+		}
+		if (a.routePath === "" || a.routePath === "/") return -1;
+		if (b.routePath === "" || b.routePath === "/") return 1;
 		return a.routePath.localeCompare(b.routePath);
 	});
 }
@@ -1751,7 +1845,6 @@ function mergeWithoutRootLayout(appRoutes, layerRoutes) {
 	merged.sort((a, b) => a.routePath.localeCompare(b.routePath));
 	return merged;
 }
-var init_route_merger = __esmMin((() => {}));
 
 //#endregion
 //#region src/plugin.ts
@@ -1795,8 +1888,8 @@ function kimeshRouterGenerator(options = {}) {
 			config = {
 				...mergedConfig,
 				root,
-				routesDirPath: path.resolve(root, mergedConfig.srcDir, mergedConfig.routesDir),
-				generatedDirPath: path.resolve(root, mergedConfig.generatedDir)
+				routesDirPath: path$1.resolve(root, mergedConfig.srcDir, mergedConfig.routesDir),
+				generatedDirPath: path$1.resolve(root, mergedConfig.generatedDir)
 			};
 			scanner = new RouteScanner(config);
 			log("Config resolved:", {
@@ -1825,7 +1918,7 @@ function kimeshRouterGenerator(options = {}) {
 			if (id === "virtual:kimesh-routes" || id === "~kimesh/routes") return VIRTUAL_ROUTES_ID;
 			if (isRouteQuery(id)) {
 				const basePath = getBasePath(id);
-				return VIRTUAL_ROUTE_PREFIX + (importer ? path.resolve(path.dirname(importer.replace("\0", "")), basePath) : basePath);
+				return VIRTUAL_ROUTE_PREFIX + (importer ? path$1.resolve(path$1.dirname(importer.replace("\0", "")), basePath) : basePath);
 			}
 			return null;
 		},
@@ -1834,9 +1927,36 @@ function kimeshRouterGenerator(options = {}) {
 			if (id.startsWith(VIRTUAL_ROUTE_PREFIX)) {
 				const filePath = id.slice(14);
 				log("Extracting route definition from:", filePath);
-				return extractRouteDefinition(filePath);
+				return {
+					code: extractRouteDefinition(filePath),
+					map: null
+				};
 			}
 			return null;
+		},
+		async transform(code, id) {
+			if (!id.startsWith(VIRTUAL_ROUTE_PREFIX)) return null;
+			try {
+				const { transform } = await import("esbuild");
+				const result = await transform(code, {
+					loader: "ts",
+					target: "esnext",
+					format: "esm",
+					minify: false,
+					tsconfigRaw: { compilerOptions: {
+						importsNotUsedAsValues: "remove",
+						verbatimModuleSyntax: false
+					} }
+				});
+				log("Transformed route module:", id.slice(14).slice(-60));
+				return {
+					code: result.code,
+					map: result.map || null
+				};
+			} catch (error) {
+				log("esbuild transform failed for:", id, error);
+				return null;
+			}
 		}
 	};
 	async function generateRoutesOnce() {
@@ -1859,7 +1979,7 @@ function kimeshRouterGenerator(options = {}) {
 					priority: l.priority
 				})), config);
 				log("Collected layer routes:", layerResult.routes.length);
-				routes = mergeRoutes$1(appRoutes, layerResult.routes, config);
+				routes = mergeRoutes(appRoutes, layerResult.routes, config);
 			} else routes = appRoutes;
 			log("Final merged routes:", routes.length, routes.map((r) => r.routePath));
 			await writeGeneratedFiles();
@@ -1871,20 +1991,20 @@ function kimeshRouterGenerator(options = {}) {
 	async function writeGeneratedFiles() {
 		if (!fs.existsSync(config.generatedDirPath)) fs.mkdirSync(config.generatedDirPath, { recursive: true });
 		const routesCode = generateRoutes(routes, config);
-		const routesPath = path.join(config.generatedDirPath, "routes.gen.ts");
+		const routesPath = path$1.join(config.generatedDirPath, "routes.gen.ts");
 		fs.writeFileSync(routesPath, routesCode, "utf-8");
 		const typesCode = generateRouteTypes(routes);
-		const typesPath = path.join(config.generatedDirPath, "typed-routes.d.ts");
+		const typesPath = path$1.join(config.generatedDirPath, "typed-routes.d.ts");
 		fs.writeFileSync(typesPath, typesCode, "utf-8");
 		const layerRoutes = resolveLayerRoutes();
 		for (const layer of layerRoutes) {
-			let layerRoot = layer.layerPath || path.dirname(layer.routesDir);
+			let layerRoot = layer.layerPath || path$1.dirname(layer.routesDir);
 			try {
 				layerRoot = fs.realpathSync(layerRoot);
 			} catch {}
-			const layerKimeshDir = path.join(layerRoot, ".kimesh");
+			const layerKimeshDir = path$1.join(layerRoot, ".kimesh");
 			if (!fs.existsSync(layerKimeshDir)) fs.mkdirSync(layerKimeshDir, { recursive: true });
-			const layerTypesPath = path.join(layerKimeshDir, "typed-routes.d.ts");
+			const layerTypesPath = path$1.join(layerKimeshDir, "typed-routes.d.ts");
 			fs.writeFileSync(layerTypesPath, typesCode, "utf-8");
 			log("Generated layer types:", {
 				layer: layer.layerName,
@@ -1909,20 +2029,9 @@ function kimeshRouterGenerator(options = {}) {
 		}
 	}
 }
-/**
-* Merge app routes with layer routes
-* App routes (priority 0) take precedence over layer routes
-* Layer routes are nested under the host's root layout if one exists
-* If app has a layout route for a path, layer routes become its children
-*/
-function mergeRoutes$1(appRoutes, layerRoutes, _config) {
-	const { mergeRoutes: mergeRoutesImpl } = (init_route_merger(), __toCommonJS(route_merger_exports));
-	return mergeRoutesImpl(appRoutes, layerRoutes, _config);
-}
 
 //#endregion
 //#region src/layout-resolver.ts
-init_route_merger();
 /**
 * @kimesh/router-generator - Layout Resolver
 *
@@ -2053,7 +2162,7 @@ var LayoutResolver = class {
 	* _layout.vue → undefined
 	*/
 	extractLayoutName(filePath) {
-		const basename = path.basename(filePath, path.extname(filePath));
+		const basename = path$1.basename(filePath, path$1.extname(filePath));
 		if (basename.startsWith("_layout.") && basename !== "_layout") return basename.replace("_layout.", "");
 	}
 	/**
@@ -2359,4 +2468,4 @@ export { default } from '${normalizeImportPath(file.filePath)}';
 }
 
 //#endregion
-export { LayoutResolver, MiddlewareScanner, RouteScanner, RouteTreeBuilder, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateMiddlewareModule, generateMiddlewareRegistry, generateMiddlewareTypes, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, mergeRoutes, parseRouteFile, processDirectoryPath, processPathSegment, scanLayerMiddleware, scanMiddlewareDir, scanMiddlewareFiles, unescapeBrackets };
+export { LayoutResolver, MiddlewareScanner, RouteScanner, RouteTreeBuilder, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateMiddlewareModule, generateMiddlewareRegistry, generateMiddlewareTypes, generateRouteTypes, generateRoutes, isDotNotationRoute, isPathlessLayout, isRootDir, kimeshRouterGenerator, mergeRoutes, parseFileName, parseRouteFile, processDirectoryPath, processPathSegment, scanLayerMiddleware, scanMiddlewareDir, scanMiddlewareFiles, unescapeBrackets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimesh/router-generator",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "File-based route generator for Kimesh",
   "repository": {
     "type": "git",
@@ -41,7 +41,13 @@
     "vitest": "^4.0.17"
   },
   "peerDependencies": {
+    "esbuild": "*",
     "vite": "^8.0.0-beta.8",
     "vue-router": "^4.6.4"
+  },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    }
   }
 }