@kimesh/router-generator 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2029 @@
+import * as path from "pathe";
+import * as fs from "node:fs";
+import { watch } from "chokidar";
+import fg from "fast-glob";
+import { parse } from "@vue/compiler-sfc";
+import { parseSync } from "oxc-parser";
+import { consola } from "consola";
+
+//#region src/parser.ts
+/**
+* @kimesh/router-generator - OXC-Powered Route Parser
+*
+* Parse Vue SFC files to extract route definition information using OXC.
+* This replaces the previous regex-based approach for more accurate parsing.
+*/
+const logger$2 = consola.withTag("kimesh:router:parser");
+/**
+* Parse a Vue SFC file to extract route definition information using OXC
+*/
+function parseRouteFile(code, filePath) {
+	try {
+		const { descriptor, errors } = parse(code, { filename: filePath });
+		if (errors.length > 0) {
+			logger$2.debug(`SFC parse errors in ${filePath}:`, errors);
+			return createEmptyParsedRoute(filePath);
+		}
+		const isLayout = filePath.includes("_layout") || filePath.includes("layout.vue");
+		const scriptContent = descriptor.script?.content || "";
+		const result = parseWithOxc(scriptContent, descriptor.scriptSetup?.content || "", filePath);
+		return {
+			hasRouteDefinition: result.hasRouteDefinition ?? false,
+			routePath: result.routePath ?? null,
+			hasLoader: result.hasLoader ?? false,
+			hasMeta: result.hasMeta ?? false,
+			hasValidateSearch: result.hasValidateSearch ?? false,
+			isLayout,
+			routeScriptContent: result.hasRouteDefinition ? scriptContent : null,
+			loaderOptions: result.loaderOptions,
+			middleware: result.middleware,
+			pageMeta: result.pageMeta
+		};
+	} catch (error) {
+		logger$2.debug(`Failed to parse ${filePath}:`, error);
+		return createEmptyParsedRoute(filePath);
+	}
+}
+/**
+* Parse script content with OXC
+*/
+function parseWithOxc(scriptContent, scriptSetupContent, filePath) {
+	const result = {
+		hasRouteDefinition: false,
+		routePath: null,
+		hasLoader: false,
+		hasMeta: false,
+		hasValidateSearch: false
+	};
+	if (scriptContent) try {
+		const parsed = parseSync(filePath + ".ts", scriptContent, { sourceType: "module" });
+		if (parsed.errors.length === 0) extractFromAST(parsed.program, result);
+	} catch (e) {
+		logger$2.debug(`OXC parse error for script in ${filePath}:`, e);
+	}
+	if (scriptSetupContent) try {
+		const parsed = parseSync(filePath + ".setup.ts", scriptSetupContent, { sourceType: "module" });
+		if (parsed.errors.length === 0) extractFromSetupAST(parsed.program, result);
+	} catch (e) {}
+	return result;
+}
+/**
+* Extract route metadata from regular script AST
+*/
+function extractFromAST(program, result) {
+	for (const node of program.body) {
+		if (node.type === "ExportNamedDeclaration" && node.declaration) {
+			const decl = node.declaration;
+			if (decl.type === "VariableDeclaration") for (const declarator of decl.declarations) {
+				if (declarator.id?.name === "Route" && declarator.init) {
+					const init = declarator.init;
+					if (init.type === "CallExpression" && init.callee?.type === "CallExpression") {
+						const inner = init.callee;
+						if (isCallTo(inner, "createFileRoute")) {
+							const arg = inner.arguments?.[0];
+							if (arg?.type === "Literal" && typeof arg.value === "string") result.routePath = arg.value;
+							const routeOptions = init.arguments?.[0];
+							if (routeOptions?.type === "ObjectExpression") {
+								result.hasRouteDefinition = true;
+								for (const prop of routeOptions.properties || []) {
+									if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+									switch (prop.key.name) {
+										case "loader":
+											result.hasLoader = true;
+											break;
+										case "meta":
+											result.hasMeta = true;
+											break;
+										case "validateSearch":
+											result.hasValidateSearch = true;
+											break;
+									}
+								}
+							}
+						}
+					}
+					if (init.type === "CallExpression" && isCallTo(init, "createFileRoute")) {
+						const arg = init.arguments?.[0];
+						if (arg?.type === "Literal" && typeof arg.value === "string") result.routePath = arg.value;
+					}
+				}
+				if (declarator.id?.name === "loader") {
+					result.hasLoader = true;
+					if (isCallTo(declarator.init, "defineLoader")) result.loaderOptions = extractLoaderOptions(declarator.init);
+				}
+				if (declarator.id?.name === "middleware") {
+					if (isCallTo(declarator.init, "defineMiddleware")) result.middleware = extractMiddlewareNames(declarator.init);
+				}
+			}
+		}
+		if (node.type === "ExpressionStatement") {
+			const expr = node.expression;
+			if (expr.type === "CallExpression") {
+				if (isCallTo(expr, "definePageMeta")) {
+					result.hasMeta = true;
+					result.pageMeta = extractPageMetaOptions(expr);
+				}
+				if (isCallTo(expr, "defineRoute")) {
+					result.hasRouteDefinition = true;
+					extractDefineRouteOptions(expr, result);
+				}
+			}
+		}
+	}
+}
+/**
+* Extract from setup script AST
+*/
+function extractFromSetupAST(program, result) {
+	for (const node of program.body) if (node.type === "ExpressionStatement") {
+		const expr = node.expression;
+		if (expr.type === "CallExpression") {
+			if (isCallTo(expr, "definePageMeta")) {
+				result.hasMeta = true;
+				result.pageMeta = extractPageMetaOptions(expr);
+			}
+		}
+	}
+}
+/**
+* Check if a CallExpression calls a specific function
+*/
+function isCallTo(node, name) {
+	if (!node || node.type !== "CallExpression") return false;
+	if (node.callee?.type === "Identifier") return node.callee.name === name;
+	return false;
+}
+/**
+* Extract loader options from defineLoader call
+*/
+function extractLoaderOptions(call) {
+	const options = {
+		isAsync: false,
+		hasBeforeLoad: false,
+		dependencies: []
+	};
+	const arg = call.arguments?.[0];
+	if (!arg) return options;
+	if (isFunctionExpression(arg)) {
+		options.isAsync = arg.async === true;
+		return options;
+	}
+	if (arg.type === "ObjectExpression") extractLoaderObjectOptions(arg, options);
+	return options;
+}
+const FUNCTION_EXPRESSION_TYPES = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+function isFunctionExpression(node) {
+	return FUNCTION_EXPRESSION_TYPES.has(node.type);
+}
+function extractLoaderObjectOptions(arg, options) {
+	for (const prop of arg.properties || []) {
+		if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+		switch (prop.key.name) {
+			case "loader":
+				if (isFunctionExpression(prop.value)) options.isAsync = prop.value.async === true;
+				break;
+			case "beforeLoad":
+				options.hasBeforeLoad = true;
+				break;
+			case "dependencies":
+				if (prop.value?.type === "ArrayExpression") options.dependencies = extractStringArrayElements(prop.value.elements);
+				break;
+			case "cache":
+				if (prop.value?.type === "Literal" && typeof prop.value.value === "string") options.cacheStrategy = prop.value.value;
+				break;
+		}
+	}
+}
+function extractStringArrayElements(elements) {
+	return elements.filter((e) => e?.type === "Literal" && typeof e.value === "string").map((e) => e.value);
+}
+/**
+* Extract middleware names from defineMiddleware call
+*/
+function extractMiddlewareNames(call) {
+	const names = [];
+	const arg = call.arguments?.[0];
+	if (!arg) return names;
+	if (arg.type === "ArrayExpression") {
+		for (const elem of arg.elements || []) if (elem?.type === "Literal" && typeof elem.value === "string") names.push(elem.value);
+	}
+	if (arg.type === "Literal" && typeof arg.value === "string") names.push(arg.value);
+	return names;
+}
+/**
+* Extract page meta options from definePageMeta call
+*/
+function extractPageMetaOptions(call) {
+	const options = {};
+	const arg = call.arguments?.[0];
+	if (!arg || arg.type !== "ObjectExpression") return options;
+	for (const prop of arg.properties || []) {
+		if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+		const key = prop.key.name;
+		const { value, serializable } = extractSerializableValue(prop.value);
+		if (!serializable) continue;
+		assignPageMetaOption(options, key, value);
+	}
+	return options;
+}
+function assignPageMetaOption(options, key, value) {
+	switch (key) {
+		case "name":
+		case "path":
+		case "redirect":
+			if (typeof value === "string") options[key] = value;
+			break;
+		case "layout":
+			if (typeof value === "string" || value === false) options.layout = value;
+			break;
+		case "alias":
+			if (typeof value === "string" || Array.isArray(value)) options.alias = value;
+			break;
+		case "transition":
+		case "keepAlive":
+			if (typeof value === "boolean" || typeof value === "string") options[key] = value;
+			break;
+		case "meta":
+			if (typeof value === "object" && value !== null) options.meta = value;
+			break;
+	}
+}
+/**
+* Extract options from defineRoute call
+*/
+function extractDefineRouteOptions(call, result) {
+	const arg = call.arguments?.[0];
+	if (!arg || arg.type !== "ObjectExpression") return;
+	for (const prop of arg.properties || []) {
+		if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+		switch (prop.key.name) {
+			case "path":
+				if (prop.value?.type === "Literal" && typeof prop.value.value === "string") result.routePath = prop.value.value;
+				break;
+			case "loader":
+				result.hasLoader = true;
+				break;
+			case "meta":
+				result.hasMeta = true;
+				break;
+			case "validateSearch":
+				result.hasValidateSearch = true;
+				break;
+		}
+	}
+}
+const NOT_SERIALIZABLE = {
+	value: void 0,
+	serializable: false
+};
+/**
+* Extract JSON-serializable value from AST node
+*/
+function extractSerializableValue(node) {
+	if (!node) return NOT_SERIALIZABLE;
+	switch (node.type) {
+		case "Literal":
+		case "BooleanLiteral": return {
+			value: node.value,
+			serializable: true
+		};
+		case "ArrayExpression": return extractArrayValue(node);
+		case "ObjectExpression": return extractObjectValue(node);
+		case "UnaryExpression": return extractUnaryValue(node);
+		case "Identifier": return extractIdentifierValue(node);
+		default: return NOT_SERIALIZABLE;
+	}
+}
+function extractArrayValue(node) {
+	const values = [];
+	for (const element of node.elements || []) {
+		if (!element) continue;
+		const result = extractSerializableValue(element);
+		if (!result.serializable) return NOT_SERIALIZABLE;
+		values.push(result.value);
+	}
+	return {
+		value: values,
+		serializable: true
+	};
+}
+function extractObjectValue(node) {
+	const obj = {};
+	for (const prop of node.properties || []) {
+		if (prop.type !== "Property") continue;
+		const key = getPropertyKey(prop);
+		if (!key) continue;
+		const result = extractSerializableValue(prop.value);
+		if (!result.serializable) return NOT_SERIALIZABLE;
+		obj[key] = result.value;
+	}
+	return {
+		value: obj,
+		serializable: true
+	};
+}
+function getPropertyKey(prop) {
+	if (prop.key?.type === "Identifier") return prop.key.name;
+	if (prop.key?.type === "Literal") return String(prop.key.value);
+	return null;
+}
+function extractUnaryValue(node) {
+	if (node.operator === "-" && node.argument?.type === "Literal") return {
+		value: -node.argument.value,
+		serializable: true
+	};
+	return NOT_SERIALIZABLE;
+}
+function extractIdentifierValue(node) {
+	if (node.name === "undefined") return {
+		value: void 0,
+		serializable: true
+	};
+	return NOT_SERIALIZABLE;
+}
+/**
+* Create an empty parsed route
+*/
+function createEmptyParsedRoute(filePath) {
+	return {
+		hasRouteDefinition: false,
+		routePath: null,
+		hasLoader: false,
+		hasMeta: false,
+		hasValidateSearch: false,
+		isLayout: filePath.includes("_layout") || filePath.includes("layout.vue"),
+		routeScriptContent: null
+	};
+}
+
+//#endregion
+//#region src/scaffolder.ts
+/**
+* Check if file content needs scaffolding (empty or invalid SFC)
+*/
+function needsScaffolding(content) {
+	const trimmed = content.trim();
+	if (!trimmed) return true;
+	if (!trimmed.includes("<template") && !trimmed.includes("<script")) return true;
+	return false;
+}
+/**
+* Generate Vue SFC boilerplate for a route file
+*/
+function generateRouteScaffold(options) {
+	const { routePath, isLayout } = options;
+	if (isLayout) return `<script setup lang="ts">
+<\/script>
+
+<template>
+  <div>
+    <slot />
+  </div>
+</template>
+`;
+	return `<script lang="ts">
+export const Route = createFileRoute('${routePath}')({})
+<\/script>
+
+<script setup lang="ts">
+<\/script>
+
+<template>
+  <div>
+    <h1>Hello "${routePath === "/" ? "Home" : routePath}"!</h1>
+  </div>
+</template>
+`;
+}
+
+//#endregion
+//#region src/route-utils.ts
+/**
+* Check if directory path is root (empty or ".")
+*/
+function isRootDir(dirPath) {
+	return dirPath === "." || dirPath === "";
+}
+/**
+* Extract dynamic param name from segment (e.g., "$id" -> "id")
+*/
+function extractDynamicParam(segment) {
+	const match = segment.match(/^\$(.+)$/);
+	return match ? match[1] : null;
+}
+/**
+* Check if filename uses dot notation for flat routes
+*/
+function isDotNotationRoute(fileName) {
+	return fileName.includes(".") && !fileName.startsWith(".") && !fileName.includes("[");
+}
+/**
+* Unescape bracket notation in filenames
+* e.g., script[.]js -> script.js, api[.]v1 -> api.v1
+*/
+function unescapeBrackets(segment) {
+	return segment.replace(/\[(.)\]/g, "$1");
+}
+/**
+* Process a single path segment for dynamic params and special conventions
+*
+* Conventions:
+* - (auth) -> pathless group folder, returns empty string
+* - _auth -> pathless layout folder, returns empty string
+* - posts_ -> layout escape, strips trailing underscore
+* - $id -> dynamic param :id
+* - -folder -> excluded from routing (dash prefix)
+* - [x] -> escape special characters
+*/
+function processPathSegment(segment) {
+	if (segment.startsWith("-")) return "";
+	if (segment.startsWith("(") && segment.endsWith(")")) return "";
+	if (segment.startsWith("_") && !segment.includes("$")) return "";
+	if (segment.endsWith("_") && segment.length > 1) return segment.slice(0, -1);
+	const dynamicParam = extractDynamicParam(segment);
+	if (dynamicParam) return `:${dynamicParam}`;
+	return unescapeBrackets(segment);
+}
+/**
+* Process directory path into route segments
+*/
+function processDirectoryPath(dirPath) {
+	return dirPath.split("/").filter((part) => Boolean(part) && part !== ".").map(processPathSegment).filter(Boolean).join("/");
+}
+/**
+* Build route path from directory and segment
+*/
+function buildRoutePath(dirPath, segment) {
+	if (isRootDir(dirPath)) return segment ? `/${segment}` : "/";
+	const processedDir = processDirectoryPath(dirPath);
+	const basePath = processedDir ? `/${processedDir}` : "";
+	if (!segment) return basePath || "/";
+	return `${basePath}/${segment}`;
+}
+/**
+* Create a standard RouteParam for a dynamic parameter
+*/
+function createDynamicParam(name) {
+	return {
+		name,
+		optional: false,
+		isSplat: false,
+		repeatable: false
+	};
+}
+/**
+* Create a catch-all RouteParam
+*/
+function createCatchAllParam() {
+	return {
+		name: "pathMatch",
+		optional: false,
+		isSplat: true,
+		repeatable: true
+	};
+}
+/**
+* Build a glob pattern for route file scanning
+*/
+function buildGlobPattern(extensions) {
+	const exts = extensions.map((e) => e.startsWith(".") ? e : `.${e}`);
+	if (exts.length === 1) return `**/*${exts[0]}`;
+	return `**/*.{${exts.map((e) => e.slice(1)).join(",")}}`;
+}
+
+//#endregion
+//#region src/scanner.ts
+/**
+* Route file scanner
+* Scans the routes directory and builds route nodes
+*/
+var RouteScanner = class {
+	config;
+	routeNodes = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Scan routes directory and return route nodes
+	*/
+	async scan() {
+		const files = await fg(this.buildGlobPattern(), {
+			cwd: this.config.routesDirPath,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		});
+		const directories = await fg("**/", {
+			cwd: this.config.routesDirPath,
+			onlyDirectories: true,
+			ignore: ["**/node_modules/**"]
+		});
+		const dirSet = new Set(directories.map((d) => d.replace(/\/$/, "")));
+		this.routeNodes.clear();
+		for (const file of files.sort()) {
+			const node = await this.processFile(file, dirSet);
+			if (node) this.routeNodes.set(file, node);
+		}
+		return Array.from(this.routeNodes.values());
+	}
+	/**
+	* 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 potentialDirPath = isRootDir(dirPath) ? fileName : `${dirPath}/${fileName}`;
+		const hasMatchingDirectory = dirSet.has(potentialDirPath);
+		const { type, routePath, params, rawSegment } = this.parseFileName(fileName, dirPath, hasMatchingDirectory);
+		let content = fs.readFileSync(fullPath, "utf-8");
+		if (needsScaffolding(content)) {
+			const isLayout = type === "layout";
+			const isDynamic = type === "dynamic";
+			const paramName = params[0]?.name;
+			content = generateRouteScaffold({
+				routePath,
+				isLayout,
+				isDynamic,
+				paramName
+			});
+			fs.writeFileSync(fullPath, content, "utf-8");
+			console.log(`[kimesh:router] Scaffolded route: ${filePath}`);
+		}
+		const parsed = parseRouteFile(content, fullPath);
+		return {
+			filePath,
+			fullPath,
+			routePath,
+			variableName: this.generateVariableName(filePath),
+			type,
+			routeName: this.generateRouteName(routePath),
+			isLazy: this.shouldBeLazy(filePath),
+			params,
+			parsed,
+			children: [],
+			rawSegment
+		};
+	}
+	/**
+	* 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) {
+		return filePath.replace(/\.[^/.]+$/, "").replace(/[\/\\]/g, "_").replace(/[\[\]$().+-]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_").replace(/^(\d)/, "_$1");
+	}
+	/**
+	* Generate route name from route path
+	*/
+	generateRouteName(routePath) {
+		if (routePath === "/") return "index";
+		return routePath.slice(1).replace(/\//g, "-").replace(/:/g, "").replace(/\(.*?\)\*/g, "catchAll").replace(/\?/g, "");
+	}
+	/**
+	* Check if route should be lazy loaded based on config
+	*/
+	shouldBeLazy(filePath) {
+		const { importMode } = this.config;
+		if (typeof importMode === "function") return importMode(filePath) === "async";
+		return importMode === "async";
+	}
+	/**
+	* Get all scanned route nodes
+	*/
+	getNodes() {
+		return Array.from(this.routeNodes.values());
+	}
+	/**
+	* Build glob pattern for file scanning based on configured extensions
+	*/
+	buildGlobPattern() {
+		return buildGlobPattern(this.config.extensions);
+	}
+};
+/**
+* Create a route scanner instance
+*/
+function createScanner(config) {
+	return new RouteScanner(config);
+}
+
+//#endregion
+//#region src/tree-builder.ts
+/**
+* Build a route tree from flat route nodes
+*/
+var RouteTreeBuilder = class {
+	config;
+	root;
+	layoutNodes = /* @__PURE__ */ new Map();
+	pathlessLayoutMap = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.config = config;
+		this.root = this.createTreeNode("", "/");
+	}
+	/**
+	* Build route tree from scanned nodes
+	*/
+	build(nodes) {
+		const { layouts, pages } = this.separateLayoutsAndPages(nodes);
+		for (const layout of layouts) this.registerLayout(layout);
+		const { pathlessPages, regularPages } = this.groupPagesByPathlessLayout(pages);
+		for (const page of regularPages) this.insertNode(page);
+		const routes = this.flattenTree();
+		this.addPathlessLayoutRoutes(routes, pathlessPages);
+		return routes;
+	}
+	separateLayoutsAndPages(nodes) {
+		const layouts = [];
+		const pages = [];
+		for (const node of nodes) if (node.type === "layout") layouts.push(node);
+		else pages.push(node);
+		return {
+			layouts,
+			pages
+		};
+	}
+	registerLayout(node) {
+		const fileName = path.basename(node.filePath, path.extname(node.filePath));
+		const dir = path.dirname(node.filePath);
+		if (fileName === "__root") {
+			this.layoutNodes.set("", node);
+			return;
+		}
+		const layoutDir = isRootDir(dir) ? fileName : `${dir}/${fileName}`;
+		if (fileName.startsWith("_") && !fileName.startsWith("__")) {
+			this.layoutNodes.set(layoutDir, node);
+			const folderPath = isRootDir(dir) ? `${fileName}/` : `${dir}/${fileName}/`;
+			this.pathlessLayoutMap.set(folderPath, layoutDir);
+		} else this.layoutNodes.set(layoutDir, node);
+	}
+	groupPagesByPathlessLayout(pages) {
+		const pathlessPages = /* @__PURE__ */ new Map();
+		const regularPages = [];
+		for (const page of pages) {
+			const matchedPathless = this.findMatchingPathlessLayout(page);
+			if (matchedPathless) {
+				if (!pathlessPages.has(matchedPathless)) pathlessPages.set(matchedPathless, []);
+				pathlessPages.get(matchedPathless).push(page);
+			} else regularPages.push(page);
+		}
+		return {
+			pathlessPages,
+			regularPages
+		};
+	}
+	findMatchingPathlessLayout(page) {
+		for (const [folderPath, layoutKey] of this.pathlessLayoutMap) if (page.filePath.startsWith(folderPath)) return layoutKey;
+		return null;
+	}
+	addPathlessLayoutRoutes(routes, pathlessPages) {
+		if (pathlessPages.size === 0) return;
+		const rootLayout = routes.find((r) => r.type === "layout" && r.routePath === "/");
+		for (const [layoutKey, layoutPages] of pathlessPages) {
+			const layout = this.layoutNodes.get(layoutKey);
+			if (!layout) continue;
+			layout.children = layoutPages.map((page) => {
+				page.parent = layout;
+				return page;
+			});
+			if (rootLayout) {
+				layout.parent = rootLayout;
+				rootLayout.children = rootLayout.children || [];
+				rootLayout.children.push(layout);
+			} else routes.push(layout);
+		}
+	}
+	/**
+	* Insert a node into the tree
+	*/
+	insertNode(node) {
+		const segments = this.getPathSegments(node.routePath);
+		let current = this.root;
+		for (let i = 0; i < segments.length; i++) {
+			const segment = segments[i];
+			const isLast = i === segments.length - 1;
+			if (!current.children.has(segment)) {
+				const routePath = "/" + segments.slice(0, i + 1).join("/");
+				current.children.set(segment, this.createTreeNode(segment, routePath, current));
+			}
+			current = current.children.get(segment);
+			if (isLast) {
+				current.node = node;
+				node.parent = current.parent?.node;
+			}
+		}
+		if (segments.length === 0 && node.type === "index") this.root.node = node;
+	}
+	/**
+	* Get path segments from route path
+	*/
+	getPathSegments(routePath) {
+		return routePath.split("/").filter(Boolean);
+	}
+	/**
+	* Create a tree node
+	*/
+	createTreeNode(segment, routePath, parent) {
+		return {
+			segment,
+			routePath,
+			children: /* @__PURE__ */ new Map(),
+			parent
+		};
+	}
+	/**
+	* Flatten tree to route array
+	*/
+	flattenTree() {
+		const routes = [];
+		const rootLayout = this.layoutNodes.get("");
+		if (rootLayout) {
+			const children = this.flattenChildren(this.root);
+			if (this.root.node) {
+				this.root.node.parent = rootLayout;
+				children.unshift(this.root.node);
+			}
+			for (const child of children) child.parent = rootLayout;
+			rootLayout.children = children;
+			routes.push(rootLayout);
+		} else {
+			const children = this.flattenChildren(this.root);
+			if (this.root.node) children.unshift(this.root.node);
+			routes.push(...children);
+		}
+		return routes;
+	}
+	/**
+	* Flatten children of a tree node
+	*/
+	flattenChildren(treeNode, currentDir = "") {
+		const children = [];
+		const sortedEntries = Array.from(treeNode.children.entries()).sort(([a], [b]) => this.compareSegments(a, b));
+		for (const [segment, child] of sortedEntries) {
+			const childDir = currentDir ? `${currentDir}/${segment}` : segment;
+			const flattenedChildren = this.flattenChildNode(child, childDir);
+			children.push(...flattenedChildren);
+		}
+		return children;
+	}
+	flattenChildNode(child, childDir) {
+		const layout = this.layoutNodes.get(childDir);
+		if (layout) return [this.createLayoutWithChildren(layout, child, childDir)];
+		if (child.node) return this.flattenNodeWithChildren(child, childDir);
+		return this.flattenChildren(child, childDir);
+	}
+	createLayoutWithChildren(layout, child, childDir) {
+		layout.children = this.flattenChildren(child, childDir);
+		if (child.node && child.node.type !== "layout") {
+			child.node.parent = layout;
+			layout.children.unshift(child.node);
+		}
+		for (const layoutChild of layout.children) layoutChild.parent = layout;
+		return layout;
+	}
+	flattenNodeWithChildren(child, childDir) {
+		const node = child.node;
+		if (node.type === "layout") {
+			node.children = this.flattenChildren(child, childDir);
+			return [node];
+		}
+		return [node, ...this.flattenChildren(child, childDir)];
+	}
+	/**
+	* Compare segments for sorting
+	* Order: static > dynamic > catch-all
+	*/
+	compareSegments(a, b) {
+		const aScore = this.getSegmentScore(a);
+		const bScore = this.getSegmentScore(b);
+		if (aScore !== bScore) return aScore - bScore;
+		return a.localeCompare(b);
+	}
+	/**
+	* Get sorting score for a segment
+	*/
+	getSegmentScore(segment) {
+		if (segment.includes("(.*)*") || segment.includes("pathMatch")) return 100;
+		if (segment.startsWith(":")) return 50;
+		return 0;
+	}
+};
+/**
+* Create a route tree builder
+*/
+function createTreeBuilder(config) {
+	return new RouteTreeBuilder(config);
+}
+/**
+* Build route tree from nodes
+*/
+function buildRouteTree(nodes, config) {
+	return new RouteTreeBuilder(config).build(nodes);
+}
+
+//#endregion
+//#region src/codegen/routes.ts
+/**
+* Generate routes.gen.ts content
+*/
+function generateRoutes(routes, config) {
+	const imports = [];
+	const importMap = /* @__PURE__ */ new Map();
+	const routeDefImportMap = /* @__PURE__ */ new Map();
+	collectImports(routes, config, imports, importMap);
+	collectRouteDefinitionImports(routes, config, imports, routeDefImportMap);
+	const routeRecords = generateRouteRecords(routes, config, importMap, routeDefImportMap);
+	return `// Auto-generated by @kimesh/router-generator
+// Do not edit this file manually
+
+${imports.join("\n")}
+
+export const routes = ${routeRecords}
+`;
+}
+/**
+* Collect imports from route nodes
+*/
+function collectImports(routes, config, imports, importMap) {
+	for (const route of routes) {
+		if (!route.isLazy) {
+			const importPath = getImportPath(route, config);
+			const importName = route.variableName;
+			imports.push(`import ${importName} from '${importPath}'`);
+			importMap.set(route.filePath, importName);
+		}
+		if (route.children.length > 0) collectImports(route.children, config, imports, importMap);
+	}
+}
+/**
+* Collect route definition imports for routes with loaders/meta
+* 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) {
+			const importPath = getImportPath(route, config);
+			const defName = `${route.variableName}_def`;
+			imports.push(`import ${defName} from '${importPath}?route'`);
+			routeDefImportMap.set(route.filePath, defName);
+		}
+		if (route.children.length > 0) collectRouteDefinitionImports(route.children, config, imports, routeDefImportMap);
+	}
+}
+/**
+* Get import path relative to generated file
+*/
+function getImportPath(route, config) {
+	const fromPath = config.generatedDirPath;
+	const toPath = route.fullPath;
+	let relativePath = path.relative(fromPath, toPath);
+	if (!relativePath.startsWith(".")) relativePath = "./" + relativePath;
+	return relativePath;
+}
+/**
+* Generate route records array
+*/
+function generateRouteRecords(routes, config, importMap, routeDefImportMap, indent = 0) {
+	const ctx = {
+		config,
+		importMap,
+		routeDefImportMap
+	};
+	const pad = "  ".repeat(indent);
+	const innerPad = "  ".repeat(indent + 1);
+	return `[\n${routes.map((route) => generateSingleRouteRecord(route, ctx, innerPad, indent)).join(",\n")}\n${pad}]`;
+}
+function generateSingleRouteRecord(route, ctx, innerPad, indent) {
+	const lines = [`${innerPad}{`];
+	const routePath = route.parent ? getRelativePath(route) : route.routePath;
+	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(", ")} },`);
+	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 shouldIncludeName(route) {
+	return route.type !== "layout" || route.children.length === 0;
+}
+function generateComponentLine(route, ctx, innerPad) {
+	if (route.isLazy) return `${innerPad}  component: () => import('${getImportPath(route, ctx.config)}'),`;
+	return `${innerPad}  component: ${ctx.importMap.get(route.filePath) || route.variableName},`;
+}
+/**
+* Get path relative to parent route
+*/
+function getRelativePath(route) {
+	if (!route.parent) return route.routePath;
+	const parentPath = route.parent.routePath;
+	const routePath = route.routePath;
+	if (parentPath === "/") return routePath === "/" ? "" : stripLeadingSlash(routePath);
+	let relativePath = routePath;
+	if (relativePath.startsWith(parentPath)) relativePath = relativePath.slice(parentPath.length);
+	relativePath = stripLeadingSlash(relativePath);
+	return !relativePath && route.type === "index" ? "" : relativePath;
+}
+function stripLeadingSlash(path$1) {
+	return path$1.startsWith("/") ? path$1.slice(1) : path$1;
+}
+
+//#endregion
+//#region src/codegen/types.ts
+/**
+* Generate typed-routes.d.ts content with comprehensive type safety
+*/
+function generateRouteTypes(routes) {
+	const routeInfos = collectAllRoutes(routes);
+	const routeMapEntries = routeInfos.map((r) => generateRouteRecordInfo(r)).join("\n");
+	const routePathsUnion = routeInfos.length > 0 ? routeInfos.map((r) => `'${r.path}'`).join(" | ") : "never";
+	return `/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// Auto-generated by @kimesh/router-generator
+// Do not edit this file manually
+
+import type {
+  RouteRecordInfo,
+  ParamValue,
+  ParamValueOneOrMore,
+  ParamValueZeroOrMore,
+  ParamValueZeroOrOne,
+} from 'vue-router'
+
+// Augment @kimesh/router-runtime for typed composables
+declare module '@kimesh/router-runtime' {
+  export interface RouteNamedMap {
+${routeMapEntries}
+  }
+}
+
+// Augment vue-router for typed router.push(), useRoute(), etc.
+declare module 'vue-router' {
+  export interface TypesConfig {
+    RouteNamedMap: import('@kimesh/router-runtime').RouteNamedMap
+  }
+}
+
+/** Union of all route names/paths */
+export type RouteNames = ${routePathsUnion}
+
+/** Union of all route paths */
+export type RoutePaths = ${routePathsUnion}
+`;
+}
+/**
+* Collect all routes recursively into flat array
+*/
+function collectAllRoutes(routes) {
+	const infos = [];
+	collectRoutesRecursively(routes, "", infos);
+	return infos;
+}
+function collectRoutesRecursively(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);
+			}
+			continue;
+		}
+		infos.push({
+			name: fullPath,
+			path: fullPath,
+			params: collectParamsFromPath(fullPath),
+			children: collectChildPaths(route.children, fullPath)
+		});
+		if (route.children.length > 0) collectRoutesRecursively(route.children, fullPath, infos);
+	}
+}
+function computeFullPath(routePath, parentPath) {
+	if (routePath === "" || routePath === "/") return parentPath || "/";
+	if (routePath.startsWith("/")) return routePath;
+	return parentPath === "/" ? `/${routePath}` : `${parentPath}/${routePath}`;
+}
+function collectChildPaths(children, parentFullPath) {
+	return children.filter((c) => c.type !== "layout").map((c) => computeFullPath(c.routePath, parentFullPath));
+}
+/**
+* Extract params from a route path
+* e.g., '/users/:userId/posts/:postId' -> [{ name: 'userId', ... }, { name: 'postId', ... }]
+*/
+function collectParamsFromPath(routePath) {
+	const params = [];
+	const regex = /:([a-zA-Z_][a-zA-Z0-9_]*)(\?)?(\+)?(\*)?/g;
+	let match;
+	while ((match = regex.exec(routePath)) !== null) {
+		const name = match[1];
+		const hasQuestion = match[2] === "?";
+		const hasPlus = match[3] === "+";
+		const hasStar = match[4] === "*";
+		params.push({
+			name,
+			optional: hasQuestion || hasStar,
+			isSplat: hasStar,
+			repeatable: hasPlus || hasStar
+		});
+	}
+	return params;
+}
+/**
+* Generate RouteRecordInfo entry for a route
+*/
+function generateRouteRecordInfo(route) {
+	const rawParams = generateParamsType(route.params, true);
+	const params = generateParamsType(route.params, false);
+	const children = route.children.length > 0 ? route.children.map((c) => `'${c}'`).join(" | ") : "never";
+	return `    '${route.name}': RouteRecordInfo<
+      '${route.name}',
+      '${route.path}',
+      ${rawParams},
+      ${params},
+      ${children}
+    >,`;
+}
+/**
+* Generate params type object
+*/
+function generateParamsType(params, isRaw) {
+	if (params.length === 0) return "Record<never, never>";
+	return `{ ${params.map((p) => formatParamEntry(p, isRaw)).join("; ")} }`;
+}
+function formatParamEntry(param, isRaw) {
+	const optional = param.optional ? "?" : "";
+	const type = getParamValueType(param, isRaw);
+	return `${param.name}${optional}: ${type}`;
+}
+function getParamValueType(param, isRaw) {
+	if (param.repeatable) return param.optional ? `ParamValueZeroOrMore<${isRaw}>` : `ParamValueOneOrMore<${isRaw}>`;
+	if (param.optional) return `ParamValueZeroOrOne<${isRaw}>`;
+	return `ParamValue<${isRaw}>`;
+}
+
+//#endregion
+//#region src/extract-route.ts
+const ROUTE_QUERY_RE = /[?&]route\b/;
+const CREATE_FILE_ROUTE_START_RE = /export\s+const\s+Route\s*=\s*createFileRoute\s*\(\s*['"`][^'"`]*['"`]\s*\)\s*\(/;
+const EMPTY_EXPORT = "export default {}";
+/**
+* Check if the id has a ?route query parameter
+*/
+function isRouteQuery(id) {
+	return ROUTE_QUERY_RE.test(id);
+}
+/**
+* Get the base path without the ?route query
+*/
+function getBasePath(id) {
+	return id.split("?")[0];
+}
+/**
+* Extract route definition from a Vue SFC file
+* Returns the route config object as a module with default export
+*/
+function extractRouteDefinition(filePath) {
+	const code = fs.readFileSync(filePath, "utf-8");
+	const match = CREATE_FILE_ROUTE_START_RE.exec(code);
+	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}`;
+}
+/**
+* Extract a balanced object starting from a position in the code
+* Handles nested braces, strings, template literals, and comments
+*/
+function extractBalancedObject(code, startPos) {
+	let i = skipWhitespace(code, startPos);
+	if (code[i] !== "{") return null;
+	const objectStart = i;
+	const state = {
+		inString: null,
+		inTemplateString: false,
+		inLineComment: false,
+		inBlockComment: false,
+		depth: 0
+	};
+	for (; i < code.length; i++) {
+		const result = processCharacter(code, i, state);
+		if (result.skip) {
+			i = result.newIndex ?? i;
+			continue;
+		}
+		if (result.foundEnd) return code.slice(objectStart, i + 1);
+	}
+	return null;
+}
+function skipWhitespace(code, pos) {
+	while (pos < code.length && /\s/.test(code[pos])) pos++;
+	return pos;
+}
+function processCharacter(code, i, state) {
+	const char = code[i];
+	const nextChar = code[i + 1];
+	const prevChar = code[i - 1];
+	if (state.inLineComment) {
+		if (char === "\n") state.inLineComment = false;
+		return { skip: true };
+	}
+	if (state.inBlockComment) {
+		if (char === "*" && nextChar === "/") {
+			state.inBlockComment = false;
+			return {
+				skip: true,
+				newIndex: i + 1
+			};
+		}
+		return { skip: true };
+	}
+	if (state.inTemplateString) {
+		if (char === "`") state.inTemplateString = false;
+		return { skip: true };
+	}
+	if (state.inString) {
+		if (char === state.inString && prevChar !== "\\") state.inString = null;
+		return { skip: true };
+	}
+	if (char === "/" && nextChar === "/") {
+		state.inLineComment = true;
+		return { skip: true };
+	}
+	if (char === "/" && nextChar === "*") {
+		state.inBlockComment = true;
+		return {
+			skip: true,
+			newIndex: i + 1
+		};
+	}
+	if (char === "`") {
+		state.inTemplateString = true;
+		return { skip: true };
+	}
+	if (char === "\"" || char === "'") {
+		state.inString = char;
+		return { skip: true };
+	}
+	if (char === "{") {
+		state.depth++;
+		return { skip: false };
+	}
+	if (char === "}") {
+		state.depth--;
+		if (state.depth === 0) return {
+			skip: false,
+			foundEnd: true
+		};
+	}
+	return { skip: false };
+}
+const IMPORT_REGEX = /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+const SKIP_IMPORT_SOURCES = new Set(["vue", "@kimesh/router-runtime"]);
+/**
+* Extract imports that are used in the route object
+* Converts relative imports to absolute paths for virtual module compatibility
+*/
+function extractUsedImports(code, routeObject, fileDir) {
+	const namedImports = /* @__PURE__ */ new Map();
+	const defaultImports = /* @__PURE__ */ new Map();
+	let match;
+	while ((match = IMPORT_REGEX.exec(code)) !== null) processImportMatch(match, routeObject, fileDir, namedImports, defaultImports);
+	return buildImportStatements(namedImports, defaultImports);
+}
+function processImportMatch(match, routeObject, fileDir, namedImports, defaultImports) {
+	const namedImportStr = match[1];
+	const defaultImport = match[2];
+	let source = match[3];
+	if (shouldSkipImport(source)) return;
+	source = resolveImportSource(source, fileDir);
+	if (namedImportStr) addUsedNamedImports(namedImportStr, source, routeObject, namedImports);
+	else if (defaultImport && routeObject.includes(defaultImport)) defaultImports.set(source, defaultImport);
+}
+function shouldSkipImport(source) {
+	for (const skip of SKIP_IMPORT_SOURCES) if (source.includes(skip)) return true;
+	return false;
+}
+function resolveImportSource(source, fileDir) {
+	if (source.startsWith(".")) return path.resolve(fileDir, source);
+	return source;
+}
+function addUsedNamedImports(namedImportStr, source, routeObject, namedImports) {
+	const usedImports = namedImportStr.split(",").map((s) => s.trim().split(" as ")[0].trim()).filter((name) => {
+		return (/* @__PURE__ */ new RegExp(`\\b${name}\\b`)).test(routeObject);
+	});
+	if (usedImports.length === 0) return;
+	if (!namedImports.has(source)) namedImports.set(source, /* @__PURE__ */ new Set());
+	for (const imp of usedImports) namedImports.get(source).add(imp);
+}
+function buildImportStatements(namedImports, defaultImports) {
+	const statements = [];
+	for (const [source, specifiers] of namedImports) statements.push(`import { ${Array.from(specifiers).join(", ")} } from '${source}'`);
+	for (const [source, name] of defaultImports) statements.push(`import ${name} from '${source}'`);
+	return statements.join("\n");
+}
+
+//#endregion
+//#region src/layer-collector.ts
+/**
+* @kimesh/router-generator - Layer Route Collector
+*
+* Collects routes from multiple layers with priority-based resolution.
+*/
+const logger$1 = consola.withTag("kimesh:router:layer-collector");
+/**
+* Collect routes from all configured layers and build proper route trees
+*/
+async function collectLayerRoutes(sources, config) {
+	const startTime = performance.now();
+	const allRoutes = [];
+	const byLayer = /* @__PURE__ */ new Map();
+	const perLayerTiming = /* @__PURE__ */ new Map();
+	const scanPromises = [...sources].sort((a, b) => a.priority - b.priority).map(async (source) => {
+		const layerStartTime = performance.now();
+		return {
+			source,
+			routes: buildLayerRouteTree(await scanLayerRoutes(source, config), source),
+			time: performance.now() - layerStartTime
+		};
+	});
+	const results = await Promise.all(scanPromises);
+	for (const { source, routes, time } of results) {
+		allRoutes.push(...routes);
+		byLayer.set(source.layer, routes);
+		perLayerTiming.set(source.layer, time);
+		logger$1.debug(`Layer '${source.layer}': ${routes.length} route tree(s) in ${time.toFixed(1)}ms`);
+	}
+	const totalTime = performance.now() - startTime;
+	logger$1.info(`Collected ${allRoutes.length} routes from ${sources.length} layers in ${totalTime.toFixed(1)}ms`);
+	return {
+		routes: allRoutes,
+		byLayer,
+		timing: {
+			totalMs: totalTime,
+			perLayer: perLayerTiming
+		}
+	};
+}
+/**
+* Build a proper route tree for a layer's routes
+* Layouts become parents with children, pages become leaves
+*
+* Routes are organized by their file path which directly maps to URL path.
+* Example: routes/blog/_layout.vue → /blog layout
+*          routes/blog/index.vue → /blog (index under /blog layout)
+*          routes/blog/$postId.vue → /blog/:postId (child under /blog layout)
+*/
+function buildLayerRouteTree(flatRoutes, source) {
+	if (flatRoutes.length === 0) return [];
+	const layoutMap = /* @__PURE__ */ new Map();
+	const pages = [];
+	for (const route of flatRoutes) if (route.type === "layout") {
+		const layoutPath = route.finalRoutePath;
+		layoutMap.set(layoutPath, route);
+	} else pages.push(route);
+	if (layoutMap.size === 0) return pages.map((page) => ({
+		...page,
+		routePath: page.finalRoutePath
+	}));
+	let rootLayout = null;
+	let rootLayoutPath = "";
+	for (const [layoutPath, layout] of layoutMap) if (!rootLayout || layoutPath.length < rootLayoutPath.length) {
+		rootLayout = layout;
+		rootLayoutPath = layoutPath;
+	}
+	if (!rootLayout) return pages.map((page) => ({
+		...page,
+		routePath: page.finalRoutePath
+	}));
+	const children = [];
+	const normalizedBase = rootLayoutPath;
+	for (const page of pages) {
+		const pagePath = page.finalRoutePath;
+		if (pagePath === normalizedBase || pagePath === normalizedBase + "/") {
+			const indexRoute = {
+				...page,
+				routePath: "",
+				parent: rootLayout
+			};
+			children.unshift(indexRoute);
+		} else if (pagePath.startsWith(normalizedBase + "/") || normalizedBase === "/" && pagePath.startsWith("/")) {
+			const relativePath = normalizedBase === "/" ? pagePath.slice(1) : pagePath.slice(normalizedBase.length + 1);
+			const childRoute = {
+				...page,
+				routePath: relativePath,
+				parent: rootLayout
+			};
+			children.push(childRoute);
+		}
+	}
+	return [{
+		...rootLayout,
+		routePath: rootLayout.finalRoutePath,
+		children
+	}];
+}
+/**
+* Scan routes from a single layer
+*/
+async function scanLayerRoutes(source, config) {
+	const { layer, priority, routesDir, basePath } = source;
+	if (!fs.existsSync(routesDir)) {
+		logger$1.debug(`Routes directory not found for layer '${layer}': ${routesDir}`);
+		return [];
+	}
+	const files = await fg(buildGlobPattern(config.extensions), {
+		cwd: routesDir,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const directories = await fg("**/", {
+		cwd: routesDir,
+		onlyDirectories: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const dirSet = new Set(directories.map((d) => d.replace(/\/$/, "")));
+	const routes = [];
+	for (const file of files.sort()) {
+		const node = await processLayerFile(file, routesDir, source, config, dirSet);
+		if (node) routes.push(node);
+	}
+	return routes;
+}
+/**
+* Process a single route file from a layer
+* 
+* Supports layout route pattern: posts.vue + posts/ directory
+* 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);
+	if (fileName.startsWith("-")) return null;
+	const potentialDirPath = isRootDir(dirPath) ? fileName : `${dirPath}/${fileName}`;
+	const hasMatchingDirectory = dirSet.has(potentialDirPath);
+	let { type, routePath, params, rawSegment, isPathlessLayout } = parseFileName(fileName, dirPath);
+	if (hasMatchingDirectory && type === "page") {
+		type = "layout";
+		routePath = buildRoutePath(dirPath, fileName);
+		logger$1.debug(`Layout route detected: ${fileName} -> ${routePath}`);
+	}
+	let content;
+	try {
+		content = fs.readFileSync(fullPath, "utf-8");
+	} catch {
+		logger$1.warn(`Could not read file: ${fullPath}`);
+		return null;
+	}
+	if (needsScaffolding(content)) {
+		const isLayout = type === "layout";
+		const isDynamic = type === "dynamic";
+		const paramName = params[0]?.name;
+		content = generateRouteScaffold({
+			routePath,
+			isLayout,
+			isDynamic,
+			paramName
+		});
+		fs.writeFileSync(fullPath, content, "utf-8");
+		logger$1.debug(`Scaffolded route: ${source.layer}:${filePath}`);
+	}
+	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,
+		params,
+		parsed,
+		children: [],
+		rawSegment,
+		layer: source.layer,
+		layerPriority: source.priority,
+		layerBasePath: source.basePath,
+		finalRoutePath
+	};
+}
+/**
+* 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) {
+	if (!basePath) return routePath;
+	const normalizedBase = basePath.startsWith("/") ? basePath : `/${basePath}`;
+	const base = normalizedBase.endsWith("/") ? normalizedBase.slice(0, -1) : normalizedBase;
+	if (routePath === "/") return base || "/";
+	return `${base}${routePath}`;
+}
+/**
+* Generate a unique variable name for a route
+*/
+function generateVariableName(filePath, layer) {
+	const withoutExt = filePath.replace(/\.[^/.]+$/, "");
+	return (layer === "app" ? "" : `${sanitizeForVariable(layer)}_`) + withoutExt.replace(/[\/\\]/g, "_").replace(/[\[\]$().+-]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_").replace(/^(\d)/, "_$1");
+}
+/**
+* Sanitize string for use in variable name
+*/
+function sanitizeForVariable(str) {
+	return str.replace(/^@/, "").replace(/[\/\\@-]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+/**
+* Generate route name from route path
+*/
+function generateRouteName(routePath, layer) {
+	const layerPrefix = layer === "app" ? "" : `${layer.replace(/[@\/]/g, "-")}-`;
+	if (routePath === "/") return `${layerPrefix}index`;
+	return `${layerPrefix}${routePath.slice(1).replace(/\//g, "-").replace(/:/g, "").replace(/\(.*?\)\*/g, "catchAll").replace(/\?/g, "")}`;
+}
+/**
+* Check if route should be lazy loaded
+*/
+function shouldBeLazy(filePath, config) {
+	const { importMode } = config;
+	if (typeof importMode === "function") return importMode(filePath) === "async";
+	return importMode === "async";
+}
+
+//#endregion
+//#region src/plugin.ts
+const VIRTUAL_ROUTES_ID = "\0virtual:kimesh-routes";
+const VIRTUAL_ROUTE_PREFIX = "\0kimesh-route:";
+const DEFAULT_CONFIG = {
+	srcDir: "src",
+	routesDir: "routes",
+	generatedDir: ".kimesh",
+	extensions: [".vue"],
+	importMode: "async"
+};
+/**
+* Kimesh Router Generator Vite Plugin
+*/
+function kimeshRouterGenerator(options = {}) {
+	const debug = options.debug ?? false;
+	let config;
+	let server = null;
+	let scanner;
+	let routes = [];
+	const log = (...args) => {
+		if (debug) console.log("[kimesh:router]", ...args);
+	};
+	/**
+	* Resolve layer routes - supports both static config and lazy getter
+	*/
+	const resolveLayerRoutes = () => {
+		if (options.getLayerRoutes) return options.getLayerRoutes();
+		return options.layerRoutes ?? [];
+	};
+	return {
+		name: "kimesh:router-generator",
+		enforce: "pre",
+		configResolved(viteConfig) {
+			const root = viteConfig.root;
+			const mergedConfig = {
+				...DEFAULT_CONFIG,
+				...options
+			};
+			config = {
+				...mergedConfig,
+				root,
+				routesDirPath: path.resolve(root, mergedConfig.srcDir, mergedConfig.routesDir),
+				generatedDirPath: path.resolve(root, mergedConfig.generatedDir)
+			};
+			scanner = new RouteScanner(config);
+			log("Config resolved:", {
+				routesDirPath: config.routesDirPath,
+				generatedDirPath: config.generatedDirPath,
+				layerCount: resolveLayerRoutes().length
+			});
+		},
+		async buildStart() {
+			await generateRoutesOnce();
+		},
+		configureServer(_server) {
+			server = _server;
+			const watchPaths = [config.routesDirPath];
+			const layerRoutes = resolveLayerRoutes();
+			for (const layer of layerRoutes) if (fs.existsSync(layer.routesDir)) watchPaths.push(layer.routesDir);
+			const watcher = watch(watchPaths, {
+				ignoreInitial: true,
+				ignored: ["**/.kimesh/**", "**/node_modules/**"]
+			});
+			watcher.on("add", handleFileChange);
+			watcher.on("unlink", handleFileChange);
+			log("Watching routes at:", watchPaths);
+		},
+		resolveId(id, importer) {
+			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 null;
+		},
+		load(id) {
+			if (id === VIRTUAL_ROUTES_ID) return generateRoutes(routes, config);
+			if (id.startsWith(VIRTUAL_ROUTE_PREFIX)) {
+				const filePath = id.slice(14);
+				log("Extracting route definition from:", filePath);
+				return extractRouteDefinition(filePath);
+			}
+			return null;
+		}
+	};
+	async function generateRoutesOnce() {
+		try {
+			if (!fs.existsSync(config.routesDirPath)) {
+				log("Routes directory does not exist:", config.routesDirPath);
+				routes = [];
+			}
+			log("Scanning routes in:", config.routesDirPath);
+			const scannedNodes = fs.existsSync(config.routesDirPath) ? await scanner.scan() : [];
+			log("Scanned app nodes:", scannedNodes.length, scannedNodes.map((n) => n.filePath));
+			let appRoutes = buildRouteTree(scannedNodes, config);
+			log("Built app routes:", appRoutes.length, appRoutes.map((r) => r.routePath));
+			const layerRoutes = resolveLayerRoutes();
+			if (layerRoutes.length > 0) {
+				const layerResult = await collectLayerRoutes(layerRoutes.map((l) => ({
+					layer: l.layerName,
+					routesDir: l.routesDir,
+					basePath: l.basePath,
+					priority: l.priority
+				})), config);
+				log("Collected layer routes:", layerResult.routes.length);
+				routes = mergeRoutes(appRoutes, layerResult.routes, config);
+			} else routes = appRoutes;
+			log("Final merged routes:", routes.length, routes.map((r) => r.routePath));
+			await writeGeneratedFiles();
+			console.log(`[kimesh:router] Generated ${routes.length} route(s)`);
+		} catch (error) {
+			console.error("[kimesh:router] Error generating routes:", error);
+		}
+	}
+	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");
+		fs.writeFileSync(routesPath, routesCode, "utf-8");
+		const typesCode = generateRouteTypes(routes);
+		const typesPath = path.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);
+			try {
+				layerRoot = fs.realpathSync(layerRoot);
+			} catch {}
+			const layerKimeshDir = path.join(layerRoot, ".kimesh");
+			if (!fs.existsSync(layerKimeshDir)) fs.mkdirSync(layerKimeshDir, { recursive: true });
+			const layerTypesPath = path.join(layerKimeshDir, "typed-routes.d.ts");
+			fs.writeFileSync(layerTypesPath, typesCode, "utf-8");
+			log("Generated layer types:", {
+				layer: layer.layerName,
+				path: layerTypesPath
+			});
+		}
+		log("Generated files:", {
+			routesPath,
+			typesPath
+		});
+	}
+	async function handleFileChange(filePath) {
+		log("File changed:", filePath);
+		await generateRoutesOnce();
+		if (server) {
+			const routesModule = server.moduleGraph.getModuleById(VIRTUAL_ROUTES_ID);
+			if (routesModule) server.moduleGraph.invalidateModule(routesModule);
+			server.ws.send({
+				type: "full-reload",
+				path: "*"
+			});
+		}
+	}
+}
+/**
+* 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(appRoutes, layerRoutes, _config) {
+	const rootLayout = findRootLayout(appRoutes);
+	if (rootLayout && rootLayout.children) return mergeWithRootLayout(appRoutes, layerRoutes, rootLayout);
+	return mergeWithoutRootLayout(appRoutes, layerRoutes);
+}
+function findRootLayout(routes) {
+	return routes.find((r) => r.routePath === "/" && r.type === "layout") || null;
+}
+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);
+	}
+	sortRouteChildren(rootLayout.children);
+	return appRoutes;
+}
+function buildLayoutRoutesMap(children) {
+	const map = /* @__PURE__ */ new Map();
+	for (const child of children) if (child.routePath && !child.routePath.includes(":")) {
+		const normalizedPath = normalizeRoutePath(child.routePath);
+		map.set(normalizedPath, child);
+	}
+	return map;
+}
+function normalizeRoutePath(routePath) {
+	return routePath.startsWith("/") ? routePath.slice(1) : routePath;
+}
+function nestLayerUnderHost(layerRoute, hostLayoutRoute) {
+	hostLayoutRoute.children = hostLayoutRoute.children || [];
+	hostLayoutRoute.type = "layout";
+	const layerWrapper = {
+		...layerRoute,
+		routePath: "",
+		parent: hostLayoutRoute
+	};
+	hostLayoutRoute.children.push(layerWrapper);
+}
+function addLayerAsSibling(layerRoute, relativePath, rootLayout, layoutRoutesByPath) {
+	const nestedRoute = {
+		...layerRoute,
+		routePath: relativePath,
+		parent: rootLayout
+	};
+	rootLayout.children.push(nestedRoute);
+	layoutRoutesByPath.set(relativePath, nestedRoute);
+}
+function sortRouteChildren(children) {
+	children.sort((a, b) => {
+		if (a.routePath === "") return -1;
+		if (b.routePath === "") return 1;
+		return a.routePath.localeCompare(b.routePath);
+	});
+}
+function mergeWithoutRootLayout(appRoutes, layerRoutes) {
+	const merged = [...appRoutes];
+	const usedPaths = new Set(appRoutes.map((r) => r.routePath));
+	for (const layerRoute of layerRoutes) if (!usedPaths.has(layerRoute.routePath)) {
+		merged.push(layerRoute);
+		usedPaths.add(layerRoute.routePath);
+	}
+	merged.sort((a, b) => a.routePath.localeCompare(b.routePath));
+	return merged;
+}
+
+//#endregion
+//#region src/layout-resolver.ts
+/**
+* @kimesh/router-generator - Layout Resolver
+*
+* Resolves layout hierarchy using nested wrapping strategy.
+* Host layouts wrap layer layouts (outer → inner).
+*/
+const logger = consola.withTag("kimesh:router:layout");
+/**
+* Layout resolver for nested wrapping
+*
+* Key principle: Host layouts WRAP layer layouts (outer → inner)
+* - Host root layout is always outermost
+* - Host path-specific layouts come next
+* - Layer layouts are innermost (closest to page content)
+*/
+var LayoutResolver = class {
+	hostLayouts = /* @__PURE__ */ new Map();
+	layerLayouts = /* @__PURE__ */ new Map();
+	layerMounts = /* @__PURE__ */ new Map();
+	/**
+	* Build layout chains for all routes
+	*/
+	resolveLayoutChains(routes, layerMounts) {
+		this.layerMounts = layerMounts;
+		this.categorizeLayouts(routes);
+		const chains = /* @__PURE__ */ new Map();
+		const pageRoutes = routes.filter((r) => r.type !== "layout");
+		for (const page of pageRoutes) {
+			const chain = this.buildLayoutChain(page);
+			chains.set(page.finalRoutePath, chain);
+		}
+		logger.debug(`Resolved layout chains for ${chains.size} pages`);
+		return chains;
+	}
+	/**
+	* Categorize layouts into host and layer layouts
+	*/
+	categorizeLayouts(routes) {
+		this.hostLayouts.clear();
+		this.layerLayouts.clear();
+		const layoutRoutes = routes.filter((r) => r.type === "layout");
+		for (const route of layoutRoutes) {
+			const layoutName = this.extractLayoutName(route.filePath);
+			const layout = {
+				filePath: route.fullPath,
+				name: layoutName,
+				routePath: route.routePath,
+				layer: route.layer,
+				priority: route.layerPriority,
+				source: route.layer === "app" ? "host" : "layer",
+				mountPath: route.layerBasePath
+			};
+			if (route.layer === "app") {
+				const key = this.makeLayoutKey(route.routePath, layoutName);
+				this.hostLayouts.set(key, layout);
+				logger.debug(`Host layout: ${key} -> ${route.fullPath}`);
+			} else {
+				if (!this.layerLayouts.has(route.layer)) this.layerLayouts.set(route.layer, /* @__PURE__ */ new Map());
+				const key = this.makeLayoutKey(route.routePath, layoutName);
+				this.layerLayouts.get(route.layer).set(key, layout);
+				logger.debug(`Layer layout: ${route.layer}:${key} -> ${route.fullPath}`);
+			}
+		}
+	}
+	/**
+	* Build the complete layout chain for a page
+	*
+	* Order: Host root → Host path-specific → Layer root → Layer path-specific → Page
+	*/
+	buildLayoutChain(page) {
+		const layouts = [];
+		const pageMeta = page.parsed.pageMeta;
+		if (pageMeta?.layout === false) return {
+			layouts: [],
+			page
+		};
+		const requestedLayout = pageMeta?.layout;
+		const hostChain = this.collectHostLayouts(page.finalRoutePath, requestedLayout);
+		layouts.push(...hostChain);
+		if (page.layer !== "app") {
+			const layerChain = this.collectLayerLayouts(page.layer, page.routePath, page.layerBasePath, requestedLayout);
+			layouts.push(...layerChain);
+		}
+		return {
+			layouts,
+			page
+		};
+	}
+	/**
+	* Collect host layouts from root to most specific path
+	*/
+	collectHostLayouts(routePath, requestedLayout) {
+		const layouts = [];
+		const segments = routePath.split("/").filter(Boolean);
+		const rootLayout = this.hostLayouts.get(this.makeLayoutKey("/", requestedLayout)) || this.hostLayouts.get("/");
+		if (rootLayout) layouts.push(rootLayout);
+		let currentPath = "";
+		for (const segment of segments) {
+			if (segment.startsWith(":")) continue;
+			currentPath += "/" + segment;
+			const layout = this.hostLayouts.get(this.makeLayoutKey(currentPath, requestedLayout)) || this.hostLayouts.get(currentPath);
+			if (layout && !layouts.includes(layout)) layouts.push(layout);
+		}
+		return layouts;
+	}
+	/**
+	* Collect layer layouts from layer root to most specific path
+	*/
+	collectLayerLayouts(layerName, routePath, mountPath, requestedLayout) {
+		const layouts = [];
+		const layerLayoutMap = this.layerLayouts.get(layerName);
+		if (!layerLayoutMap) return layouts;
+		const segments = routePath.split("/").filter(Boolean);
+		const rootLayout = layerLayoutMap.get(this.makeLayoutKey("/", requestedLayout)) || layerLayoutMap.get("/");
+		if (rootLayout) layouts.push(rootLayout);
+		let currentPath = "";
+		for (const segment of segments) {
+			if (segment.startsWith(":")) continue;
+			currentPath += "/" + segment;
+			const layout = layerLayoutMap.get(this.makeLayoutKey(currentPath, requestedLayout)) || layerLayoutMap.get(currentPath);
+			if (layout && !layouts.includes(layout)) layouts.push(layout);
+		}
+		return layouts;
+	}
+	/**
+	* Extract layout name from file path
+	* _layout.admin.vue → 'admin'
+	* _layout.vue → undefined
+	*/
+	extractLayoutName(filePath) {
+		const basename = path.basename(filePath, path.extname(filePath));
+		if (basename.startsWith("_layout.") && basename !== "_layout") return basename.replace("_layout.", "");
+	}
+	/**
+	* Make a unique key for layout lookup
+	*/
+	makeLayoutKey(routePath, layoutName) {
+		if (layoutName) return `${routePath}:${layoutName}`;
+		return routePath;
+	}
+};
+/**
+* Generate nested layout component structure for Vue Router
+*
+* This generates the component tree where layouts wrap their children
+*/
+function generateLayoutStructure(chain) {
+	if (chain.layouts.length === 0) return { component: chain.page.fullPath };
+	let current = { component: chain.page.fullPath };
+	for (let i = chain.layouts.length - 1; i >= 0; i--) current = {
+		component: chain.layouts[i].filePath,
+		children: [current]
+	};
+	return current;
+}
+
+//#endregion
+export { LayoutResolver, RouteScanner, RouteTreeBuilder, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, parseRouteFile, processDirectoryPath, processPathSegment, unescapeBrackets };
+//# sourceMappingURL=index.mjs.map