@kosmojs/lib 0.4.4 → 0.5.0

package/pkg/index.js

@@ -1,21 +1,1509 @@
-import{builtinModules as e}from"node:module";import{styleText as t}from"node:util";import n from"crc/crc32";import r from"tfusion";import{ModuleResolutionKind as i,Project as a,SyntaxKind as o}from"ts-morph";import{RequestValidationTargets as s,defaults as c}from"@kosmojs/core";import{HTTPMethods as l}from"@kosmojs/core/api";import{mergeConfig as u}from"vite";import{access as d,constants as f,mkdir as p,readFile as m,stat as h,writeFile as g}from"node:fs/promises";import{basename as _,dirname as v,isAbsolute as y,join as b,parse as x,resolve as S}from"node:path";import C from"handlebars";import w from"picomatch";import{glob as T}from"tinyglobby";import{compile as E,parse as D}from"path-to-regexp";import{lookup as O}from"mrmime";import{Spinner as k}from"@topcli/spinner";var ee=(...e)=>[{configFile:!1},...e].reduce((e,t)=>u(e||{},t||{}),{}),te=e=>[[/(?<!\\)`/g,"\\`"],[/(?<!\\)\$\{/g,"\\${"]].reduce((e,[t,n])=>e.replace(t,n),e),A=e=>{let t=(...t)=>e.root?S(e.root,b(...t)):b(...t),n={src(t,{origin:n}){return n===`src`?b(c.srcPrefix,...t):b(c.appPrefix,c.srcDir,e.name,...t)},api(e,t){return this.src([c.apiDir,...e],t)},entry(e,t){return this.src([c.entryDir,...e],t)},pages(e,t){return this.src([c.pagesDir,...e],t)},lib(t,{origin:n}){return n===`src`?b(c.libPrefix,...t):b(c.appPrefix,c.libDir,e.name,...t)},libCore(e,t){return this.lib([`core`,...e],t)},libApi(e,t){return this.lib([c.apiDir,...e],t)},libEntry(e,t){return this.lib([c.entryDir,...e],t)}};return{createPath:{src(...n){return t(c.srcDir,e.name,...n)},api(...e){return this.src(c.apiDir,...e)},pages(...e){return this.src(c.pagesDir,...e)},entry(...e){return this.src(c.entryDir,...e)},lib(...n){return t(c.libDir,e.name,...n)},libCore(...e){return this.lib(`core`,...e)},libApi(...e){return this.lib(c.apiDir,...e)},libEntry(...e){return this.lib(c.entryDir,...e)},libPages(...e){return this.lib(c.pagesDir,...e)},distDir(...n){return t(e.distDir,e.name,...n)}},createImport:n,createImportHelpers(e){if(![`src`,`lib`].includes(e?.origin))throw Error(`createImportHelpers: required exactly one argument of shape { origin: "src|lib" }`);return{createImport(t,...r){return n[t](r.slice(0,-1),e)}}}}},j=async e=>d(e,f.F_OK).then(()=>!0,()=>!1),M=(e,t,n)=>{let{noEscape:r=!0,renderer:i=C}={...n};return i.compile(e,{noEscape:r})(t)},N=async(e,t,r,i)=>{let a=i?.render?i.render(t,r,i):M(t,r,i);if(await j(e)){let{overwrite:t=!0}={...i};if(t===!1)return;let r=await m(e,`utf8`);if(typeof t==`function`&&!t(r)||n(a)===n(r))return}await p(v(e),{recursive:!0}),await g(e,a,`utf8`)},ne=e=>{let t=t=>{let n=C.create();return n.registerPartial({...e?.partials,...t?.partials}),n.registerHelper({...e?.helpers,...t?.helpers}),n};return{render(n,r,i){return M(n,r,{...e,...i,renderer:t(i)})},async renderToFile(n,r,i,a){return N(e?.outdir?b(e.outdir,n):n,r,i,{...e,...a,renderer:t(a)})}}},P=`{{#each resolvedTypes}}
-export type {{name}} = {{text}};
-{{/each}}
-`,re=`{{#each typeDeclarations}}{{text}}
-{{/each}}
-
-export type {{params.id}} = {
-  {{#each paramsSchema}}
-  "{{name}}"{{#unless isRequired}}?{{/unless}}: {{#if refinement}}
-    {{refinement.text}},
-  {{else}}
-    {{#if isSplat}}Array<string>{{else}}string{{/if}},
-  {{/if}}
-  {{/each}}
+import { builtinModules } from "node:module";
+import { styleText } from "node:util";
+import crc from "crc/crc32";
+import flattener from "tfusion";
+import { ModuleResolutionKind, Project, SyntaxKind } from "ts-morph";
+import { RequestValidationTargets, defaults } from "@kosmojs/core";
+import { HTTPMethods } from "@kosmojs/core/api";
+import { mergeConfig } from "vite";
+import { access, constants, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, parse, posix, resolve } from "node:path";
+import handlebars from "handlebars";
+import picomatch from "picomatch";
+import { glob } from "tinyglobby";
+import { compile, parse as parse$1 } from "path-to-regexp";
+import { lookup } from "mrmime";
+import { Spinner } from "@topcli/spinner";
+//#region src/generic.ts
+var mergeConfigs = (...configs) => {
+	return [{ configFile: false }, ...configs].reduce((config, prev) => mergeConfig(config || {}, prev || {}), {});
+};
+var escapeTemplateLiterals = (origin) => {
+	return [[/(?<!\\)`/g, "\\`"], [/(?<!\\)\$\{/g, "\\${"]].reduce((text, [a, b]) => text.replace(a, b), origin);
+};
+var containsPathTraversalPatterns = (str) => {
+	return [/\.\.\//, /\/\.\//].some((e) => e.test(str));
+};
+//#endregion
+//#region src/paths.ts
+var pathResolver = (sourceFolder) => {
+	const createPath = (...a) => {
+		return sourceFolder.root ? resolve(sourceFolder.root, join(...a)) : join(...a);
+	};
+	const createImport = {
+		src(a, { origin }) {
+			return origin === "src" ? join(defaults.srcPrefix, ...a) : join(defaults.appPrefix, defaults.srcDir, sourceFolder.name, ...a);
+		},
+		api(a, o) {
+			return this.src([defaults.apiDir, ...a], o);
+		},
+		entry(a, o) {
+			return this.src([defaults.entryDir, ...a], o);
+		},
+		pages(a, o) {
+			return this.src([defaults.pagesDir, ...a], o);
+		},
+		lib(a, { origin }) {
+			return origin === "src" ? join(defaults.libPrefix, ...a) : join(defaults.appPrefix, defaults.libDir, sourceFolder.name, ...a);
+		},
+		libCore(a, o) {
+			return this.lib(["core", ...a], o);
+		},
+		libApi(a, o) {
+			return this.lib([defaults.apiDir, ...a], o);
+		},
+		libEntry(a, o) {
+			return this.lib([defaults.entryDir, ...a], o);
+		}
+	};
+	return {
+		createPath: {
+			src(...a) {
+				return createPath(defaults.srcDir, sourceFolder.name, ...a);
+			},
+			api(...a) {
+				return this.src(defaults.apiDir, ...a);
+			},
+			pages(...a) {
+				return this.src(defaults.pagesDir, ...a);
+			},
+			entry(...a) {
+				return this.src(defaults.entryDir, ...a);
+			},
+			lib(...a) {
+				return createPath(defaults.libDir, sourceFolder.name, ...a);
+			},
+			libCore(...a) {
+				return this.lib("core", ...a);
+			},
+			libApi(...a) {
+				return this.lib(defaults.apiDir, ...a);
+			},
+			libEntry(...a) {
+				return this.lib(defaults.entryDir, ...a);
+			},
+			libPages(...a) {
+				return this.lib(defaults.pagesDir, ...a);
+			},
+			distDir(...a) {
+				return createPath(sourceFolder.distDir, sourceFolder.name, ...a);
+			}
+		},
+		createImport,
+		createImportHelpers(o) {
+			if (!["src", "lib"].includes(o?.origin)) throw new Error(`createImportHelpers: required exactly one argument of shape { origin: "src|lib" }`);
+			return { createImport(key, ...a) {
+				return createImport[key](a.slice(0, -1), o);
+			} };
+		}
+	};
+};
+var pathExists = async (path) => {
+	return access(path, constants.F_OK).then(() => true, () => false);
+};
+//#endregion
+//#region src/render.ts
+var render = (template, context, options) => {
+	const { noEscape = true, renderer = handlebars } = { ...options };
+	return renderer.compile(template, { noEscape })(context);
+};
+var renderToFile = async (file, template, context, options) => {
+	const content = options?.render ? options.render(template, context, options) : render(template, context, options);
+	/**
+	* Two fs calls (exists + read) are worth it to avoid touching the file
+	* and triggering watchers unnecessarily.
+	* */
+	if (await pathExists(file)) {
+		const { overwrite = true } = { ...options };
+		if (overwrite === false) return;
+		const fileContent = await readFile(file, "utf8");
+		if (typeof overwrite === "function" && !overwrite(fileContent)) return;
+		if (crc(content) === crc(fileContent)) return;
+	}
+	await mkdir(dirname(file), { recursive: true });
+	await writeFile(file, content, "utf8");
+};
+var renderFactory = (options) => {
+	const createRenderer = (selfOoptions) => {
+		const renderer = handlebars.create();
+		renderer.registerPartial({
+			...options?.partials,
+			...selfOoptions?.partials
+		});
+		renderer.registerHelper({
+			...options?.helpers,
+			...selfOoptions?.helpers
+		});
+		return renderer;
+	};
+	return {
+		render(template, context, selfOoptions) {
+			return render(template, context, {
+				...options,
+				...selfOoptions,
+				renderer: createRenderer(selfOoptions)
+			});
+		},
+		async renderToFile(file, template, context, selfOoptions) {
+			return renderToFile(options?.outdir ? join(options.outdir, file) : file, template, context, {
+				...options,
+				...selfOoptions,
+				renderer: createRenderer(selfOoptions)
+			});
+		}
+	};
+};
+//#endregion
+//#region src/templates/resolved-types.hbs?raw
+var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
+//#endregion
+//#region src/templates/types.hbs?raw
+var types_default = "{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  \"{{name}}\"{{#unless isRequired}}?{{/unless}}: {{#if refinement}}\n    {{refinement.text}},\n  {{else}}\n    {{#if isSplat}}Array<string>{{else}}string{{/if}},\n  {{/if}}\n  {{/each}}\n};\n\n{{#each validationTypes}}export type {{id}} = {{text}};\n{{/each}}\n";
+//#endregion
+//#region src/ast.ts
+var astFactory = () => {
+	const createProject = (opts) => new Project(opts);
+	const resolveRouteSignature = async (route, opts) => {
+		const { sourceFile = createProject().addSourceFileAtPath(route.fileFullpath) } = { ...opts };
+		const [typeDeclarations, referencedFiles] = extractTypeDeclarations(sourceFile, opts);
+		const defaultExport = extractDefaultExport(sourceFile);
+		const paramsRefinements = defaultExport ? extractParamsRefinements(defaultExport) : void 0;
+		const methods = defaultExport ? extractRouteMethods(route, defaultExport) : [];
+		return {
+			typeDeclarations,
+			paramsRefinements,
+			methods: methods.map((e) => e.method),
+			validationDefinitions: methods.flatMap((e) => e.validationDefinitions),
+			referencedFiles
+		};
+	};
+	const extractDefaultExport = (sourceFile) => {
+		const [defaultExport] = sourceFile.getExportAssignments().flatMap((exportAssignment) => {
+			if (exportAssignment.isExportEquals()) return [];
+			const callExpression = exportAssignment.getExpression();
+			return callExpression.isKind(SyntaxKind.CallExpression) ? [callExpression] : [];
+		});
+		return defaultExport;
+	};
+	const extractParamsRefinements = (callExpression) => {
+		const [_routeName, paramsGeneric] = extractGenerics(callExpression);
+		if (!paramsGeneric?.isKind(SyntaxKind.TupleType)) return;
+		return paramsGeneric.getElements().map((node, index) => {
+			return {
+				index,
+				text: node.getText()
+			};
+		});
+	};
+	const extractRouteMethods = (route, callExpression) => {
+		const funcDeclaration = callExpression.getFirstChildByKind(SyntaxKind.ArrowFunction) || callExpression.getFirstChildByKind(SyntaxKind.FunctionExpression);
+		if (!funcDeclaration) return [];
+		const arrayLiteralExpression = funcDeclaration.getFirstChildByKind(SyntaxKind.ArrayLiteralExpression);
+		if (!arrayLiteralExpression) return [];
+		const callExpressions = [];
+		for (const e of arrayLiteralExpression.getChildrenOfKind(SyntaxKind.CallExpression)) {
+			const name = e.getExpression().getText();
+			if (HTTPMethods[name]) callExpressions.push([e, name]);
+		}
+		const methods = [];
+		for (const [callExpression, method] of callExpressions) {
+			const [vDefs, vOpts] = extractGenerics(callExpression);
+			methods.push({
+				method,
+				validationDefinitions: extractValidationDefinitions(route, method, vDefs, vOpts)
+			});
+		}
+		return methods;
+	};
+	/** Parse a boolean literal type node */
+	const parseRuntimeValidation = (typeNode) => {
+		if (typeNode.isKind(SyntaxKind.LiteralType)) {
+			const literal = typeNode.getFirstChild();
+			if (literal?.isKind(SyntaxKind.TrueKeyword)) return true;
+			else if (literal?.isKind(SyntaxKind.FalseKeyword)) return false;
+		}
+	};
+	const extractResponseVariant = (typeNode) => {
+		if (!typeNode.isKind(SyntaxKind.TupleType)) return;
+		let status = 200;
+		let contentType;
+		let body;
+		const [statusNode, contentTypeNode, bodyNode] = typeNode.getElements();
+		if (statusNode?.isKind(SyntaxKind.LiteralType)) {
+			const literal = statusNode.getFirstChildByKind(SyntaxKind.NumericLiteral);
+			if (literal) status = Number(literal.getText());
+		}
+		if (contentTypeNode) contentType = extractStringLiteral(contentTypeNode);
+		if (bodyNode) {
+			body = bodyNode.getText();
+			if (["object"].includes(body)) body = "{}";
+		}
+		return {
+			status,
+			contentType,
+			body
+		};
+	};
+	/** Parse opts TypeLiteral into a map keyed by target */
+	const parseValidationOptions = (typeNode) => {
+		const opts = {};
+		if (!typeNode?.isKind(SyntaxKind.TypeLiteral)) return opts;
+		for (const prop of typeNode.getMembers()) {
+			if (!prop.isKind(SyntaxKind.PropertySignature)) continue;
+			const target = prop.getName();
+			const typeNode = prop.getTypeNodeOrThrow();
+			if (!typeNode.isKind(SyntaxKind.TypeLiteral)) continue;
+			let contentType;
+			let runtimeValidation;
+			const customErrors = {};
+			for (const member of typeNode.getMembers()) {
+				if (!member.isKind(SyntaxKind.PropertySignature)) continue;
+				const name = propertyName(member);
+				const node = member.getTypeNodeOrThrow();
+				if (name === "contentType") contentType = extractStringLiteral(node);
+				else if (name === "runtimeValidation") runtimeValidation = parseRuntimeValidation(node);
+				else if (name.startsWith("error")) {
+					const literal = extractStringLiteral(node);
+					if (literal) customErrors[name] = literal;
+				}
+			}
+			opts[target] = {
+				contentType,
+				runtimeValidation,
+				customErrors
+			};
+		}
+		return opts;
+	};
+	const extractStringLiteral = (typeNode) => {
+		const literal = typeNode.isKind(SyntaxKind.LiteralType) ? typeNode.getFirstChildByKind(SyntaxKind.StringLiteral) : void 0;
+		return literal ? literal.getLiteralText() : void 0;
+	};
+	/**
+	* Extract validation definitions from route handler generics.
+	* Merges defs (schemas) and opts (validation options) into a flat array.
+	* */
+	const extractValidationDefinitions = (route, method, defsNode, optsNode) => {
+		const definitions = [];
+		if (!defsNode?.isKind(SyntaxKind.TypeLiteral)) return definitions;
+		const optsMap = parseValidationOptions(optsNode);
+		const createId = (target, hash) => {
+			return [
+				target.replace(/^./, (c) => c.toUpperCase()),
+				"T",
+				method,
+				crc(route.id + hash)
+			].join("");
+		};
+		for (const prop of defsNode.getMembers()) {
+			if (!prop.isKind(SyntaxKind.PropertySignature)) continue;
+			const target = prop.getName();
+			const typeNode = prop.getTypeNodeOrThrow();
+			if (target === "response") {
+				const variants = typeNode.isKind(SyntaxKind.UnionType) ? typeNode.getChildrenOfKind(SyntaxKind.TupleType) : [typeNode];
+				definitions.push({
+					...optsMap[target],
+					method,
+					target,
+					variants: variants.flatMap((e, i) => {
+						const { status, contentType, body } = { ...extractResponseVariant(e) };
+						if (!status) return [];
+						if (contentType && typeof contentType !== "string") {
+							console.warn(styleText(["bold", "red"], `✗ The second element of a response variant should specify the Response Content Type`));
+							console.warn(styleText(["blue"], `  Example: [200, "json", Schema]`));
+							console.warn(`  Route: ${route.name}; Method: ${method}; Response Variant: #${i}`);
+							console.warn();
+						}
+						return [{
+							id: createId(target, JSON.stringify([
+								status,
+								contentType,
+								body
+							])),
+							status,
+							contentType,
+							body
+						}];
+					})
+				});
+			} else if (Object.keys(RequestValidationTargets).includes(target)) definitions.push({
+				...optsMap[target],
+				method,
+				target,
+				schema: {
+					id: createId(target),
+					text: typeNode.getText()
+				}
+			});
+		}
+		return definitions;
+	};
+	const extractTypeDeclarations = (sourceFile, opts) => {
+		const declarations = [];
+		const referencedFiles = opts?.withReferencedFiles ? [] : void 0;
+		for (const declaration of sourceFile.getImportDeclarations()) {
+			const modulePath = declaration.getModuleSpecifierValue();
+			const path = /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath;
+			const typeOnlyDeclaration = declaration.isTypeOnly();
+			const defaultImport = typeOnlyDeclaration ? declaration.getDefaultImport() : void 0;
+			if (defaultImport) {
+				const name = defaultImport.getText();
+				const text = `import type ${name} from "${path}";`;
+				declarations.push({
+					importDeclaration: {
+						name,
+						path
+					},
+					text
+				});
+				if (referencedFiles) referencedFiles.push(...getReferencedFiles(defaultImport));
+			}
+			const namespaceImport = typeOnlyDeclaration ? declaration.getNamespaceImport() : void 0;
+			if (namespaceImport) {
+				const name = namespaceImport.getText();
+				const text = `import type * as ${name} from "${path}";`;
+				declarations.push({
+					importDeclaration: {
+						name,
+						path
+					},
+					text
+				});
+				if (referencedFiles) referencedFiles.push(...getReferencedFiles(namespaceImport));
+			}
+			for (const namedImport of declaration.getNamedImports()) if (namedImport.isTypeOnly() || typeOnlyDeclaration) {
+				const nameNode = namedImport.getNameNode();
+				const name = nameNode.getText();
+				const alias = namedImport.getAliasNode()?.getText();
+				const nameText = alias ? `${name} as ${alias}` : name;
+				declarations.push({
+					importDeclaration: {
+						name,
+						alias,
+						path
+					},
+					text: `import type { ${nameText} } from "${path}";`
+				});
+				if (referencedFiles) {
+					if (nameNode.isKind(SyntaxKind.Identifier)) referencedFiles.push(...getReferencedFiles(nameNode));
+				}
+			}
+		}
+		for (const declaration of sourceFile.getTypeAliases()) {
+			const name = declaration.getName();
+			const text = declaration.getFullText().trim();
+			declarations.push({
+				typeAliasDeclaration: { name },
+				text
+			});
+		}
+		for (const declaration of sourceFile.getInterfaces()) {
+			const name = declaration.getName();
+			const text = declaration.getFullText().trim();
+			declarations.push({
+				interfaceDeclaration: { name },
+				text
+			});
+		}
+		for (const declaration of sourceFile.getEnums()) {
+			const name = declaration.getName();
+			const text = declaration.getFullText().trim();
+			declarations.push({
+				enumDeclaration: { name },
+				text
+			});
+		}
+		for (const declaration of sourceFile.getExportDeclarations()) {
+			const typeOnlyDeclaration = declaration.isTypeOnly();
+			const modulePath = declaration.getModuleSpecifierValue();
+			const path = modulePath ? /^\.\.?\/?/.test(modulePath) ? opts?.relpathResolver ? opts.relpathResolver(modulePath) : modulePath : modulePath : void 0;
+			for (const namedExport of declaration.getNamedExports()) if (namedExport.isTypeOnly() || typeOnlyDeclaration) {
+				const nameNode = namedExport.getNameNode();
+				const name = nameNode.getText();
+				const alias = namedExport.getAliasNode()?.getText();
+				const nameText = alias ? `${name} as ${alias}` : name;
+				declarations.push({
+					exportDeclaration: {
+						name,
+						alias: alias ?? name,
+						path
+					},
+					text: path ? `export type { ${nameText} } from "${path}";` : `export type { ${nameText} };`
+				});
+				if (referencedFiles) {
+					if (nameNode.isKind(SyntaxKind.Identifier)) referencedFiles.push(...getReferencedFiles(nameNode));
+				}
+			}
+		}
+		return referencedFiles ? [declarations, [...new Set(referencedFiles)]] : [declarations];
+	};
+	const getReferencedFiles = (importIdentifier) => {
+		return (importIdentifier?.getSymbol()?.getAliasedSymbol()?.getDeclarations() || []).flatMap((e) => {
+			const sourceFile = e.getSourceFile();
+			return sourceFile ? [sourceFile.getFilePath()] : [];
+		});
+	};
+	const extractGenerics = (callExpression) => {
+		return callExpression.getTypeArguments();
+	};
+	const typeResolverFactory = (sourceFolder) => {
+		const { createPath } = pathResolver(sourceFolder);
+		const project = createProject({ compilerOptions: {
+			moduleResolution: ModuleResolutionKind.Bundler,
+			types: [],
+			noLib: true,
+			skipLibCheck: true,
+			paths: {
+				[`${defaults.appPrefix}/*`]: [`${sourceFolder.root}/*`],
+				[`${defaults.srcPrefix}/*`]: [createPath.src("*")],
+				[`${defaults.libPrefix}/*`]: [createPath.lib("*")]
+			}
+		} });
+		const withTypeboxSchema = (resolvedTypes) => {
+			const materializedTypes = render(resolved_types_default, { resolvedTypes });
+			const sourceFile = project.createSourceFile(`${crc(materializedTypes)}-${Date.now()}.ts`, materializedTypes, { overwrite: true });
+			return resolvedTypes.map((type) => {
+				const typeNode = sourceFile.getTypeAlias(type.name)?.getTypeNode();
+				if (!typeNode) return type;
+				const properties = [];
+				const numericProperties = [];
+				const booleanProperties = [];
+				for (const prop of type.properties || []) {
+					const propNode = typeNode.isKind(SyntaxKind.TypeLiteral) ? typeNode.getProperty(prop.nameDeclaration)?.getTypeNode() : void 0;
+					if (!propNode) continue;
+					properties.push({
+						...prop,
+						typeboxSchema: renderTypeboxSchema(propNode)
+					});
+					if (isNumericTypeNode(propNode)) numericProperties.push(prop.name);
+					if (isBooleanTypeNode(propNode)) booleanProperties.push(prop.name);
+				}
+				return {
+					...type,
+					properties,
+					numericProperties,
+					booleanProperties,
+					typeboxSchema: renderTypeboxSchema(typeNode)
+				};
+			});
+		};
+		const literalTypesResolver = (literalTypes, options) => {
+			const sourceFile = project.createSourceFile(`${crc(literalTypes)}-${Date.now()}.ts`, literalTypes, { overwrite: true });
+			const resolvedTypes = flattener(project, sourceFile, {
+				...options,
+				stripComments: true
+			});
+			return withTypeboxSchema(resolvedTypes);
+		};
+		return {
+			getSourceFile: (fileFullpath) => {
+				return project.getSourceFile(fileFullpath) || project.addSourceFileAtPath(fileFullpath);
+			},
+			refreshSourceFile: async (fileFullpath) => {
+				const sourceFile = project.getSourceFile(fileFullpath);
+				if (sourceFile) await sourceFile.refreshFromFileSystem();
+			},
+			literalTypesResolver
+		};
+	};
+	return {
+		createProject,
+		extractDefaultExport,
+		extractParamsRefinements,
+		extractRouteMethods,
+		extractTypeDeclarations,
+		resolveRouteSignature,
+		typeResolverFactory
+	};
+};
+/**
+* Property name as declared, stripping quotes for string-literal keys.
+* */
+var propertyName = (property) => {
+	const nameNode = property.getNameNode();
+	return nameNode.isKind(SyntaxKind.StringLiteral) ? nameNode.getLiteralValue() : nameNode.getText();
+};
+/**
+* Whether type node reduces to `number`.
+*
+*   number                      -> true
+*   VRefine<number, {}>         -> true (peel to first type argument)
+*   Array<number>               -> true (peel to first type argument)
+*   number[]                    -> true (peel to element type)
+*   readonly number[]           -> true (peel the type operator, then array)
+*   VRefine<Array<number>, {}>  -> true (peels compose)
+*   2, -2                       -> true (literal types, sign included)
+*   1 | -2 | 3                  -> true (union with every member numeric)
+*   number | string             -> false (mixed unions are not numeric)
+*
+* Does NOT descend into object properties or nested tuple elements.
+* */
+var isNumericTypeNode = (typeNode, refineTypeName = defaults.refineTypeName) => {
+	if (typeNode.isKind(SyntaxKind.ParenthesizedType)) return isNumericTypeNode(typeNode.getTypeNode(), refineTypeName);
+	if (typeNode.isKind(SyntaxKind.TypeReference)) {
+		const name = typeNode.getTypeName().getText();
+		return name === refineTypeName || name === "Array" ? isNumericTypeNode(typeNode.getTypeArguments()[0], refineTypeName) : false;
+	}
+	if (typeNode.isKind(SyntaxKind.ArrayType)) return isNumericTypeNode(typeNode.getElementTypeNode(), refineTypeName);
+	if (typeNode.isKind(SyntaxKind.TypeOperator)) return typeNode.getOperator() === SyntaxKind.ReadonlyKeyword ? isNumericTypeNode(typeNode.getTypeNode(), refineTypeName) : false;
+	if (typeNode.isKind(SyntaxKind.UnionType)) return typeNode.getTypeNodes().every((node) => isNumericTypeNode(node, refineTypeName));
+	if (typeNode.isKind(SyntaxKind.LiteralType)) {
+		const literal = typeNode.getLiteral();
+		return literal.isKind(SyntaxKind.PrefixUnaryExpression) ? literal.getOperand().isKind(SyntaxKind.NumericLiteral) : literal.isKind(SyntaxKind.NumericLiteral);
+	}
+	return typeNode.isKind(SyntaxKind.NumberKeyword);
+};
+/**
+* Whether type node reduces to `boolean`.
+*
+*   boolean               -> true
+*   Array<boolean>        -> true
+*   boolean[]             -> true
+*   readonly boolean[]    -> true
+*   true, false           -> true (literal types)
+*
+* Does NOT descend into object properties or nested tuple elements.
+* */
+var isBooleanTypeNode = (typeNode) => {
+	if (typeNode.isKind(SyntaxKind.ParenthesizedType)) return isBooleanTypeNode(typeNode.getTypeNode());
+	if (typeNode.isKind(SyntaxKind.TypeReference)) return typeNode.getTypeName().getText() === "Array" ? isBooleanTypeNode(typeNode.getTypeArguments()[0]) : false;
+	if (typeNode.isKind(SyntaxKind.ArrayType)) return isBooleanTypeNode(typeNode.getElementTypeNode());
+	if (typeNode.isKind(SyntaxKind.TypeOperator)) return typeNode.getOperator() === SyntaxKind.ReadonlyKeyword ? isBooleanTypeNode(typeNode.getTypeNode()) : false;
+	if (typeNode.isKind(SyntaxKind.LiteralType)) {
+		const literal = typeNode.getLiteral();
+		return literal.isKind(SyntaxKind.TrueKeyword) || literal.isKind(SyntaxKind.FalseKeyword);
+	}
+	return typeNode.isKind(SyntaxKind.BooleanKeyword);
+};
+/**
+* Render a ts-morph TypeNode to TypeBox Script text, replacing every VRefine
+* occurrence (at any depth) with the infix `with` form.
+*
+*   VRefine<string, { format: "email" }>     ->  (string with { format: "email" })
+*   VRefine<string, { format: "email" }>[]   ->  (string with { format: "email" })[]
+*   VRefine<Array<string>, { minItems: 1 }>  ->  (Array<string> with { minItems: 1 })
+*   VRefine<Record<string, string>, { maxProperties: 20 }>
+*                                            ->  (Record<string, string> with { maxProperties: 20 })
+*
+* The parentheses matter: for an array element the `with` clause must bind to the element,
+* not the array, so a VRefine that is the element of an array is wrapped.
+* So, wrapping unconditionally - harmless when not nested, required when it is.
+*
+* @param typeNode the node to render
+* @param refineTypeName the configured refine type name
+* */
+var renderTypeboxSchema = (typeNode, refineTypeName = defaults.refineTypeName) => {
+	const traverse = (typeNode) => {
+		if (typeNode.isKind(SyntaxKind.TypeReference) && typeNode.getTypeName().getText() === refineTypeName) {
+			const [inner, opts] = typeNode.getTypeArguments();
+			if (!inner || !opts) return typeNode.getText();
+			return `(${traverse(inner)} with ${opts.getText()})`;
+		}
+		if (typeNode.isKind(SyntaxKind.ArrayType)) return `${traverse(typeNode.getElementTypeNode())}[]`;
+		if (typeNode.isKind(SyntaxKind.TypeLiteral)) {
+			const members = [];
+			for (const member of typeNode.getMembers()) if (member.isKind(SyntaxKind.PropertySignature)) {
+				const name = member.getName();
+				const optional = member.hasQuestionToken() ? "?" : "";
+				const t = member.getTypeNode();
+				const rendered = t ? traverse(t) : "unknown";
+				members.push(`${name}${optional}: ${rendered}`);
+			} else members.push(member.getText());
+			return `{ ${members.join(", ")} }`;
+		}
+		if (typeNode.isKind(SyntaxKind.TupleType)) return `[${typeNode.getElements().map((el) => traverse(el)).join(", ")}]`;
+		if (typeNode.isKind(SyntaxKind.ParenthesizedType)) return `(${traverse(typeNode.getTypeNode())})`;
+		if (typeNode.isKind(SyntaxKind.UnionType)) return typeNode.getTypeNodes().map((t) => traverse(t)).join(" | ");
+		if (typeNode.isKind(SyntaxKind.IntersectionType)) return typeNode.getTypeNodes().map((t) => traverse(t)).join(" & ");
+		if (typeNode.isKind(SyntaxKind.TypeReference)) {
+			const args = typeNode.getTypeArguments();
+			if (args.length === 0) return typeNode.getText();
+			return `${typeNode.getTypeName().getText()}<${args.map((a) => traverse(a)).join(", ")}>`;
+		}
+		return typeNode.getText();
+	};
+	return escapeTemplateLiterals(traverse(typeNode));
+};
+//#endregion
+//#region src/generators.ts
+var defineGenerator = ({ meta, factory, dependencies, devDependencies }) => {
+	const wrapper = ((options) => {
+		return {
+			meta,
+			factory: (folder) => factory(folder, options),
+			dependencies,
+			devDependencies,
+			options
+		};
+	});
+	Object.assign(wrapper, {
+		meta,
+		dependencies,
+		devDependencies
+	});
+	return wrapper;
+};
+var defineGeneratorFactory = (factory) => factory;
+/**
+* Filter watched API routes by event.
+* Handle 3 cases:
+* - event is undefined (means initial call): process all routes.
+* - `create` event given: process newly added route.
+*   Files can arrive already containing content (git checkout, cp) -
+*   clients must generate on create, not only on a subsequent update.
+* - `update` event given: process the updated route,
+*    and any route referencing the updated file (shared types).
+* */
+var createWatchedApiRouteEntriesFilter = (event, eventsOfInterest) => {
+	return ({ kind, entry }) => {
+		if (!event) return true;
+		if (!eventsOfInterest.includes(event.kind)) return false;
+		if (kind === "apiRoute" || kind === "apiUse") return entry.fileFullpath !== event.file ? entry.referencedFiles?.includes(event.file) : true;
+		return false;
+	};
+};
+/**
+* Filter watched page routes by event.
+* Handle 3 cases:
+* - event is undefined (means initial call): process all routes.
+* - `create` event given: process newly added route.
+*   Files can arrive already containing content (git checkout, cp) -
+*   clients must generate on create, not only on a subsequent update.
+* - `update` event given: process the updated route,
+*    and any route referencing the updated file (shared types).
+* */
+var createWatchedPageRouteEntriesFilter = (event, eventsOfInterest) => {
+	return ({ kind, entry }) => {
+		if (!event) return true;
+		if (!eventsOfInterest.includes(event.kind)) return false;
+		return kind === "pageRoute" || kind === "pageLayout" ? entry.fileFullpath === event.file : false;
+	};
+};
+//#endregion
+//#region src/routes/paths.ts
+/**
+* Parse a filesystem route path into structured PathToken array.
+*
+* Uses path-to-regexp v8 AST for parsing, with directory-friendly syntax:
+*   - [param]     => required param - :param
+*   - {param}     => optional param - {:param}
+*   - {...param}  => splat - {*param}
+*
+* Direct :param syntax is prohibited outside {} to avoid ambiguity.
+* Inside {} it is treated as path-to-regexp power syntax and used as-is.
+*
+* Throw error if path can not be compiled into path-to-regexp pattern.
+*
+* Examples:
+*   Required:       [id], [name]
+*   Optional:       {name}, {format}
+*   Splat:          {...path}
+*   Mixed segments: shop/[id]-{name}
+*   Power syntax:   {-v:version{-:pre}}, :name{@:version{.:min}}.js
+* */
+var pathTokensFactory = (path) => {
+	/**
+	* Recursively extract parts from path-to-regexp AST tokens.
+	* A param inside a group is optional; top-level params are required.
+	* Wildcard tokens are always splat.
+	* Slash-only text nodes (restored for parsing) are skipped.
+	* */
+	const extractParts = (tokens, createConst, insideGroup = false) => {
+		const parts = [];
+		for (const token of tokens) switch (token.type) {
+			case "text":
+				if (token.value !== "/") parts.push({
+					type: "static",
+					value: token.value
+				});
+				break;
+			case "param":
+				parts.push({
+					type: "param",
+					kind: insideGroup ? "optional" : "required",
+					name: token.name,
+					const: createConst(token.name)
+				});
+				break;
+			case "wildcard":
+				parts.push({
+					type: "param",
+					kind: "splat",
+					name: token.name,
+					const: createConst(token.name)
+				});
+				break;
+			case "group": parts.push(...extractParts(token.tokens, createConst, true));
+		}
+		return parts;
+	};
+	const patternTransforms = [
+		(s) => s.replace(/\[(\w+)\]/g, ":$1"),
+		(s) => s.replace(/\{(\w+)\}/g, "{:$1}"),
+		(s) => s.replace(/\{\.\.\./g, "{*"),
+		(s) => {
+			return s.startsWith("{") ? s.replace(/^\{/, "{/") : s;
+		}
+	];
+	const detectBareParams = (s) => {
+		let depth = 0;
+		for (const [i, ch] of [...s].entries()) if (ch === "{") depth += 1;
+		else if (ch === "}") depth -= 1;
+		else if (ch === ":" && depth === 0) return s.slice(i + 1).match(/^\w+/)?.[0] || ":";
+	};
+	const tokens = path.replace(/^index\/?/, "").split("/").flatMap((orig) => {
+		if (!orig.length) return [];
+		const bareParam = detectBareParams(orig);
+		if (bareParam === ":") throw new Error(`${path} contains colons outside braces, use : only within {}`);
+		else if (bareParam) throw new Error(`${path} contains bare params, use [${bareParam}] instead of :${bareParam}`);
+		const pattern = patternTransforms.reduce((src, fn) => fn(src), orig);
+		const { tokens } = parse$1(pattern.replace(/\{[^}]*\}|(\+)/g, (m, p1) => p1 ? "\\+" : m));
+		const parts = extractParts(tokens, (val) => {
+			return /\W/.test(val) || /^\d/.test(val) ? [val.replace(/^\d+|\W/g, "_"), crc(orig)].join("_") : val;
+		});
+		const isStatic = parts.length === 1 ? parts[0].type === "static" : false;
+		const isParam = parts.length === 1 ? parts[0].type === "param" : false;
+		return [{
+			kind: isStatic ? "static" : isParam ? "param" : "mixed",
+			orig,
+			pattern,
+			parts
+		}];
+	});
+	compile(tokens.map((e) => e.pattern).join("/"));
+	return tokens;
+};
+var createPathPattern = (tokens) => {
+	return tokens.map(({ pattern }, i) => {
+		const next = tokens[i + 1];
+		if (!next || next.pattern.includes("/")) return pattern;
+		return tokens.slice(i + 1).some((e) => {
+			return e.parts.some((e) => {
+				return e.type === "static" || e.kind === "required";
+			});
+		}) ? `${pattern}/` : pattern;
+	}).join("");
+};
+var createHonoPattern = (tokens) => {
+	const escapeStatic = (s) => s.replace(/[*+?^${}()|[\]\\]/g, "\\$&");
+	const tokensToPattern = (tokens) => {
+		return tokens.flatMap((t) => {
+			if (t.type === "text") return t.value === "/" ? [] : [escapeStatic(t.value)];
+			if (t.type === "param") return ["[^/]+"];
+			if (t.type === "wildcard") return [".+"];
+			if (t.type === "group") return [`(?:${tokensToPattern(t.tokens)})?`];
+			return [];
+		}).join("");
+	};
+	return tokens.flatMap((token, i) => {
+		if (token.kind === "static") return [token.parts[0].value];
+		if (token.kind === "param") {
+			const part = token.parts[0];
+			if (part.kind === "splat") return ["*"];
+			if (part.kind === "optional") return [`:${part.name}?`];
+			return [`:${part.name}`];
+		}
+		const { tokens } = parse$1(token.pattern);
+		return [`:_${i}{${tokensToPattern(tokens)}}`];
+	}).join("/");
+};
+var createH3Pattern = (tokens) => {
+	const escapeStatic = (s) => s.replace(/[-*+?^${}()|[\]\\]/g, "\\$&");
+	const tokensToPattern = (tokens) => {
+		return tokens.flatMap((t) => {
+			if (t.type === "text") return t.value === "/" ? [] : [escapeStatic(t.value)];
+			if (t.type === "param") return [`:${t.name}`];
+			if (t.type === "wildcard") return [`/**:${t.name}?`];
+			if (t.type === "group") return [`{${tokensToPattern(t.tokens)}}?`];
+			return [];
+		}).join("");
+	};
+	return tokens.flatMap((token) => {
+		if (token.kind === "static") return [token.parts[0].value];
+		if (token.kind === "param") {
+			const part = token.parts[0];
+			if (part.kind === "splat") return ["**"];
+			if (part.kind === "optional") return ["*"];
+			return [`:${part.name}`];
+		}
+		const { tokens } = parse$1(token.pattern);
+		return [tokensToPattern(tokens)];
+	}).join("/");
+};
+var createAliasPatterns = (aliasMap) => {
+	return Object.keys(aliasMap || {}).map((alias) => {
+		return createPathPattern(pathTokensFactory(alias));
+	});
+};
+//#endregion
+//#region src/routes/base.ts
+var API_INDEX_BASENAME = "index";
+var API_INDEX_PATTERN = `${API_INDEX_BASENAME}.ts`;
+var API_USE_BASENAME = "use";
+var API_USE_PATTERN = `use.ts`;
+var PAGE_INDEX_BASENAME = "index";
+var PAGE_INDEX_PATTERN = `${PAGE_INDEX_BASENAME}.{tsx,vue,svelte,mdx,md}`;
+var PAGE_LAYOUT_BASENAME = "layout";
+var PAGE_LAYOUT_PATTERN = `${PAGE_LAYOUT_BASENAME}.{tsx,vue,svelte,mdx}`;
+var ROUTE_FILE_PATTERNS = [
+	`${defaults.apiDir}/**/${API_INDEX_PATTERN}`,
+	`${defaults.apiDir}/**/${API_USE_PATTERN}`,
+	`${defaults.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
+	`${defaults.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
+];
+var scanRoutes = async (sourceFolder) => {
+	const { createPath } = pathResolver(sourceFolder);
+	return glob(ROUTE_FILE_PATTERNS, {
+		cwd: createPath.src(),
+		absolute: true,
+		onlyFiles: true,
+		followSymbolicLinks: false,
+		ignore: [
+			`${defaults.apiDir}/${API_INDEX_PATTERN}`,
+			`${defaults.apiDir}/${API_USE_PATTERN}`,
+			`${defaults.pagesDir}/${PAGE_INDEX_PATTERN}`,
+			`${defaults.pagesDir}/${PAGE_LAYOUT_PATTERN}`
+		]
+	});
+};
+var isRouteFile = (file, sourceFolder) => {
+	const [_sourceFolder, _folder, ...rest] = resolve(sourceFolder.root, file).replace(`${sourceFolder.root}/${defaults.srcDir}/`, "").split("/");
+	/**
+	* Ensure the file:
+	* - is under the correct source root
+	* - belongs to a known route folder (`api/` or `pages/`)
+	* - is nested at least one level deep (not a direct child of the folder)
+	* */
+	if (!_folder || _sourceFolder !== sourceFolder.name || rest.length < 2) return false;
+	return picomatch.isMatch(join(_folder, ...rest), ROUTE_FILE_PATTERNS) ? [_folder, rest.join("/")] : false;
+};
+var isApiRoute = (file) => {
+	return picomatch.matchBase(file, `**/${API_INDEX_PATTERN}`);
+};
+var isApiUse = (file) => {
+	return picomatch.matchBase(file, `**/${API_USE_PATTERN}`);
+};
+var isPageRoute = (file) => {
+	return picomatch.matchBase(file, `**/${PAGE_INDEX_PATTERN}`);
+};
+var isPageLayout = (file) => {
+	return picomatch.matchBase(file, `**/${PAGE_LAYOUT_PATTERN}`);
+};
+var createRouteEntry = (fileFullpath, sourceFolder) => {
+	const resolvedPaths = isRouteFile(fileFullpath, sourceFolder);
+	if (!resolvedPaths) return;
+	const [folder, file] = resolvedPaths;
+	const id = `${file.replace(/\W+/g, "_")}_${crc(file)}`;
+	const name = dirname(file);
+	try {
+		const pathTokens = pathTokensFactory(dirname(file));
+		return {
+			id,
+			name,
+			folder,
+			file,
+			fileFullpath,
+			pathTokens,
+			pathPattern: createPathPattern(pathTokens),
+			honoPattern: createHonoPattern(pathTokens),
+			h3Pattern: createH3Pattern(pathTokens)
+		};
+	} catch (error) {
+		console.error(`❗${styleText("red", "ERROR")}: Failed parsing path for "${styleText("cyan", file)}"`);
+		console.error(error.message);
+		return;
+	}
+};
+/**
+* Weight of a single path segment.
+*
+* Fixed values per kind prevent complex mixed segments
+* from outscoring multiple statics.
+*
+*   static:   4  (exact match, most specific)
+*   mixed:    3+ (static + param parts; more statics = slightly higher)
+*   required: 2  (matches any single segment)
+*   optional: 1  (may or may not match)
+*   splat:    0  (matches anything, least specific)
+* */
+var segmentWeight = (token) => {
+	if (token.kind === "static") return 4;
+	if (token.kind === "mixed") {
+		let statics = 0;
+		let optionals = 0;
+		for (const part of token.parts) if (part.type === "static") statics += 1;
+		else if (part.kind === "optional" || part.kind === "splat") optionals += 1;
+		return 3 + statics * .01 - optionals * .005;
+	}
+	switch (token.parts[0].kind) {
+		case "required": return 2;
+		case "optional": return 1;
+		case "splat": return 0;
+	}
+};
+/**
+* Compare two route entries for registration order.
+*
+* More specific routes sort first (higher priority).
+* Segments are compared left-to-right; first difference wins.
+*
+* When one route is a prefix of the other, the trailing segment
+* determines order: a trailing splat loses (shorter sibling first),
+* anything else wins (longer route is more specific).
+*
+* At equal weight and length, lexicographic tiebreak ensures
+* deterministic ordering across JS engines.
+* */
+var sortRoutes = (a, b) => {
+	const pairs = Array.from({ length: Math.max(a.pathTokens.length, b.pathTokens.length) }, (_, i) => [a.pathTokens[i], b.pathTokens[i]]);
+	for (const [at, bt] of pairs) {
+		if (!at || !bt) {
+			const extra = at ?? bt;
+			if (extra?.kind === "param" ? extra.parts[0].kind === "splat" : false) return at ? 1 : -1;
+			return at ? -1 : 1;
+		}
+		const aw = segmentWeight(at);
+		const bw = segmentWeight(bt);
+		if (aw !== bw) return bw - aw;
+	}
+	return a.pathPattern.localeCompare(b.pathPattern);
+};
+/**
+* Compare two route entries for first-match resolution order,
+* as used by the generated svelte/mdx routers.
+*
+* Identical to `sortRoutes` except when one route is a prefix of the other
+* and the trailing extra segment is an optional parameter: there the SHORTER route goes first.
+* The longer route's pattern also matches the bare path (optional omitted),
+* but only the shorter route can serve it - deeper URLs never match the shorter one's pattern,
+* so it must get the first shot:
+*
+*   /blog               -> `blog`, not `blog/{category}/{tag}`
+*   /admin/x/resources  -> `admin/[tenant]/resources`, not `.../resources/{type}`
+*
+* Trailing splats already sort shorter-first in `sortRoutes`;
+* trailing static or required segments make the two patterns disjoint,
+* so their relative order is immaterial for first-match and stays as registration order.
+* */
+var sortRoutesForResolution = (a, b) => {
+	const shorter = a.pathTokens.length < b.pathTokens.length ? a : b;
+	const longer = shorter === a ? b : a;
+	if (a.pathTokens.length !== b.pathTokens.length && shorter.pathTokens.every((token, i) => {
+		const counterpart = longer.pathTokens[i];
+		return segmentWeight(token) === segmentWeight(counterpart);
+	})) {
+		const extra = longer.pathTokens[shorter.pathTokens.length];
+		if (extra.kind === "param" && extra.parts[0].kind === "optional") return shorter === a ? -1 : 1;
+	}
+	return sortRoutes(a, b);
+};
+//#endregion
+//#region src/routes/resolve.ts
+var resolverFactory = (sourceFolder, cacheFactory) => {
+	const { generators } = sourceFolder.config;
+	const { refineTypeName = defaults.refineTypeName } = typeof sourceFolder.config.validation === "object" ? { ...sourceFolder.config.validation } : {};
+	const { typeResolverFactory, resolveRouteSignature } = astFactory();
+	const resolveTypes = generators.some(({ meta }) => meta.resolveTypes);
+	const { literalTypesResolver, getSourceFile, refreshSourceFile } = typeResolverFactory(sourceFolder);
+	return {
+		pageLayoutResolver(entry) {
+			const { name } = entry;
+			const handler = async () => {
+				return {
+					kind: "pageLayout",
+					entry
+				};
+			};
+			return {
+				name,
+				handler
+			};
+		},
+		pageRouteResolver(entry) {
+			const { id, name, folder, file, fileFullpath, pathTokens, pathPattern, honoPattern, h3Pattern } = entry;
+			const handler = async () => {
+				return {
+					kind: "pageRoute",
+					entry: {
+						id,
+						name,
+						pathTokens,
+						pathPattern,
+						honoPattern,
+						h3Pattern,
+						params: { schema: pathTokens.flatMap((e) => {
+							return e.parts.filter((p) => p.type === "param");
+						}) },
+						folder,
+						file,
+						fileFullpath
+					}
+				};
+			};
+			return {
+				name,
+				handler
+			};
+		},
+		apiUseResolver(entry) {
+			const { name } = entry;
+			const handler = async () => {
+				return {
+					kind: "apiUse",
+					entry
+				};
+			};
+			return {
+				name,
+				handler
+			};
+		},
+		apiRouteResolver(entry) {
+			const { id, name, file, folder, fileFullpath, pathTokens, pathPattern, honoPattern, h3Pattern } = entry;
+			const handler = async (updatedFile) => {
+				const paramsSchema = pathTokens.flatMap((e) => {
+					return e.parts.flatMap((p) => {
+						return p.type === "param" ? [p] : [];
+					});
+				});
+				const optionalParams = paramsSchema.length ? paramsSchema.filter((e) => e.kind === "required").length === 0 : true;
+				const cacheStore = cacheFactory ? cacheFactory({
+					id,
+					file,
+					fileFullpath
+				}, sourceFolder, { resolveTypes }) : void 0;
+				let cache = cacheStore ? await cacheStore.get({ validate: true }) : void 0;
+				if (!cache) {
+					if (updatedFile === fileFullpath) await refreshSourceFile(fileFullpath);
+					const { typeDeclarations, paramsRefinements, methods, validationDefinitions, referencedFiles = [] } = await resolveRouteSignature({
+						id,
+						name,
+						fileFullpath,
+						optionalParams
+					}, {
+						withReferencedFiles: true,
+						sourceFile: getSourceFile(fileFullpath),
+						relpathResolver(path) {
+							return join(defaults.srcPrefix, defaults.apiDir, dirname(file), path);
+						}
+					});
+					const validationTypes = validationDefinitions.flatMap((def) => {
+						return def.target === "response" ? def.variants.flatMap(({ id, body }) => {
+							return body ? [{
+								id,
+								text: body
+							}] : [];
+						}) : [def.schema];
+					});
+					const typesFile = pathResolver(sourceFolder).createPath.libApi(dirname(file), "types.ts");
+					const params = {
+						id: ["ParamsT", crc(name)].join(""),
+						schema: paramsSchema,
+						resolvedType: void 0
+					};
+					const typesFileContent = render(types_default, {
+						params,
+						paramsSchema: paramsSchema.map((param, index) => {
+							return {
+								...param,
+								isRequired: param.kind === "required",
+								isSplat: param.kind === "splat",
+								refinement: paramsRefinements?.at(index)
+							};
+						}),
+						typeDeclarations,
+						validationTypes
+					});
+					const resolvedTypes = resolveTypes ? literalTypesResolver(typesFileContent, {
+						stripComments: true,
+						overrides: { [refineTypeName]: refineTypeName },
+						withProperties: [params.id, ...validationTypes.map(({ id }) => id)]
+					}) : void 0;
+					/**
+					* Deploy types.ts file; required by core generators (like fetch).
+					* If types resolved, write resolved types;
+					* otherwise write original types extracted from API route.
+					* */
+					await renderToFile(typesFile, resolvedTypes ? resolved_types_default : typesFileContent, { resolvedTypes });
+					params.resolvedType = resolvedTypes?.find((e) => e.name === params.id);
+					cache = {
+						hash: 0,
+						referencedFiles: {},
+						params,
+						methods,
+						typeDeclarations,
+						validationDefinitions: validationDefinitions.map((def) => {
+							return {
+								...def,
+								...def.target === "response" ? { variants: def.variants.map((variant) => {
+									return {
+										...variant,
+										resolvedType: resolvedTypes?.find((e) => e.name === variant.id)
+									};
+								}) } : { schema: {
+									...def.schema,
+									resolvedType: resolvedTypes?.find((e) => e.name === def.schema.id)
+								} }
+							};
+						})
+					};
+					if (cacheStore) {
+						const { referencedFiles: _void, ...rest } = cache;
+						cache = await cacheStore.set({
+							...rest,
+							referencedFiles
+						});
+					}
+				}
+				const validationDefinitions = cache.validationDefinitions.flatMap((def) => {
+					let augmentedDef = def;
+					if (def.target === "response") augmentedDef = {
+						...def,
+						variants: def.variants.flatMap((variant, i) => {
+							if (typeof variant.contentType !== "string") return [variant];
+							if (variant.contentType.includes("/")) return [variant];
+							const contentType = lookup(variant.contentType);
+							if (!contentType) {
+								console.warn(styleText(["bold", "red"], "✗ Failed resolving Response Content Type"));
+								console.warn(`  Invalid value provided for mime-types lookup - ${variant.contentType}`);
+								console.warn(styleText(["cyan"], `  Response variant #${i} excluded from route schemas`));
+								console.warn(`  Route: ${name}; Method: ${def.method}`);
+								console.warn();
+								return [];
+							}
+							return [{
+								...variant,
+								contentType
+							}];
+						})
+					};
+					else if (def.contentType && !def.contentType.includes("/")) {
+						const contentType = lookup(def.contentType);
+						if (!contentType) {
+							console.warn(styleText(["bold", "red"], "✗ Failed resolving Response Content Type"));
+							console.warn(`  Invalid value provided for mime-types lookup - ${def.contentType}`);
+							console.warn(`  Route: ${name}; Method: ${def.method}`);
+							console.warn();
+						} else augmentedDef = {
+							...def,
+							contentType
+						};
+					}
+					return augmentedDef ? [augmentedDef] : [];
+				});
+				return {
+					kind: "apiRoute",
+					entry: {
+						id,
+						name,
+						pathTokens,
+						pathPattern,
+						honoPattern,
+						h3Pattern,
+						params: cache.params,
+						optionalParams,
+						folder,
+						file,
+						fileFullpath,
+						methods: cache.methods,
+						typeDeclarations: cache.typeDeclarations,
+						validationDefinitions,
+						referencedFiles: Object.keys(cache.referencedFiles).map((e) => resolve(sourceFolder.root, e))
+					}
+				};
+			};
+			return {
+				name,
+				handler
+			};
+		}
+	};
+};
+//#endregion
+//#region src/routes/nesting.ts
+var nestedRoutesFactory = (routeEntries) => {
+	const entryStack = structuredClone(routeEntries).sort(sortRoutes);
+	/**
+	* Group entries by name (at the same level, both layout and index share same name).
+	*
+	* Handle 3 cases:
+	*    - both index and layout exists
+	*    - only index exists
+	*    - only layout exists
+	*
+	* */
+	const transformEntries = (entries, parent) => {
+		return [...new Set(entries.map((e) => e.name))].flatMap((name) => {
+			const nameEntries = entryStack.flatMap(({ fileFullpath, ...entry }) => {
+				return entry.name === name ? [entry] : [];
+			});
+			const index = nameEntries.find((e) => basename(e.file).startsWith(PAGE_INDEX_BASENAME));
+			const layout = nameEntries.find((e) => basename(e.file).startsWith(PAGE_LAYOUT_BASENAME));
+			if (index || layout) return [{
+				index: index ? {
+					...index,
+					pathTokens: index.pathTokens.slice(parent?.pathTokens.length || 0)
+				} : void 0,
+				layout: layout ? {
+					...layout,
+					pathTokens: layout.pathTokens.slice(parent?.pathTokens.length || 0)
+				} : void 0,
+				parent: parent?.name,
+				children: transformEntries(findDescendantEntries(index || layout), index || layout)
+			}];
+			return [];
+		});
+	};
+	/**
+	* Recursively finds direct descendant routes.
+	*
+	* "Direct" means the next existing route in the path hierarchy,
+	* skipping intermediate path segments that don't have index/layout files.
+	*
+	* Example: blog/post/[slug]/index.tsx is a direct child of blog/index.tsx
+	* even though "post" segment exists (it has no index.tsx).
+	* */
+	const findDescendantEntries = ({ name, pathTokens }) => {
+		const potentialChildren = entryStack.filter((entry) => {
+			if (entry.pathTokens.length <= pathTokens.length) return false;
+			if (!entry.name.startsWith(posix.join(name, "/"))) return false;
+			return true;
+		});
+		return potentialChildren.filter((child) => {
+			return !potentialChildren.some((intermediate) => {
+				if (intermediate === child) return false;
+				if (intermediate.pathTokens.length <= pathTokens.length) return false;
+				if (intermediate.pathTokens.length >= child.pathTokens.length) return false;
+				return child.name.startsWith(posix.join(intermediate.name, "/"));
+			});
+		});
+	};
+	return transformEntries(entryStack.filter((entry) => {
+		return !entryStack.some((potential) => {
+			if (potential === entry) return false;
+			if (potential.pathTokens.length >= entry.pathTokens.length) return false;
+			return entry.name.startsWith(posix.join(potential.name, "/"));
+		});
+	}));
+};
+//#endregion
+//#region src/routes/index.ts
+var routesFactory = async (sourceFolder, cacheFactory) => {
+	const { apiRouteResolver, apiUseResolver, pageRouteResolver, pageLayoutResolver } = resolverFactory(sourceFolder, cacheFactory);
+	const resolversFactory = (routeFiles) => {
+		const resolvers = /* @__PURE__ */ new Map();
+		const entries = routeFiles.flatMap((file) => {
+			const entry = createRouteEntry(file, sourceFolder);
+			return entry ? [entry] : [];
+		});
+		for (const entry of entries) if (entry.folder === defaults.apiDir) {
+			if (isApiRoute(entry.file)) resolvers.set(entry.fileFullpath, apiRouteResolver(entry));
+			else if (isApiUse(entry.file)) resolvers.set(entry.fileFullpath, apiUseResolver(entry));
+		} else if (entry.folder === defaults.pagesDir) {
+			if (isPageRoute(entry.file)) resolvers.set(entry.fileFullpath, pageRouteResolver(entry));
+			else if (isPageLayout(entry.file)) resolvers.set(entry.fileFullpath, pageLayoutResolver(entry));
+		}
+		return resolvers;
+	};
+	return {
+		resolvers: resolversFactory(await scanRoutes(sourceFolder)),
+		resolversFactory
+	};
+};
+//#endregion
+//#region src/spinner.ts
+var spinnerFactory = (startText) => {
+	if (!process.stdout.isTTY || process.env.CI || process.env.TERM === "dumb") return {
+		text() {},
+		append() {},
+		succeed() {},
+		failed() {}
+	};
+	const spinner = new Spinner().start(startText);
+	let _text = startText;
+	return {
+		text(text) {
+			_text = text;
+			spinner.text = text;
+		},
+		append(text) {
+			spinner.text = `${_text} › ${text}`;
+		},
+		succeed(text) {
+			if (text) this.append(text);
+			else this.text(_text);
+			spinner.succeed();
+		},
+		failed(text) {
+			if (text) this.text([_text, text].join("\n"));
+			spinner.failed();
+		}
+	};
+};
+//#endregion
+//#region src/vite.ts
+/**
+* Resolves Kosmo's generated import prefixes to absolute file paths.
+*
+* WHY THIS EXISTS
+* ---------------
+* Every source folder is scaffolded with three tsconfig `paths` prefixes
+* that let generated and user code import across
+* the folder's layout without long relative chains:
+*
+*   appPrefix "@" -> the project root            (<root>/*)
+*   srcPrefix "~" -> the folder's src dir        (<root>/src/<name>/*)
+*   libPrefix "_" -> the folder's lib dir        (<root>/lib/<name>/*)
+*
+* These are the backbone of the generated code: `defineRoute` and friends are
+* emitted with `_/...` imports, pages import layouts and components via `~/...`,
+* and `@/...` reaches shared app-level modules. If a bundler cannot resolve
+* them, nothing the framework generates can be loaded.
+*
+* Historically Vite resolved these through its built-in `resolve.tsconfigPaths: true`,
+* reading the `paths` straight from the generated tsconfig. That option
+* regressed in Vite 8.1.0 (still broken as of 8.1.3): it stops resolving
+* `paths` mappings, especially those defined in an extended / referenced base
+* config - which is exactly Kosmo's structure, where a source folder's
+* tsconfig `extends` `lib/<name>/tsconfig.json` and the paths use the
+* TypeScript `${configDir}` variable. The failure surfaces as:
+*
+*   [vite] Failed to resolve import "_/pageSamples/welcome.vue" from
+*   "src/<name>/pages/index/index.vue". Does the file exist?
+*
+* (Upstream: vitejs/vite #22139, #22047, #22371, #21889, #21856.)
+*
+* Rather than pin Vite to 8.0.x indefinitely, or depend on the general-purpose
+* `vite-tsconfig-paths` plugin, this internal plugin resolves ONLY
+* known prefixes against dirs derived from the source folder. That makes it:
+*
+*   - Correct on 8.1.x, where native `tsconfigPaths` is broken.
+*   - Faster: no tsconfig discovery, no `extends` chain walking, no glob
+*     matching - just a prefix check and a handful of `stat` probes,
+*     cached by Vite per specifier.
+*   - Non-blocking: probes via async `fs/promises` `stat`, so `resolveId` never
+*     stalls the event loop.
+*   - `.vue` / `.mdx`-aware: `resolveId` sees every specifier regardless of the
+*     importer's type, so imports from non-JS files resolve without the
+*     `loose` / `allowJs` escape hatches `vite-tsconfig-paths` needs.
+*
+* A project with custom `paths` beyond these three prefixes should install
+* `vite-tsconfig-paths`; this plugin is internal and intentionally narrow.
+*
+* The prefix -> dir bases come from `pathResolver`, the same source of truth the
+* tsconfig generator uses, so alias resolution here can never drift from the
+* paths that were written into the generated tsconfig.
+* */
+var tsconfigPaths = (sourceFolder) => {
+	/**
+	* Candidate extensions for an extensionless specifier, in resolution priority order.
+	* Mirrors the renderable file types the generators emit;
+	* a new page type (e.g. `.svelte`) must be added here or its aliased imports won't resolve.
+	* */
+	const EXTENSIONS = [
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".vue",
+		".svelte",
+		".md",
+		".mdx",
+		".json"
+	];
+	const { createPath } = pathResolver(sourceFolder);
+	const table = [
+		[`${defaults.srcPrefix}/`, createPath.src()],
+		[`${defaults.libPrefix}/`, createPath.lib()],
+		[`${defaults.appPrefix}/`, sourceFolder.root]
+	];
+	const resolveWithin = async (baseDir, rest) => {
+		const target = join(baseDir, rest);
+		const { ext } = parse(rest);
+		if (EXTENSIONS.includes(ext)) {
+			for (const candidate of [target, `${target}/index${ext}`]) if (await isFile(candidate)) return candidate;
+			return target;
+		}
+		for (const e of EXTENSIONS) for (const candidate of [`${target}${e}`, `${target}/index${e}`]) if (await isFile(candidate)) return candidate;
+		return target;
+	};
+	return {
+		name: "kosmo:tsconfigPaths",
+		enforce: "pre",
+		async resolveId(source) {
+			if (isAbsolute(source) || source.startsWith(".")) return;
+			for (const [prefix, baseDir] of table) if (source.startsWith(prefix)) return resolveWithin(baseDir, source.replace(prefix, ""));
+		}
+	};
+};
+var nodePrefix = () => {
+	return {
+		name: "kosmojs:node-prefix",
+		enforce: "pre",
+		resolveId(source) {
+			return builtinModules.includes(source) ? {
+				id: `node:${source}`,
+				external: true
+			} : void 0;
+		}
+	};
+};
+/**
+* Resolves the CSR/SSR variant of env-sensitive modules.
+*
+* WHY THIS EXISTS
+* ---------------
+* A handful of generated modules must differ between the client graph and the SSR bundle -
+* the fetch transport (a no-op in the browser, an in-process dispatch on the server)
+* and the TanStack Query client (a singleton in the browser, per-request on the server).
+*
+* Every build installs this plugin; but only the SSR bundle installs it with `kind: "ssr"`.
+* Nothing is written, so concurrent processes cannot disturb each other.
+*
+* Generators declare their modules via `factory.virtualModules()`.
+* */
+var virtualModules = (sourceFolder, { kind, command }) => {
+	/**
+	* Rollup's / Rolldown's convention for ids owned by a plugin:
+	* the NUL prefix keeps other plugins and Node resolution from touching them.
+	* */
+	const VIRTUAL_PREFIX = "\0";
+	const modules = sourceFolder.config.generators.flatMap(({ factory }) => {
+		return factory(sourceFolder).virtualModules?.() || [];
+	});
+	const virtualSources = /* @__PURE__ */ new Map();
+	for (const { specifier, csr, ssr } of modules) virtualSources.set(specifier, {
+		csr,
+		ssr
+	});
+	{
+		const source = `export const command = "${command}";`;
+		virtualSources.set("virtual:kosmo/env", {
+			csr: source,
+			ssr: source
+		});
+	}
+	return {
+		name: "kosmo:virtualModules",
+		enforce: "pre",
+		resolveId(source) {
+			return virtualSources.has(source) ? VIRTUAL_PREFIX + source : void 0;
+		},
+		load(id) {
+			return id.startsWith(VIRTUAL_PREFIX) ? virtualSources.get(id.slice(1))?.[kind] : void 0;
+		}
+	};
+};
+var vitePlugins = {
+	tsconfigPaths,
+	nodePrefix,
+	virtualModules
+};
+var isFile = async (path) => {
+	return stat(path).then((e) => e.isFile()).catch(() => false);
 };
+//#endregion
+export { API_INDEX_BASENAME, API_INDEX_PATTERN, API_USE_BASENAME, API_USE_PATTERN, PAGE_INDEX_BASENAME, PAGE_INDEX_PATTERN, PAGE_LAYOUT_BASENAME, PAGE_LAYOUT_PATTERN, astFactory, containsPathTraversalPatterns, createAliasPatterns, createH3Pattern, createHonoPattern, createPathPattern, createRouteEntry, createWatchedApiRouteEntriesFilter, createWatchedPageRouteEntriesFilter, defineGenerator, defineGeneratorFactory, escapeTemplateLiterals, isApiRoute, isApiUse, isPageLayout, isPageRoute, isRouteFile, mergeConfigs, nestedRoutesFactory, pathExists, pathResolver, pathTokensFactory, render, renderFactory, renderToFile, routesFactory, scanRoutes, sortRoutes, sortRoutesForResolution, spinnerFactory, tsconfigPaths, virtualModules, vitePlugins };
 
-{{#each validationTypes}}export type {{id}} = {{text}};
-{{/each}}
-`,F=()=>{let e=e=>new a(e),u=async(t,n)=>{let{sourceFile:r=e().addSourceFileAtPath(t.fileFullpath)}={...n},[i,a]=y(r,n),o=d(r),s=o?f(o):void 0,c=o?p(t,o):[];return{typeDeclarations:i,paramsRefinements:s,methods:c.map(e=>e.method),validationDefinitions:c.flatMap(e=>e.validationDefinitions),referencedFiles:a}},d=e=>{let[t]=e.getExportAssignments().flatMap(e=>{if(e.isExportEquals())return[];let t=e.getExpression();return t.isKind(o.CallExpression)?[t]:[]});return t},f=e=>{let[t,n]=x(e);if(n?.isKind(o.TupleType))return n.getElements().map((e,t)=>({index:t,text:e.getText()}))},p=(e,t)=>{let n=t.getFirstChildByKind(o.ArrowFunction)||t.getFirstChildByKind(o.FunctionExpression);if(!n)return[];let r=n.getFirstChildByKind(o.ArrayLiteralExpression);if(!r)return[];let i=[];for(let e of r.getChildrenOfKind(o.CallExpression)){let t=e.getExpression().getText();l[t]&&i.push([e,t])}let a=[];for(let[t,n]of i){let[r,i]=x(t);a.push({method:n,validationDefinitions:v(e,n,r,i)})}return a},m=e=>{if(e.isKind(o.LiteralType)){let t=e.getFirstChild();if(t?.isKind(o.TrueKeyword))return!0;if(t?.isKind(o.FalseKeyword))return!1}},h=e=>{if(!e.isKind(o.TupleType))return;let t=200,n,r,[i,a,s]=e.getElements();if(i?.isKind(o.LiteralType)){let e=i.getFirstChildByKind(o.NumericLiteral);e&&(t=Number(e.getText()))}return a&&(n=_(a)),s&&(r=s.getText(),[`object`].includes(r)&&(r=`{}`)),{status:t,contentType:n,body:r}},g=e=>{let t={};if(!e?.isKind(o.TypeLiteral))return t;for(let n of e.getMembers()){if(!n.isKind(o.PropertySignature))continue;let e=n.getName(),r=n.getTypeNodeOrThrow();if(!r.isKind(o.TypeLiteral))continue;let i,a,s={};for(let e of r.getMembers()){if(!e.isKind(o.PropertySignature))continue;let t=ie(e),n=e.getTypeNodeOrThrow();if(t===`contentType`)i=_(n);else if(t===`runtimeValidation`)a=m(n);else if(t.startsWith(`error`)){let e=_(n);e&&(s[t]=e)}}t[e]={contentType:i,runtimeValidation:a,customErrors:s}}return t},_=e=>{let t=e.isKind(o.LiteralType)?e.getFirstChildByKind(o.StringLiteral):void 0;return t?t.getLiteralText():void 0},v=(e,r,i,a)=>{let c=[];if(!i?.isKind(o.TypeLiteral))return c;let l=g(a),u=(t,i)=>[t.replace(/^./,e=>e.toUpperCase()),`T`,r,n(e.id+i)].join(``);for(let n of i.getMembers()){if(!n.isKind(o.PropertySignature))continue;let i=n.getName(),a=n.getTypeNodeOrThrow();if(i===`response`){let n=a.isKind(o.UnionType)?a.getChildrenOfKind(o.TupleType):[a];c.push({...l[i],method:r,target:i,variants:n.flatMap((n,a)=>{let{status:o,contentType:s,body:c}={...h(n)};return o?(s&&typeof s!=`string`&&(console.warn(t([`bold`,`red`],`✗ The second element of a response variant should specify the Response Content Type`)),console.warn(t([`blue`],`  Example: [200, "json", Schema]`)),console.warn(`  Route: ${e.name}; Method: ${r}; Response Variant: #${a}`),console.warn()),[{id:u(i,JSON.stringify([o,s,c])),status:o,contentType:s,body:c}]):[]})})}else Object.keys(s).includes(i)&&c.push({...l[i],method:r,target:i,schema:{id:u(i),text:a.getText()}})}return c},y=(e,t)=>{let n=[],r=t?.withReferencedFiles?[]:void 0;for(let i of e.getImportDeclarations()){let e=i.getModuleSpecifierValue(),a=/^\.\.?\/?/.test(e)&&t?.relpathResolver?t.relpathResolver(e):e,s=i.isTypeOnly(),c=s?i.getDefaultImport():void 0;if(c){let e=c.getText(),t=`import type ${e} from "${a}";`;n.push({importDeclaration:{name:e,path:a},text:t}),r&&r.push(...b(c))}let l=s?i.getNamespaceImport():void 0;if(l){let e=l.getText(),t=`import type * as ${e} from "${a}";`;n.push({importDeclaration:{name:e,path:a},text:t}),r&&r.push(...b(l))}for(let e of i.getNamedImports())if(e.isTypeOnly()||s){let t=e.getNameNode(),i=t.getText(),s=e.getAliasNode()?.getText(),c=s?`${i} as ${s}`:i;n.push({importDeclaration:{name:i,alias:s,path:a},text:`import type { ${c} } from "${a}";`}),r&&t.isKind(o.Identifier)&&r.push(...b(t))}}for(let t of e.getTypeAliases()){let e=t.getName(),r=t.getFullText().trim();n.push({typeAliasDeclaration:{name:e},text:r})}for(let t of e.getInterfaces()){let e=t.getName(),r=t.getFullText().trim();n.push({interfaceDeclaration:{name:e},text:r})}for(let t of e.getEnums()){let e=t.getName(),r=t.getFullText().trim();n.push({enumDeclaration:{name:e},text:r})}for(let i of e.getExportDeclarations()){let e=i.isTypeOnly(),a=i.getModuleSpecifierValue(),s=a?/^\.\.?\/?/.test(a)&&t?.relpathResolver?t.relpathResolver(a):a:void 0;for(let t of i.getNamedExports())if(t.isTypeOnly()||e){let e=t.getNameNode(),i=e.getText(),a=t.getAliasNode()?.getText(),c=a?`${i} as ${a}`:i;n.push({exportDeclaration:{name:i,alias:a??i,path:s},text:s?`export type { ${c} } from "${s}";`:`export type { ${c} };`}),r&&e.isKind(o.Identifier)&&r.push(...b(e))}}return r?[n,[...new Set(r)]]:[n]},b=e=>(e?.getSymbol()?.getAliasedSymbol()?.getDeclarations()||[]).flatMap(e=>{let t=e.getSourceFile();return t?[t.getFilePath()]:[]}),x=e=>e.getTypeArguments();return{createProject:e,extractDefaultExport:d,extractParamsRefinements:f,extractRouteMethods:p,extractTypeDeclarations:y,resolveRouteSignature:u,typeResolverFactory:t=>{let{createPath:a}=A(t),s=e({compilerOptions:{moduleResolution:i.Bundler,types:[],noLib:!0,skipLibCheck:!0,paths:{[`${c.appPrefix}/*`]:[`${t.root}/*`],[`${c.srcPrefix}/*`]:[a.src(`*`)],[`${c.libPrefix}/*`]:[a.lib(`*`)]}}}),l=e=>{let t=M(P,{resolvedTypes:e}),r=s.createSourceFile(`${n(t)}-${Date.now()}.ts`,t,{overwrite:!0});return e.map(e=>{let t=r.getTypeAlias(e.name)?.getTypeNode();if(!t)return e;let n=[],i=[],a=[];for(let r of e.properties||[]){let e=t.isKind(o.TypeLiteral)?t.getProperty(r.nameDeclaration)?.getTypeNode():void 0;e&&(n.push({...r,typeboxSchema:ae(e)}),I(e)&&i.push(r.name),L(e)&&a.push(r.name))}return{...e,properties:n,numericProperties:i,booleanProperties:a,typeboxSchema:ae(t)}})};return{getSourceFile:e=>s.getSourceFile(e)||s.addSourceFileAtPath(e),refreshSourceFile:async e=>{let t=s.getSourceFile(e);t&&await t.refreshFromFileSystem()},literalTypesResolver:(e,t)=>{let i=s.createSourceFile(`${n(e)}-${Date.now()}.ts`,e,{overwrite:!0}),a=r(s,i,{...t,stripComments:!0});return l(a)}}}}},ie=e=>{let t=e.getNameNode();return t.isKind(o.StringLiteral)?t.getLiteralValue():t.getText()},I=(e,t=c.refineTypeName)=>{if(e.isKind(o.ParenthesizedType))return I(e.getTypeNode(),t);if(e.isKind(o.TypeReference)){let n=e.getTypeName().getText();return n===t||n===`Array`?I(e.getTypeArguments()[0],t):!1}if(e.isKind(o.ArrayType))return I(e.getElementTypeNode(),t);if(e.isKind(o.TypeOperator))return e.getOperator()===o.ReadonlyKeyword&&I(e.getTypeNode(),t);if(e.isKind(o.UnionType))return e.getTypeNodes().every(e=>I(e,t));if(e.isKind(o.LiteralType)){let t=e.getLiteral();return t.isKind(o.PrefixUnaryExpression)?t.getOperand().isKind(o.NumericLiteral):t.isKind(o.NumericLiteral)}return e.isKind(o.NumberKeyword)},L=e=>{if(e.isKind(o.ParenthesizedType))return L(e.getTypeNode());if(e.isKind(o.TypeReference))return e.getTypeName().getText()===`Array`&&L(e.getTypeArguments()[0]);if(e.isKind(o.ArrayType))return L(e.getElementTypeNode());if(e.isKind(o.TypeOperator))return e.getOperator()===o.ReadonlyKeyword&&L(e.getTypeNode());if(e.isKind(o.LiteralType)){let t=e.getLiteral();return t.isKind(o.TrueKeyword)||t.isKind(o.FalseKeyword)}return e.isKind(o.BooleanKeyword)},ae=(e,t=c.refineTypeName)=>{let n=e=>{if(e.isKind(o.TypeReference)&&e.getTypeName().getText()===t){let[t,r]=e.getTypeArguments();return!t||!r?e.getText():`(${n(t)} with ${r.getText()})`}if(e.isKind(o.ArrayType))return`${n(e.getElementTypeNode())}[]`;if(e.isKind(o.TypeLiteral)){let t=[];for(let r of e.getMembers())if(r.isKind(o.PropertySignature)){let e=r.getName(),i=r.hasQuestionToken()?`?`:``,a=r.getTypeNode(),o=a?n(a):`unknown`;t.push(`${e}${i}: ${o}`)}else t.push(r.getText());return`{ ${t.join(`, `)} }`}if(e.isKind(o.TupleType))return`[${e.getElements().map(e=>n(e)).join(`, `)}]`;if(e.isKind(o.ParenthesizedType))return`(${n(e.getTypeNode())})`;if(e.isKind(o.UnionType))return e.getTypeNodes().map(e=>n(e)).join(` | `);if(e.isKind(o.IntersectionType))return e.getTypeNodes().map(e=>n(e)).join(` & `);if(e.isKind(o.TypeReference)){let t=e.getTypeArguments();return t.length===0?e.getText():`${e.getTypeName().getText()}<${t.map(e=>n(e)).join(`, `)}>`}return e.getText()};return te(n(e))},oe=({meta:e,factory:t,dependencies:n,devDependencies:r})=>{let i=(i=>({meta:e,factory:e=>t(e,i),dependencies:n,devDependencies:r,options:i}));return Object.assign(i,{meta:e,dependencies:n,devDependencies:r}),i},se=e=>e,ce=(e,t)=>({kind:n,entry:r})=>e?t.includes(e.kind)&&(n===`apiRoute`||n===`apiUse`)?r.fileFullpath===e.file||r.referencedFiles?.includes(e.file):!1:!0,le=(e,t)=>({kind:n,entry:r})=>e?t.includes(e.kind)&&(n===`pageRoute`||n===`pageLayout`)?r.fileFullpath===e.file:!1:!0,ue=(e,t)=>t.flatMap(({factory:t})=>t(e).virtualModules?.()||[]),R=e=>{let t=(e,n,r=!1)=>{let i=[];for(let a of e)switch(a.type){case`text`:a.value!==`/`&&i.push({type:`static`,value:a.value});break;case`param`:i.push({type:`param`,kind:r?`optional`:`required`,name:a.name,const:n(a.name)});break;case`wildcard`:i.push({type:`param`,kind:`splat`,name:a.name,const:n(a.name)});break;case`group`:i.push(...t(a.tokens,n,!0))}return i},r=[e=>e.replace(/\[(\w+)\]/g,`:$1`),e=>e.replace(/\{(\w+)\}/g,`{:$1}`),e=>e.replace(/\{\.\.\./g,`{*`),e=>e.startsWith(`{`)?e.replace(/^\{/,`{/`):e],i=e=>{let t=0;for(let[n,r]of[...e].entries())if(r===`{`)t+=1;else if(r===`}`)--t;else if(r===`:`&&t===0)return e.slice(n+1).match(/^\w+/)?.[0]||`:`},a=e.replace(/^index\/?/,``).split(`/`).flatMap(a=>{if(!a.length)return[];let o=i(a);if(o===`:`)throw Error(`${e} contains colons outside braces, use : only within {}`);if(o)throw Error(`${e} contains bare params, use [${o}] instead of :${o}`);let s=r.reduce((e,t)=>t(e),a),{tokens:c}=D(s.replace(/\{[^}]*\}|(\+)/g,(e,t)=>t?`\\+`:e)),l=t(c,e=>/\W/.test(e)||/^\d/.test(e)?[e.replace(/^\d+|\W/g,`_`),n(a)].join(`_`):e),u=l.length===1&&l[0].type===`static`,d=l.length===1&&l[0].type===`param`;return[{kind:u?`static`:d?`param`:`mixed`,orig:a,pattern:s,parts:l}]});return E(a.map(e=>e.pattern).join(`/`)),a},z=e=>e.map(({pattern:t},n)=>{let r=e[n+1];return!r||r.pattern.includes(`/`)?t:e.slice(n+1).some(e=>e.parts.some(e=>e.type===`static`||e.kind===`required`))?`${t}/`:t}).join(``),B=e=>{let t=e=>e.replace(/[*+?^${}()|[\]\\]/g,`\\$&`),n=e=>e.flatMap(e=>e.type===`text`?e.value===`/`?[]:[t(e.value)]:e.type===`param`?[`[^/]+`]:e.type===`wildcard`?[`.+`]:e.type===`group`?[`(?:${n(e.tokens)})?`]:[]).join(``);return e.flatMap((e,t)=>{if(e.kind===`static`)return[e.parts[0].value];if(e.kind===`param`){let t=e.parts[0];return t.kind===`splat`?[`*`]:t.kind===`optional`?[`:${t.name}?`]:[`:${t.name}`]}let{tokens:r}=D(e.pattern);return[`:_${t}{${n(r)}}`]}).join(`/`)},V=e=>{let t=e=>e.replace(/[-*+?^${}()|[\]\\]/g,`\\$&`),n=e=>e.flatMap(e=>e.type===`text`?e.value===`/`?[]:[t(e.value)]:e.type===`param`?[`:${e.name}`]:e.type===`wildcard`?[`/**:${e.name}?`]:e.type===`group`?[`{${n(e.tokens)}}?`]:[]).join(``);return e.flatMap(e=>{if(e.kind===`static`)return[e.parts[0].value];if(e.kind===`param`){let t=e.parts[0];return t.kind===`splat`?[`**`]:t.kind===`optional`?[`*`]:[`:${t.name}`]}let{tokens:t}=D(e.pattern);return[n(t)]}).join(`/`)},H=`index`,U=`${H}.ts`,de=`use`,W=`use.ts`,G=`index`,K=`${G}.{tsx,vue,svelte,mdx,md}`,q=`layout`,J=`${q}.{tsx,vue,svelte,mdx}`,Y=[`${c.apiDir}/**/${U}`,`${c.apiDir}/**/${W}`,`${c.pagesDir}/**/${K}`,`${c.pagesDir}/**/${J}`],X=async e=>{let{createPath:t}=A(e);return T(Y,{cwd:t.src(),absolute:!0,onlyFiles:!0,followSymbolicLinks:!1,ignore:[`${c.apiDir}/${U}`,`${c.apiDir}/${W}`,`${c.pagesDir}/${K}`,`${c.pagesDir}/${J}`]})},Z=(e,t)=>{let[n,r,...i]=S(t.root,e).replace(`${t.root}/${c.srcDir}/`,``).split(`/`);return!r||n!==t.name||i.length<2?!1:w.isMatch(b(r,...i),Y)?[r,i.join(`/`)]:!1},fe=e=>w.matchBase(e,`**/${U}`),pe=e=>w.matchBase(e,`**/${W}`),me=e=>w.matchBase(e,`**/${K}`),he=e=>w.matchBase(e,`**/${J}`),ge=(e,r)=>{let i=Z(e,r);if(!i)return;let[a,o]=i,s=`${o.replace(/\W+/g,`_`)}_${n(o)}`,c=v(o);try{let t=R(v(o));return{id:s,name:c,folder:a,file:o,fileFullpath:e,pathTokens:t,pathPattern:z(t),honoPattern:B(t),h3Pattern:V(t)}}catch(e){console.error(`❗${t(`red`,`ERROR`)}: Failed parsing path for "${t(`cyan`,o)}"`),console.error(e.message);return}},Q=e=>{if(e.kind===`static`)return 4;if(e.kind===`mixed`){let t=0,n=0;for(let r of e.parts)r.type===`static`?t+=1:(r.kind===`optional`||r.kind===`splat`)&&(n+=1);return 3+t*.01-n*.005}switch(e.parts[0].kind){case`required`:return 2;case`optional`:return 1;case`splat`:return 0}},$=(e,t)=>{let n=Array.from({length:Math.max(e.pathTokens.length,t.pathTokens.length)},(n,r)=>[e.pathTokens[r],t.pathTokens[r]]);for(let[e,t]of n){if(!e||!t){let n=e??t;return n?.kind===`param`&&n.parts[0].kind===`splat`?e?1:-1:e?-1:1}let n=Q(e),r=Q(t);if(n!==r)return r-n}return e.pathPattern.localeCompare(t.pathPattern)},_e=(e,t)=>{let n=e.pathTokens.length<t.pathTokens.length?e:t,r=n===e?t:e;if(e.pathTokens.length!==t.pathTokens.length&&n.pathTokens.every((e,t)=>{let n=r.pathTokens[t];return Q(e)===Q(n)})){let t=r.pathTokens[n.pathTokens.length];if(t.kind===`param`&&t.parts[0].kind===`optional`)return n===e?-1:1}return $(e,t)},ve=(e,r)=>{let{generators:i=[],refineTypeName:a=c.refineTypeName}=e.config,{typeResolverFactory:o,resolveRouteSignature:s}=F(),l=i.some(({meta:e})=>e.resolveTypes),{literalTypesResolver:u,getSourceFile:d,refreshSourceFile:f}=o(e);return{pageLayoutResolver(e){let{name:t}=e;return{name:t,handler:async()=>({kind:`pageLayout`,entry:e})}},pageRouteResolver(e){let{id:t,name:n,folder:r,file:i,fileFullpath:a,pathTokens:o,pathPattern:s,honoPattern:c,h3Pattern:l}=e;return{name:n,handler:async()=>({kind:`pageRoute`,entry:{id:t,name:n,pathTokens:o,pathPattern:s,honoPattern:c,h3Pattern:l,params:{schema:o.flatMap(e=>e.parts.filter(e=>e.type===`param`))},folder:r,file:i,fileFullpath:a}})}},apiUseResolver(e){let{name:t}=e;return{name:t,handler:async()=>({kind:`apiUse`,entry:e})}},apiRouteResolver(i){let{id:o,name:p,file:m,folder:h,fileFullpath:g,pathTokens:_,pathPattern:y,honoPattern:x,h3Pattern:C}=i;return{name:p,handler:async i=>{let w=_.flatMap(e=>e.parts.flatMap(e=>e.type===`param`?[e]:[])),T=!w.length||w.filter(e=>e.kind===`required`).length===0,E=r?r({id:o,file:m,fileFullpath:g},e,{resolveTypes:l}):void 0,D=E?await E.get({validate:!0}):void 0;if(!D){i===g&&await f(g);let{typeDeclarations:t,paramsRefinements:r,methods:h,validationDefinitions:_,referencedFiles:y=[]}=await s({id:o,name:p,fileFullpath:g,optionalParams:T},{withReferencedFiles:!0,sourceFile:d(g),relpathResolver(e){return b(c.srcPrefix,c.apiDir,v(m),e)}}),x=_.flatMap(e=>e.target===`response`?e.variants.flatMap(({id:e,body:t})=>t?[{id:e,text:t}]:[]):[e.schema]),S=A(e).createPath.libApi(v(m),`types.ts`),C={id:[`ParamsT`,n(p)].join(``),schema:w,resolvedType:void 0},O=M(re,{params:C,paramsSchema:w.map((e,t)=>({...e,isRequired:e.kind===`required`,isSplat:e.kind===`splat`,refinement:r?.at(t)})),typeDeclarations:t,validationTypes:x}),k=l?u(O,{stripComments:!0,overrides:{[a]:a},withProperties:[C.id,...x.map(({id:e})=>e)]}):void 0;if(await N(S,k?P:O,{resolvedTypes:k}),C.resolvedType=k?.find(e=>e.name===C.id),D={hash:0,referencedFiles:{},params:C,methods:h,typeDeclarations:t,validationDefinitions:_.map(e=>({...e,...e.target===`response`?{variants:e.variants.map(e=>({...e,resolvedType:k?.find(t=>t.name===e.id)}))}:{schema:{...e.schema,resolvedType:k?.find(t=>t.name===e.schema.id)}}}))},E){let{referencedFiles:e,...t}=D;D=await E.set({...t,referencedFiles:y})}}let k=D.validationDefinitions.flatMap(e=>{let n=e;if(e.target===`response`)n={...e,variants:e.variants.flatMap((n,r)=>{if(typeof n.contentType!=`string`||n.contentType.includes(`/`))return[n];let i=O(n.contentType);return i?[{...n,contentType:i}]:(console.warn(t([`bold`,`red`],`✗ Failed resolving Response Content Type`)),console.warn(`  Invalid value provided for mime-types lookup - ${n.contentType}`),console.warn(t([`cyan`],`  Response variant #${r} excluded from route schemas`)),console.warn(`  Route: ${p}; Method: ${e.method}`),console.warn(),[])})};else if(e.contentType&&!e.contentType.includes(`/`)){let r=O(e.contentType);r?n={...e,contentType:r}:(console.warn(t([`bold`,`red`],`✗ Failed resolving Response Content Type`)),console.warn(`  Invalid value provided for mime-types lookup - ${e.contentType}`),console.warn(`  Route: ${p}; Method: ${e.method}`),console.warn())}return n?[n]:[]});return{kind:`apiRoute`,entry:{id:o,name:p,pathTokens:_,pathPattern:y,honoPattern:x,h3Pattern:C,params:D.params,optionalParams:T,folder:h,file:m,fileFullpath:g,methods:D.methods,typeDeclarations:D.typeDeclarations,validationDefinitions:k,referencedFiles:Object.keys(D.referencedFiles).map(t=>S(e.root,t))}}}}}}},ye=e=>{let t=structuredClone(e).sort($),n=(e,i)=>[...new Set(e.map(e=>e.name))].flatMap(e=>{let a=t.flatMap(({fileFullpath:t,...n})=>n.name===e?[n]:[]),o=a.find(e=>_(e.file).startsWith(G)),s=a.find(e=>_(e.file).startsWith(q));return o||s?[{index:o?{...o,pathTokens:o.pathTokens.slice(i?.pathTokens.length||0)}:void 0,layout:s?{...s,pathTokens:s.pathTokens.slice(i?.pathTokens.length||0)}:void 0,parent:i?.name,children:n(r(o||s),o||s)}]:[]}),r=({name:e,pathTokens:n})=>{let r=t.filter(t=>!(t.pathTokens.length<=n.length||!t.name.startsWith(`${e}/`)));return r.filter(e=>!r.some(t=>t===e||t.pathTokens.length<=n.length||t.pathTokens.length>=e.pathTokens.length?!1:e.name.startsWith(`${t.name}/`)))};return n(t.filter(e=>!t.some(t=>t===e||t.pathTokens.length>=e.pathTokens.length?!1:e.name.startsWith(`${t.name}/`))))},be=async(e,t)=>{let{apiRouteResolver:n,apiUseResolver:r,pageRouteResolver:i,pageLayoutResolver:a}=ve(e,t),o=t=>{let o=new Map,s=t.flatMap(t=>{let n=ge(t,e);return n?[n]:[]});for(let e of s)e.folder===c.apiDir?fe(e.file)?o.set(e.fileFullpath,n(e)):pe(e.file)&&o.set(e.fileFullpath,r(e)):e.folder===c.pagesDir&&(me(e.file)?o.set(e.fileFullpath,i(e)):he(e.file)&&o.set(e.fileFullpath,a(e)));return o};return{resolvers:o(await X(e)),resolversFactory:o}},xe=e=>{if(!process.stdout.isTTY||process.env.CI||process.env.TERM===`dumb`)return{text(){},append(){},succeed(){},failed(){}};let t=new k().start(e),n=e;return{text(e){n=e,t.text=e},append(e){t.text=`${n} › ${e}`},succeed(e){e?this.append(e):this.text(n),t.succeed()},failed(e){e&&this.text([n,e].join(`
-`)),t.failed()}}},Se=e=>{let t=[`.ts`,`.tsx`,`.js`,`.jsx`,`.mjs`,`.vue`,`.svelte`,`.md`,`.mdx`,`.json`],{createPath:n}=A(e),r=[[`${c.srcPrefix}/`,n.src()],[`${c.libPrefix}/`,n.lib()],[`${c.appPrefix}/`,e.root]],i=async(e,n)=>{let r=b(e,n),{ext:i}=x(n);if(t.includes(i)){for(let e of[r,`${r}/index${i}`])if(await Ee(e))return e;return r}for(let e of t)for(let t of[`${r}${e}`,`${r}/index${e}`])if(await Ee(t))return t;return r};return{name:`kosmo:tsconfigPaths`,enforce:`pre`,async resolveId(e){if(!(y(e)||e.startsWith(`.`))){for(let[t,n]of r)if(e.startsWith(t))return i(n,e.replace(t,``))}}}},Ce=()=>({name:`kosmojs:node-prefix`,enforce:`pre`,resolveId(t){return e.includes(t)?{id:`node:${t}`,external:!0}:void 0}}),we=(e,{kind:t,command:n})=>{let r=new Map;for(let{specifier:t,csr:n,ssr:i}of e)r.set(t,{csr:n,ssr:i});{let e=`export const command = "${n}";`;r.set(`virtual:kosmo/env`,{csr:e,ssr:e})}return{name:`kosmo:virtualModules`,enforce:`pre`,resolveId(e){return r.has(e)?`\0`+e:void 0},load(e){return e.startsWith(`\0`)?r.get(e.slice(1))?.[t]:void 0}}},Te={tsconfigPaths:Se,nodePrefix:Ce,virtualModules:we},Ee=async e=>h(e).then(e=>e.isFile()).catch(()=>!1);export{H as API_INDEX_BASENAME,U as API_INDEX_PATTERN,de as API_USE_BASENAME,W as API_USE_PATTERN,G as PAGE_INDEX_BASENAME,K as PAGE_INDEX_PATTERN,q as PAGE_LAYOUT_BASENAME,J as PAGE_LAYOUT_PATTERN,F as astFactory,ue as collectVirtualModules,V as createH3Pattern,B as createHonoPattern,z as createPathPattern,ge as createRouteEntry,ce as createWatchedApiRouteEntriesFilter,le as createWatchedPageRouteEntriesFilter,oe as defineGenerator,se as defineGeneratorFactory,te as escapeTemplateLiterals,fe as isApiRoute,pe as isApiUse,he as isPageLayout,me as isPageRoute,Z as isRouteFile,ee as mergeConfigs,ye as nestedRoutesFactory,j as pathExists,A as pathResolver,R as pathTokensFactory,M as render,ne as renderFactory,N as renderToFile,be as routesFactory,X as scanRoutes,$ as sortRoutes,_e as sortRoutesForResolution,xe as spinnerFactory,Se as tsconfigPaths,we as virtualModules,Te as vitePlugins};
 //# sourceMappingURL=index.js.map