@kosmojs/dev 0.1.0 → 0.1.1

package/pkg/chassis.js

@@ -1,540 +1,1859 @@
-// src/chassis.ts
+import { n as defaults$3 } from "./assets/pkg-BO-iPG8y.js";
+import "node:module";
+import { dirname, join, resolve } from "node:path";
+import crc from "crc/crc32";
+import { flattener } from "tfusion";
+import { Project, SyntaxKind } from "ts-morph";
+import { access, constants, mkdir, readFile, writeFile } from "node:fs/promises";
+import handlebars from "handlebars";
+import { parse } from "path-to-regexp";
+import mimeTypes from "mime-types";
+import { Spinner } from "@topcli/spinner";
+import picomatch from "picomatch";
+import { build, createServer } from "vite";
+import { styleText } from "node:util";
 import http from "node:http";
 import net from "node:net";
-import { join, resolve as resolve2 } from "node:path";
-import { styleText } from "node:util";
-import { build, createServer } from "vite";
-import {
-  defaults
-} from "@kosmojs/core";
-import { pathResolver as pathResolver2, routesFactory, spinnerFactory } from "@kosmojs/lib";
-import coreGenerator from "@kosmojs/core-generator";
-
-// src/cache.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import crc from "crc/crc32";
-import self from "@kosmojs/dev/package.json" with { type: "json" };
-import { pathExists, pathResolver } from "@kosmojs/lib";
+import { glob } from "tinyglobby";
+//#region ../lib/pkg/index.js
+var defaults$2 = {
+	appPrefix: "@",
+	srcPrefix: "~",
+	libPrefix: "_",
+	coreDir: "core",
+	srcDir: "src",
+	libDir: "lib",
+	configDir: "config",
+	apiDir: "api",
+	pagesDir: "pages",
+	entryDir: "entry",
+	fetchDir: "fetch",
+	refineTypeName: "VRefine"
+};
+/**
+* Request metadata validation targets.
+* */
+var RequestMetadataTargets$2 = {
+	query: "URL query parameters",
+	headers: "HTTP request headers",
+	cookies: "HTTP cookies"
+};
+/**
+* Request body validation targets.
+*
+* Body formats are mutually exclusive - only one should be specified per handler.
+*
+* **Development behavior:**
+* - If multiple formats are defined, the builder displays a warning and
+*   disables validation schemas for the affected handler.
+* - If an unsuitable target is defined (e.g., `json`, `form`)
+*   for a method without a body like GET, HEAD), a warning is displayed and
+*   validation schemas are disabled for that handler.
+*
+* This ensures misconfigurations are detected during development
+* for runtime to execute without false positive validation failures.
+*
+* Always define exactly one target that is suitable for current handler.
+* */
+var RequestBodyTargets$2 = {
+	json: "JSON request body",
+	form: "URL-encoded or Multipart form",
+	raw: "Raw body format (string/Buffer/ArrayBuffer/Blob)"
+};
+var RequestValidationTargets = {
+	...RequestMetadataTargets$2,
+	...RequestBodyTargets$2
+};
+var HTTPMethods = /* @__PURE__ */ function(HTTPMethods) {
+	HTTPMethods["HEAD"] = "HEAD";
+	HTTPMethods["OPTIONS"] = "OPTIONS";
+	HTTPMethods["GET"] = "GET";
+	HTTPMethods["PUT"] = "PUT";
+	HTTPMethods["PATCH"] = "PATCH";
+	HTTPMethods["POST"] = "POST";
+	HTTPMethods["DELETE"] = "DELETE";
+	return HTTPMethods;
+}({});
+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 nameNode = member.getNameNode();
+				const valueNode = member.getTypeNodeOrThrow();
+				const name = nameNode.isKind(SyntaxKind.StringLiteral) ? nameNode.getLiteralText() : nameNode.getText();
+				if (name === "contentType") contentType = extractStringLiteral(valueNode);
+				else if (name === "runtimeValidation") runtimeValidation = parseRuntimeValidation(valueNode);
+				else if (name.startsWith("error")) {
+					const literal = extractStringLiteral(valueNode);
+					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 = ({ root, name }) => {
+		const project = createProject({
+			tsConfigFilePath: resolve(root, join(defaults$2.srcDir, name, "tsconfig.json")),
+			skipAddingFilesFromTsConfig: true
+		});
+		const literalTypesResolver = (literalTypes, options) => {
+			const sourceFile = project.createSourceFile(`${crc(literalTypes)}-${Date.now()}.ts`, literalTypes, { overwrite: true });
+			const resolvedTypes = flattener(project, sourceFile, {
+				...options,
+				stripComments: true
+			});
+			project.removeSourceFile(sourceFile);
+			return 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
+	};
+};
+var pathResolver$1 = (sourceFolder) => {
+	const createPath = (...a) => {
+		return sourceFolder.root ? resolve(sourceFolder.root, join(...a)) : join(...a);
+	};
+	const createImport = {
+		src(a, { origin }) {
+			return origin === "src" ? join(defaults$2.srcPrefix, ...a) : join(defaults$2.appPrefix, defaults$2.srcDir, sourceFolder.name, ...a);
+		},
+		api(a, o) {
+			return this.src([defaults$2.apiDir, ...a], o);
+		},
+		pages(a, o) {
+			return this.src([defaults$2.pagesDir, ...a], o);
+		},
+		lib(a, { origin }) {
+			return origin === "src" ? join(defaults$2.libPrefix, ...a) : join(defaults$2.appPrefix, defaults$2.libDir, sourceFolder.name, ...a);
+		},
+		libCore(a, o) {
+			return this.lib(["core", ...a], o);
+		},
+		libApi(a, o) {
+			return this.lib([defaults$2.apiDir, ...a], o);
+		},
+		libEntry(a, o) {
+			return this.lib([defaults$2.entryDir, ...a], o);
+		}
+	};
+	return {
+		createPath: {
+			src(...a) {
+				return createPath(defaults$2.srcDir, sourceFolder.name, ...a);
+			},
+			api(...a) {
+				return this.src(defaults$2.apiDir, ...a);
+			},
+			pages(...a) {
+				return this.src(defaults$2.pagesDir, ...a);
+			},
+			entry(...a) {
+				return this.src(defaults$2.entryDir, ...a);
+			},
+			lib(...a) {
+				return createPath(defaults$2.libDir, sourceFolder.name, ...a);
+			},
+			libCore(...a) {
+				return this.lib("core", ...a);
+			},
+			libApi(...a) {
+				return this.lib(defaults$2.apiDir, ...a);
+			},
+			libEntry(...a) {
+				return this.lib(defaults$2.entryDir, ...a);
+			},
+			libPages(...a) {
+				return this.lib(defaults$2.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$1 = async (path) => {
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var render$1 = (template, context, options) => {
+	const { noEscape = true, renderer = handlebars } = { ...options };
+	return renderer.compile(template, { noEscape })(context);
+};
+var renderToFile$1 = async (file, template, context, options) => {
+	const content = render$1(template, context, options);
+	/**
+	* Two fs calls (exists + read) are worth it to avoid touching the file
+	* and triggering watchers unnecessarily.
+	* */
+	if (await pathExists$1(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");
+};
+/**
+* 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.
+*
+* 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, { transformStaticValue = normalizeStaticValue } = {}) => {
+	/**
+	* 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: transformStaticValue(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));
+				break;
+		}
+		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] || ":";
+	};
+	return 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(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
+		}];
+	});
+};
+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 staticValue = ({ value }) => {
+		return normalizeStaticValue(value);
+	};
+	const paramValue = (p) => {
+		if (p.kind === "splat") return `*`;
+		if (p.kind === "optional") return `:${p.name}?`;
+		return `:${p.name}`;
+	};
+	const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const tokensToRegex = (tokens) => {
+		return tokens.flatMap((t) => {
+			if (t.type === "text") return t.value === "/" ? [] : [escapeRegex(t.value)];
+			if (t.type === "wildcard") return [".+"];
+			if (t.type === "param") return ["[^/]+"];
+			if (t.type === "group") return [`(?:${tokensToRegex(t.tokens)})?`];
+			return [];
+		}).join("");
+	};
+	return tokens.flatMap((token, i) => {
+		if (token.kind === "static") return [staticValue(token.parts[0])];
+		if (token.kind === "param") return [paramValue(token.parts[0])];
+		const { tokens } = parse(token.pattern.replace(/\//g, ""));
+		return [`:_${i}{${tokensToRegex(tokens)}}`];
+	}).join("/");
+};
+var normalizeStaticValue = (value) => {
+	return value.replace(/\+/g, "\\\\+");
+};
+var API_INDEX_PATTERN = `index.ts`;
+var API_USE_PATTERN = `use.ts`;
+var PAGE_INDEX_PATTERN = `index.{tsx,vue,mdx,md}`;
+var PAGE_LAYOUT_PATTERN = `layout.{tsx,vue,mdx}`;
+var ROUTE_FILE_PATTERNS = [
+	`${defaults$2.apiDir}/**/${API_INDEX_PATTERN}`,
+	`${defaults$2.apiDir}/**/${API_USE_PATTERN}`,
+	`${defaults$2.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
+	`${defaults$2.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
+];
+var scanRoutes = async (sourceFolder) => {
+	const { createPath } = pathResolver$1(sourceFolder);
+	return glob(ROUTE_FILE_PATTERNS, {
+		cwd: createPath.src(),
+		absolute: true,
+		onlyFiles: true,
+		followSymbolicLinks: false,
+		ignore: [
+			`${defaults$2.apiDir}/${API_INDEX_PATTERN}`,
+			`${defaults$2.apiDir}/${API_USE_PATTERN}`,
+			`${defaults$2.pagesDir}/${PAGE_INDEX_PATTERN}`,
+			`${defaults$2.pagesDir}/${PAGE_LAYOUT_PATTERN}`
+		]
+	});
+};
+var isRouteFile = (file, sourceFolder) => {
+	const [_sourceFolder, _folder, ...rest] = resolve(sourceFolder.root, file).replace(`${sourceFolder.root}/${defaults$2.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)
+		};
+	} catch (error) {
+		console.error(`❗${styleText("red", "ERROR")}: Failed parsing path for "${styleText("cyan", file)}"`);
+		console.error(error);
+		return;
+	}
+};
+var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
+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";
+var resolverFactory = (sourceFolder, cacheFactory) => {
+	const { generators = [], refineTypeName = defaults$2.refineTypeName } = sourceFolder.config;
+	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 } = entry;
+			const handler = async () => {
+				return {
+					kind: "pageRoute",
+					entry: {
+						id,
+						name,
+						pathTokens,
+						pathPattern,
+						honoPattern,
+						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 } = 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(sourceFolder.name, defaults$2.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 numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
+						if (text === "number") {
+							const param = paramsSchema.at(index);
+							return param ? [param.name] : [];
+						}
+						return [];
+					}) : [];
+					const typesFile = pathResolver$1(sourceFolder).createPath.libApi(dirname(file), "types.ts");
+					const params = {
+						id: ["ParamsT", crc(name)].join(""),
+						schema: paramsSchema,
+						resolvedType: void 0
+					};
+					const typesFileContent = render$1(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.flatMap(({ 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$1(typesFile, resolvedTypes ? resolved_types_default : typesFileContent, { resolvedTypes });
+					params.resolvedType = resolvedTypes?.find((e) => e.name === params.id);
+					cache = {
+						hash: 0,
+						referencedFiles: {},
+						params,
+						methods,
+						typeDeclarations,
+						numericParams,
+						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 = mimeTypes.lookup(variant.contentType);
+							if (contentType === false) {
+								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 = mimeTypes.lookup(def.contentType);
+						if (contentType === false) {
+							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,
+						params: cache.params,
+						numericParams: cache.numericParams,
+						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
+			};
+		}
+	};
+};
+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$2.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$2.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
+	};
+};
+var spinnerFactory = (startText) => {
+	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 ../../generators/core-generator/pkg/index.js
+var routeRenderHelpers = () => {
+	return {
+		pageLinkBase({ name, pathPattern, params }) {
+			return JSON.stringify({
+				name,
+				pathPattern,
+				params
+			});
+		},
+		serializeParamsTupleElements: (route) => {
+			return route.params.schema.map((p, i) => {
+				if (p.kind === "splat") {
+					const suffix = route.params.schema[i + 1] ? "" : "?";
+					return `${p.const + suffix}: Array<string | number>`;
+				}
+				return p.kind === "optional" ? `${p.const}?: string | number` : `${p.const}: string | number`;
+			}).join(", ");
+		},
+		serializeParamsLiteral(route) {
+			return `{ ${route.params.schema.map((e) => {
+				return [[e.name, e.kind === "required" ? "" : "?"].join(""), e.kind === "splat" ? "Array<string>" : "string"].join(": ");
+			}).join("; ")} }`;
+		}
+	};
+};
+var defaults$1 = {
+	appPrefix: "@",
+	srcPrefix: "~",
+	libPrefix: "_",
+	coreDir: "core",
+	srcDir: "src",
+	libDir: "lib",
+	configDir: "config",
+	apiDir: "api",
+	pagesDir: "pages",
+	entryDir: "entry",
+	fetchDir: "fetch",
+	refineTypeName: "VRefine"
+};
+/**
+* Request metadata validation targets.
+* */
+var RequestMetadataTargets$1 = {
+	query: "URL query parameters",
+	headers: "HTTP request headers",
+	cookies: "HTTP cookies"
+};
+/**
+* Request body validation targets.
+*
+* Body formats are mutually exclusive - only one should be specified per handler.
+*
+* **Development behavior:**
+* - If multiple formats are defined, the builder displays a warning and
+*   disables validation schemas for the affected handler.
+* - If an unsuitable target is defined (e.g., `json`, `form`)
+*   for a method without a body like GET, HEAD), a warning is displayed and
+*   validation schemas are disabled for that handler.
+*
+* This ensures misconfigurations are detected during development
+* for runtime to execute without false positive validation failures.
+*
+* Always define exactly one target that is suitable for current handler.
+* */
+var RequestBodyTargets$1 = {
+	json: "JSON request body",
+	form: "URL-encoded or Multipart form",
+	raw: "Raw body format (string/Buffer/ArrayBuffer/Blob)"
+};
+({
+	...RequestMetadataTargets$1,
+	...RequestBodyTargets$1
+});
+var defineGenerator = (f) => f;
+var defineGeneratorFactory = (f) => f;
+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$1.srcPrefix, ...a) : join(defaults$1.appPrefix, defaults$1.srcDir, sourceFolder.name, ...a);
+		},
+		api(a, o) {
+			return this.src([defaults$1.apiDir, ...a], o);
+		},
+		pages(a, o) {
+			return this.src([defaults$1.pagesDir, ...a], o);
+		},
+		lib(a, { origin }) {
+			return origin === "src" ? join(defaults$1.libPrefix, ...a) : join(defaults$1.appPrefix, defaults$1.libDir, sourceFolder.name, ...a);
+		},
+		libCore(a, o) {
+			return this.lib(["core", ...a], o);
+		},
+		libApi(a, o) {
+			return this.lib([defaults$1.apiDir, ...a], o);
+		},
+		libEntry(a, o) {
+			return this.lib([defaults$1.entryDir, ...a], o);
+		}
+	};
+	return {
+		createPath: {
+			src(...a) {
+				return createPath(defaults$1.srcDir, sourceFolder.name, ...a);
+			},
+			api(...a) {
+				return this.src(defaults$1.apiDir, ...a);
+			},
+			pages(...a) {
+				return this.src(defaults$1.pagesDir, ...a);
+			},
+			entry(...a) {
+				return this.src(defaults$1.entryDir, ...a);
+			},
+			lib(...a) {
+				return createPath(defaults$1.libDir, sourceFolder.name, ...a);
+			},
+			libCore(...a) {
+				return this.lib("core", ...a);
+			},
+			libApi(...a) {
+				return this.lib(defaults$1.apiDir, ...a);
+			},
+			libEntry(...a) {
+				return this.lib(defaults$1.entryDir, ...a);
+			},
+			libPages(...a) {
+				return this.lib(defaults$1.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) => {
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+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 = 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)
+			});
+		}
+	};
+};
+`${defaults$1.apiDir}`, `${defaults$1.apiDir}`, `${defaults$1.pagesDir}`, `${defaults$1.pagesDir}`;
+var package_default$1 = {
+	type: "module",
+	"private": true,
+	name: "@kosmojs/core-generator",
+	version: "0.1.0",
+	author: "Slee Woo",
+	license: "MIT",
+	files: ["pkg/*"],
+	imports: { "#templates/*": "./src/templates/*" },
+	exports: { ".": {
+		"types": "./pkg/index.d.ts",
+		"default": "./pkg/index.js"
+	} },
+	scripts: { "build": "wsbuild src/index.ts" },
+	devDependencies: {
+		"@kosmojs/core": "workspace:^",
+		"@kosmojs/lib": "workspace:^",
+		"path-to-regexp": "^8.4.2"
+	}
+};
+var config_default = "export const base = \"{{config.base}}\";\nexport const apiBase = \"{{config.apiBase}}\";\n";
+var core_default = "export * from \"./config\";\nexport * from \"./routeMap\";\n";
+var pathMapper_default = "import { compile } from \"path-to-regexp\";\n\nimport type { PathMapperSignature } from \"@kosmojs/core\";\nimport { createHost, join, stringify } from \"@kosmojs/core/fetch\";\n\nexport const pathMapper = <ParamsT extends readonly unknown[]>(\n  basePath: string,\n  routeName: string,\n  pathPattern: string,\n  paramsMap: Array<[name: string, kind: string]>,\n  numericParams: Array<string>,\n): PathMapperSignature<ParamsT> => {\n  const toPath = compile(pathPattern);\n\n  const castParam = (name: string, value: unknown) => {\n    if (numericParams.includes(name)) {\n      const n = Number(value);\n      return Number.isFinite(n) ? n : String(value);\n    }\n    return String(value);\n  };\n\n  const paramsMapper: PathMapperSignature<ParamsT>[\"paramsMapper\"] = (\n    params,\n  ) => {\n    return paramsMap.reduce<Record<string, unknown>>((map, [name, kind], i) => {\n      if (kind === \"splat\") {\n        if (Array.isArray(params[i]) && params[i].length) {\n          map[name] = params[i].map((v) => castParam(name, v));\n        }\n      } else if (params[i] !== undefined) {\n        map[name] = castParam(name, params[i]);\n      }\n      return map;\n    }, {});\n  };\n\n  const parametrize: PathMapperSignature<ParamsT>[\"parametrize\"] = (params) => {\n    try {\n      return toPath(paramsMapper(params) as never);\n    } catch (error) {\n      console.error(`❗ERROR: Failed building path for ${routeName}`);\n      throw error;\n    }\n  };\n\n  const base: PathMapperSignature<ParamsT>[\"base\"] = (params, query) => {\n    const path = join(\"/\", parametrize(params));\n    return query ? [path, stringify(query)].join(\"?\") : path;\n  };\n\n  const path: PathMapperSignature<ParamsT>[\"path\"] = (params, query) => {\n    return join(basePath, base(params, query));\n  };\n\n  const href: PathMapperSignature<ParamsT>[\"href\"] = (host, params, query) => {\n    return createHost(host) + path(params, query);\n  };\n\n  return {\n    paramsMapper,\n    parametrize,\n    base,\n    path,\n    href,\n  };\n};\n";
+var routeMap_default = "{{> pathMapper}}\n\nimport { base, apiBase } from \"./config\";\n\n{{#if pageRoutes.length}}\nexport type LinkProps =\n  {{#each pageRoutes}}\n  | [ \"{{name}}\", {{serializeParamsTupleElements .}} ]\n  {{/each}};\n{{else}}\nexport type LinkProps = never;\n{{/if}}\n\nexport const apiRouteMap = {\n  {{#each apiRoutes}}\n  \"{{name}}\": pathMapper<[{{serializeParamsTupleElements .}}]>(\n    apiBase,\n    \"{{name}}\",\n    \"{{pathPattern}}\",\n    [{{#each params.schema}}[\"{{name}}\", \"{{kind}}\"], {{/each}}],\n    [{{#each numericParams}}\"{{.}}\", {{/each}}],\n  ),\n  {{/each}}\n};\n\nexport const pageRouteMap = {\n  {{#each pageRoutes}}\n  \"{{name}}\": pathMapper<[{{serializeParamsTupleElements .}}]>(\n    base,\n    \"{{name}}\",\n    \"{{pathPattern}}\",\n    [{{#each params.schema}}[\"{{name}}\", \"{{kind}}\"], {{/each}}],\n    [{{#each numericParams}}\"{{.}}\", {{/each}}],\n  ),\n  {{/each}}\n};\n";
+var env_d_default = "declare const KOSMO_PRODUCTION_BUILD: boolean;\n\n/**\n * Enhances base TypeScript types with JSON Schema validation constraints.\n * Allows declaring refined types that carry validation metadata for runtime\n * schema validation while maintaining full TypeScript type safety.\n *\n * Useful for generating validation schemas and ensuring\n * data conforms to specific business rules beyond basic type checking.\n * */\ndeclare type VRefine<\n  T extends unknown[] | number | string | object,\n  _ extends T extends unknown[]\n    ? TArrayOptions\n    : T extends number\n      ? TNumberOptions\n      : T extends string\n        ? TStringOptions\n        : TObjectOptions,\n> = T;\n\n/**\n * Type definitions inspired by and gently adapted from TypeBox.\n * Original TypeBox created by sinclairzx81: https://github.com/sinclairzx81/typebox\n * TypeBox is licensed under MIT: https://github.com/sinclairzx81/typebox/blob/main/license\n *\n * These types provide JSON Schema compatible type refinements for TypeScript.\n * */\ninterface TSchema {}\n\n// ------------------------------------------------------------------\n// ObjectOptions\n// ------------------------------------------------------------------\ninterface TObjectOptions {\n  /**\n   * Defines whether additional properties are allowed beyond those explicitly defined in `properties`.\n   */\n  additionalProperties?: TSchema | boolean;\n  /**\n   * The minimum number of properties required in the object.\n   */\n  minProperties?: number;\n  /**\n   * The maximum number of properties allowed in the object.\n   */\n  maxProperties?: number;\n  /**\n   * Defines conditional requirements for properties.\n   */\n  dependencies?: Record<string, boolean | TSchema | string[]>;\n  /**\n   * Specifies properties that *must* be present if a given property is present.\n   */\n  dependentRequired?: Record<string, string[]>;\n  /**\n   * Defines schemas that apply if a specific property is present.\n   */\n  dependentSchemas?: Record<string, TSchema>;\n  /**\n   * Maps regular expressions to schemas properties matching a pattern must validate against the schema.\n   */\n  patternProperties?: Record<string, TSchema>;\n  /**\n   * A schema that all property names within the object must validate against.\n   */\n  propertyNames?: TSchema;\n}\n\n// ------------------------------------------------------------------\n// ArrayOptions\n// ------------------------------------------------------------------\ninterface TArrayOptions {\n  /**\n   * The minimum number of items allowed in the array.\n   */\n  minItems?: number;\n  /**\n   * The maximum number of items allowed in the array.\n   */\n  maxItems?: number;\n  /**\n   * A schema that at least one item in the array must validate against.\n   */\n  contains?: TSchema;\n  /**\n   * The minimum number of array items that must validate against the `contains` schema.\n   */\n  minContains?: number;\n  /**\n   * The maximum number of array items that may validate against the `contains` schema.\n   */\n  maxContains?: number;\n  /**\n   * An array of schemas, where each schema in `prefixItems` validates against items at corresponding positions from the beginning of the array.\n   */\n  prefixItems?: TSchema[];\n  /**\n   * If `true`, all items in the array must be unique.\n   */\n  uniqueItems?: boolean;\n}\n\n// ------------------------------------------------------------------\n// NumberOptions\n// ------------------------------------------------------------------\ninterface TNumberOptions {\n  /**\n   * Specifies an exclusive upper limit for the number (number must be less than this value).\n   */\n  exclusiveMaximum?: number | bigint;\n  /**\n   * Specifies an exclusive lower limit for the number (number must be greater than this value).\n   */\n  exclusiveMinimum?: number | bigint;\n  /**\n   * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).\n   */\n  maximum?: number | bigint;\n  /**\n   * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).\n   */\n  minimum?: number | bigint;\n  /**\n   * Specifies that the number must be a multiple of this value.\n   */\n  multipleOf?: number | bigint;\n}\n\n// ------------------------------------------------------------------\n// StringOptions\n// ------------------------------------------------------------------\ntype TFormat =\n  | \"date-time\"\n  | \"date\"\n  | \"duration\"\n  | \"email\"\n  | \"hostname\"\n  | \"idn-email\"\n  | \"idn-hostname\"\n  | \"ipv4\"\n  | \"ipv6\"\n  | \"iri-reference\"\n  | \"iri\"\n  | \"json-pointer-uri-fragment\"\n  | \"json-pointer\"\n  | \"json-string\"\n  | \"regex\"\n  | \"relative-json-pointer\"\n  | \"time\"\n  | \"uri-reference\"\n  | \"uri-template\"\n  | \"url\"\n  | \"uuid\";\n\ninterface TStringOptions {\n  /**\n   * Specifies the expected string format.\n   *\n   * Common values include:\n   * - `base64` – Base64-encoded string.\n   * - `date-time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time format.\n   * - `date` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date (YYYY-MM-DD).\n   * - `duration` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) duration format.\n   * - `email` – RFC 5321/5322 compliant email address.\n   * - `hostname` – RFC 1034/1035 compliant host name.\n   * - `idn-email` – Internationalized email address.\n   * - `idn-hostname` – Internationalized host name.\n   * - `ipv4` – IPv4 address.\n   * - `ipv6` – IPv6 address.\n   * - `iri` / `iri-reference` – Internationalized Resource Identifier.\n   * - `json-pointer` / `json-pointer-uri-fragment` – JSON Pointer format.\n   * - `json-string` – String containing valid JSON.\n   * - `regex` – Regular expression syntax.\n   * - `relative-json-pointer` – Relative JSON Pointer format.\n   * - `time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time (HH:MM:SS).\n   * - `uri-reference` / `uri-template` – URI reference or template.\n   * - `url` – Web URL format.\n   * - `uuid` – RFC 4122 UUID string.\n   *\n   * May also be a custom format string.\n   */\n  format?: TFormat;\n  /**\n   * Specifies the minimum number of characters allowed in the string.\n   * Must be a non-negative integer.\n   */\n  minLength?: number;\n  /**\n   * Specifies the maximum number of characters allowed in the string.\n   * Must be a non-negative integer.\n   */\n  maxLength?: number;\n  /**\n   * Specifies a regular expression pattern that the string value must match.\n   * Can be provided as a string (ECMA-262 regex syntax) or a `RegExp` object.\n   */\n  pattern?: string | RegExp;\n}\n";
+var gitignore_default = "# Ignore all files\n*\n\n# But don't ignore directories (so Git can traverse them)\n!*/\n\n# And don't ignore these files at any depth\n!cache.json\n!types.ts\n";
+var schemas_default = "// stub schemas, specialized generators supposed to overwrite this file\nimport type { ValidationSchemas } from \"@kosmojs/core/api\";\nexport type { ValidationSchemas };\nexport const validationSchemas: ValidationSchemas = {};\n";
+var defaults = {
+	appPrefix: "@",
+	srcPrefix: "~",
+	libPrefix: "_",
+	coreDir: "core",
+	srcDir: "src",
+	libDir: "lib",
+	configDir: "config",
+	apiDir: "api",
+	pagesDir: "pages",
+	entryDir: "entry",
+	fetchDir: "fetch",
+	refineTypeName: "VRefine"
+};
+/**
+* Request metadata validation targets.
+* */
+var RequestMetadataTargets = {
+	query: "URL query parameters",
+	headers: "HTTP request headers",
+	cookies: "HTTP cookies"
+};
+/**
+* Request body validation targets.
+*
+* Body formats are mutually exclusive - only one should be specified per handler.
+*
+* **Development behavior:**
+* - If multiple formats are defined, the builder displays a warning and
+*   disables validation schemas for the affected handler.
+* - If an unsuitable target is defined (e.g., `json`, `form`)
+*   for a method without a body like GET, HEAD), a warning is displayed and
+*   validation schemas are disabled for that handler.
+*
+* This ensures misconfigurations are detected during development
+* for runtime to execute without false positive validation failures.
+*
+* Always define exactly one target that is suitable for current handler.
+* */
+var RequestBodyTargets = {
+	json: "JSON request body",
+	form: "URL-encoded or Multipart form",
+	raw: "Raw body format (string/Buffer/ArrayBuffer/Blob)"
+};
+({
+	...RequestMetadataTargets,
+	...RequestBodyTargets
+});
+var generateTsconfig = (sourceFolder) => {
+	const rootDir = "${configDir}";
+	const compilerOptions = {
+		types: ["@types/node", "vite/client"],
+		moduleResolution: "bundler",
+		module: "ESNext",
+		target: "ESNext",
+		strict: true,
+		exactOptionalPropertyTypes: true,
+		noImplicitAny: true,
+		noImplicitThis: true,
+		noImplicitOverride: true,
+		noImplicitReturns: true,
+		noUnusedLocals: false,
+		noUnusedParameters: false,
+		allowArbitraryExtensions: true,
+		allowImportingTsExtensions: true,
+		allowUnreachableCode: false,
+		allowUnusedLabels: false,
+		useUnknownInCatchVariables: true,
+		noFallthroughCasesInSwitch: true,
+		noUncheckedSideEffectImports: true,
+		resolveJsonModule: true,
+		esModuleInterop: true,
+		verbatimModuleSyntax: true,
+		skipLibCheck: true,
+		noEmit: true
+	};
+	if (sourceFolder) return {
+		include: [
+			`${rootDir}/`,
+			`${rootDir}/../../${defaults.libDir}/${sourceFolder}/`,
+			`${rootDir}/../../**/*.d.ts`
+		],
+		compilerOptions: {
+			...compilerOptions,
+			types: [...compilerOptions.types],
+			paths: {
+				[`${defaults.appPrefix}/*`]: [`${rootDir}/../../*`],
+				[`${defaults.srcPrefix}/*`]: [`${rootDir}/*`],
+				[`${defaults.libPrefix}/*`]: [`${rootDir}/../../${defaults.libDir}/${sourceFolder}/*`]
+			},
+			jsx: "preserve"
+		}
+	};
+	return {
+		include: [`${rootDir}/`],
+		exclude: [`${rootDir}/${defaults.srcDir}/`],
+		compilerOptions: {
+			...compilerOptions,
+			paths: { [`${defaults.appPrefix}/*`]: [`${rootDir}/*`] }
+		}
+	};
+};
+var factory = defineGeneratorFactory((meta, sourceFolder) => {
+	const { createPath, createImportHelpers } = pathResolver(sourceFolder);
+	const start = async () => {
+		await renderToFile(createPath.lib("../tsconfig.base.json"), JSON.stringify(generateTsconfig(), void 0, 2), {});
+		{
+			const tsconfig = generateTsconfig(sourceFolder.name);
+			const compilerOptions = {};
+			const types = new Set(tsconfig.compilerOptions.types || []);
+			for (const { meta } of sourceFolder.config.generators || []) {
+				if (meta.jsxImportSource) compilerOptions.jsxImportSource = meta.jsxImportSource;
+				for (const type of meta.types || []) types.add(type);
+			}
+			await renderToFile(createPath.lib("tsconfig.base.json"), JSON.stringify({
+				...tsconfig,
+				compilerOptions: {
+					...tsconfig.compilerOptions,
+					...compilerOptions,
+					types: [...types.values()]
+				}
+			}, void 0, 2), {});
+		}
+		/**
+		* expose VRefine as a global type.
+		* not supposed to be overriden by generators.
+		* */
+		await renderToFile(createPath.lib("../env.d.ts"), env_d_default, {});
+		/**
+		* deploy a default gitignore file that ignore everything,
+		* except cache.json files; if file exists, do not override.
+		* */
+		await renderToFile(createPath.lib("../.gitignore"), gitignore_default, {}, { overwrite: false });
+		/**
+		* deploy a stub SSG file.
+		* generators that support SSG will override it as needed.
+		* then SSG generator will import it and generate static files for exported routes.
+		* */
+		await renderToFile(createPath.lib("ssg.ts"), "export default [];", {});
+	};
+	const generateLibFiles = async (entries) => {
+		const { renderToFile } = renderFactory({
+			helpers: {
+				...createImportHelpers({ origin: "lib" }),
+				...routeRenderHelpers()
+			},
+			partials: { pathMapper: pathMapper_default }
+		});
+		await renderToFile(createPath.libCore("routeMap.ts"), routeMap_default, {
+			apiRoutes: entries.flatMap(({ kind, entry }) => {
+				return kind === "apiRoute" ? [entry] : [];
+			}),
+			pageRoutes: entries.flatMap(({ kind, entry }) => {
+				return kind === "pageRoute" ? [entry] : [];
+			})
+		});
+		for (const [file, template] of [["config.ts", config_default], ["index.ts", core_default]]) await renderToFile(createPath.libCore(file), template, sourceFolder);
+		for (const { kind, entry } of entries) if (kind === "apiRoute") await renderToFile(createPath.libApi(dirname(entry.file), "schemas.ts"), schemas_default, { route: entry }, { overwrite: false });
+	};
+	return {
+		meta,
+		options: void 0,
+		start,
+		watch: generateLibFiles,
+		build: generateLibFiles
+	};
+});
+/**
+* Generates stub files required by various generators.
+* Ensures cross-generator dependencies remain resolvable
+* even if specialized generators supposed to generate these files are not installed.
+* */
+var src_default = defineGenerator(() => {
+	const meta = {
+		name: "Core",
+		dependencies: { "path-to-regexp": package_default$1.devDependencies["path-to-regexp"] }
+	};
+	return {
+		meta,
+		options: void 0,
+		factory: (sourceFolder) => factory(meta, sourceFolder)
+	};
+});
+var package_default = {
+	type: "module",
+	name: "@kosmojs/dev",
+	version: "0.1.0",
+	cacheVersion: "001",
+	author: "Slee Woo",
+	license: "MIT",
+	files: ["pkg/*"],
+	exports: {
+		".": {
+			"types": "./pkg/index.d.ts",
+			"default": "./pkg/index.js"
+		},
+		"./chassis": {
+			"types": "./pkg/chassis.d.ts",
+			"default": "./pkg/chassis.js"
+		},
+		"./package.json": "./package.json"
+	},
+	scripts: { "build": "wsbuild src/index.ts src/chassis.ts" },
+	dependencies: { "crc": "^4.3.2" },
+	devDependencies: {
+		"@kosmojs/core": "workspace:^",
+		"@kosmojs/core-generator": "workspace:^",
+		"@kosmojs/fetch-generator": "workspace:^",
+		"@kosmojs/hono-generator": "workspace:^",
+		"@kosmojs/koa-generator": "workspace:^",
+		"@kosmojs/lib": "workspace:^",
+		"@kosmojs/mdx-generator": "workspace:^",
+		"@kosmojs/openapi-generator": "workspace:^",
+		"@kosmojs/react-generator": "workspace:^",
+		"@kosmojs/solid-generator": "workspace:^",
+		"@kosmojs/ssg-generator": "workspace:^",
+		"@kosmojs/ssr-generator": "workspace:^",
+		"@kosmojs/typebox-generator": "workspace:^",
+		"@kosmojs/vue-generator": "workspace:^"
+	}
+};
+//#endregion
+//#region src/cache.ts
+/**
+* Import from published package to ensure correct version at runtime.
+* Local import would be bundled with pre-bump version; this external
+* import resolves to the actual published package.json.
+* */
 var cacheFactory = (route, sourceFolder, extraContext) => {
-  const cacheFile = pathResolver(sourceFolder).createPath.libApi(
-    dirname(route.file),
-    "cache.json"
-  );
-  const validateCache = async (cache) => {
-    if (!cache?.hash) {
-      return;
-    }
-    if (!cache.typeDeclarations || !cache.referencedFiles) {
-      return;
-    }
-    const hash = await generateFileHash(route.fileFullpath, {
-      ...extraContext
-    });
-    if (!identicalHashSum(cache.hash, hash)) {
-      return;
-    }
-    for (const [file, hash2] of Object.entries(cache.referencedFiles)) {
-      if (!identicalHashSum(
-        hash2,
-        await generateFileHash(resolve(sourceFolder.root, file))
-      )) {
-        return;
-      }
-    }
-    return cache;
-  };
-  return {
-    async get(opt) {
-      if (await pathExists(cacheFile)) {
-        try {
-          const cache = JSON.parse(await readFile(cacheFile, "utf8"));
-          return opt?.validate ? validateCache(cache) : cache;
-        } catch (_e) {
-        }
-      }
-      return void 0;
-    },
-    async set(cache) {
-      const hash = await generateFileHash(route.fileFullpath, {
-        ...extraContext
-      });
-      const referencedFiles = {};
-      for (const file of cache.referencedFiles) {
-        referencedFiles[
-          // Strip project root to ensure cached paths are relative
-          // and portable across environments (CI, local, etc.)
-          file.replace(`${sourceFolder.root}/`, "")
-        ] = await generateFileHash(file);
-      }
-      const value = { ...cache, hash, referencedFiles };
-      await mkdir(dirname(cacheFile), { recursive: true });
-      await writeFile(cacheFile, JSON.stringify(value, null, 2), "utf8");
-      return value;
-    }
-  };
+	const cacheFile = pathResolver$1(sourceFolder).createPath.libApi(dirname(route.file), "cache.json");
+	const validateCache = async (cache) => {
+		if (!cache?.hash) return;
+		if (!cache.typeDeclarations || !cache.referencedFiles) return;
+		const hash = await generateFileHash(route.fileFullpath, { ...extraContext });
+		if (!identicalHashSum(cache.hash, hash)) return;
+		for (const [file, hash] of Object.entries(cache.referencedFiles)) if (!identicalHashSum(hash, await generateFileHash(resolve(sourceFolder.root, file)))) return;
+		return cache;
+	};
+	return {
+		async get(opt) {
+			if (await pathExists$1(cacheFile)) try {
+				const cache = JSON.parse(await readFile(cacheFile, "utf8"));
+				return opt?.validate ? validateCache(cache) : cache;
+			} catch (_e) {}
+		},
+		async set(cache) {
+			const hash = await generateFileHash(route.fileFullpath, { ...extraContext });
+			const referencedFiles = {};
+			for (const file of cache.referencedFiles) referencedFiles[file.replace(`${sourceFolder.root}/`, "")] = await generateFileHash(file);
+			const value = {
+				...cache,
+				hash,
+				referencedFiles
+			};
+			await mkdir(dirname(cacheFile), { recursive: true });
+			await writeFile(cacheFile, JSON.stringify(value, null, 2), "utf8");
+			return value;
+		}
+	};
 };
 var generateFileHash = async (file, extraContext) => {
-  let fileContent;
-  try {
-    fileContent = await readFile(file, "utf8");
-  } catch (_e) {
-    return 0;
-  }
-  return fileContent ? crc(
-    JSON.stringify({
-      ...extraContext,
-      [self.cacheVersion]: fileContent
-    })
-  ) : 0;
+	let fileContent;
+	try {
+		fileContent = await readFile(file, "utf8");
+	} catch (_e) {
+		return 0;
+	}
+	return fileContent ? crc(JSON.stringify({
+		...extraContext,
+		[package_default.cacheVersion]: fileContent
+	})) : 0;
 };
 var identicalHashSum = (a, b) => {
-  return a === b;
+	return a === b;
 };
-
-// src/chassis.ts
+//#endregion
+//#region src/chassis.ts
 var chassis_default = async (projectSettings) => {
-  const { devPort, command } = projectSettings;
-  for (const sourceFolder of projectSettings.sourceFolders) {
-    for (const base of folderGenerators(sourceFolder)) {
-      if (!base.meta?.name || typeof base.factory !== "function") {
-        throw new Error(
-          `${sourceFolder.name}: Unrecognized generator - must be created via defineGenerator()`
-        );
-      }
-      const factory = base.factory(sourceFolder);
-      if (!factory.meta?.name) {
-        throw new Error(
-          `${sourceFolder.name}: ${base.meta.name} generator is missing meta property`
-        );
-      }
-      try {
-        await factory.start?.();
-      } catch (error) {
-        console.error(
-          styleText(
-            "red",
-            `${sourceFolder.name}: ${base.meta.name} generator failed to initialize`
-          )
-        );
-        throw error;
-      }
-    }
-  }
-  if (command === "build") {
-    for (const sourceFolder of projectSettings.sourceFolders) {
-      const { config, baseurl } = sourceFolder;
-      const { createPath } = pathResolver2(sourceFolder);
-      const resolvedRoutes = [];
-      {
-        const { resolvers } = await routesFactory(sourceFolder, cacheFactory);
-        const spinner = spinnerFactory(
-          `${sourceFolder.name}: resolving routes`
-        );
-        for (const { name, handler } of resolvers.values()) {
-          spinner.append(
-            `[ ${resolvedRoutes.length + 1} of ${resolvers.size} ] ${name}`
-          );
-          resolvedRoutes.push(await handler());
-        }
-        spinner.succeed("ready \u2728");
-      }
-      const generators = folderGenerators(sourceFolder);
-      const plugins = [...config.plugins || []];
-      for (const base of generators) {
-        await base.factory(sourceFolder).build?.(resolvedRoutes);
-        plugins.push(...base.plugins?.(sourceFolder, command) || []);
-      }
-      {
-        const outDir = createPath.distDir("client");
-        await build({
-          ...config,
-          configFile: false,
-          root: createPath.src(),
-          base: join(baseurl, "/"),
-          plugins,
-          resolve: {
-            ...config.resolve,
-            tsconfigPaths: true
-          },
-          build: {
-            ...config?.build,
-            outDir,
-            manifest: true,
-            emptyOutDir: true
-          },
-          cacheDir: cacheDir(sourceFolder, command, "client")
-        });
-      }
-      const apiGenerator = generators.find((e) => e.meta.slot === "api");
-      if (apiGenerator) {
-        const dir = createPath.distDir("api");
-        const noExternal = Array.isArray(apiGenerator.options?.noExternal) ? apiGenerator.options.noExternal : generators.flatMap(({ meta }) => {
-          return Object.keys({
-            ...meta.dependencies,
-            ...meta.devDependencies
-          });
-        });
-        await build({
-          configFile: false,
-          root: createPath.src(),
-          appType: "custom",
-          plugins: [...apiGenerator.plugins?.(sourceFolder, command) || []],
-          define: {
-            ...config.define,
-            KOSMO_PRODUCTION_BUILD: "true"
-          },
-          ssr: { noExternal },
-          resolve: {
-            ...config.resolve,
-            tsconfigPaths: true,
-            conditions: ["node"]
-          },
-          build: {
-            ssr: true,
-            target: "esnext",
-            sourcemap: true,
-            emptyOutDir: true,
-            rolldownOptions: {
-              input: [createPath.api("app.ts"), createPath.api("server.ts")],
-              output: {
-                dir,
-                format: "esm"
-              }
-            }
-          },
-          cacheDir: cacheDir(sourceFolder, command, "backend")
-        });
-      }
-      for (const base of generators) {
-        await base.factory(sourceFolder).postBuild?.(resolvedRoutes);
-      }
-    }
-    return async () => {
-    };
-  }
-  const requestHandlers = [];
-  const teardownHandlers = [];
-  const eventMap = {};
-  for (const sourceFolder of projectSettings.sourceFolders) {
-    eventMap[sourceFolder.name] = await eventFactory(sourceFolder);
-  }
-  let port = await findFreePort(devPort);
-  for (const sourceFolder of projectSettings.sourceFolders) {
-    const { config, baseurl } = sourceFolder;
-    const { createPath } = pathResolver2(sourceFolder);
-    const requestMatchers = matchersFactory(sourceFolder);
-    const generators = folderGenerators(sourceFolder);
-    const plugins = [...config.plugins || []];
-    for (const base of generators) {
-      plugins.push(...base.plugins?.(sourceFolder, command) || []);
-    }
-    const viteServer = await createServer({
-      ...config,
-      configFile: false,
-      root: createPath.src(),
-      base: join(baseurl, "/"),
-      plugins,
-      server: {
-        ...config.server,
-        port: port++,
-        middlewareMode: true,
-        hmr: { port: port++ }
-      },
-      resolve: {
-        ...config.resolve,
-        tsconfigPaths: true
-      },
-      define: {
-        ...config.define
-      },
-      cacheDir: cacheDir(sourceFolder, command, "client")
-    });
-    for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) {
-      viteServer.watcher.on(evt, handler);
-    }
-    requestHandlers.push([
-      [sourceFolder.baseurl],
-      () => requestMatchers.base,
-      () => viteServer.middlewares
-    ]);
-    teardownHandlers.push(viteServer.close);
-  }
-  for (const sourceFolder of projectSettings.sourceFolders) {
-    const { config } = sourceFolder;
-    if (!folderGenerators(sourceFolder).find((e) => e.meta.slot === "api")) {
-      continue;
-    }
-    const { createPath } = pathResolver2(sourceFolder);
-    const requestMatchers = matchersFactory(sourceFolder);
-    const viteServer = await createServer({
-      configFile: false,
-      root: createPath.src(),
-      appType: "custom",
-      server: {
-        port: port++,
-        middlewareMode: true,
-        hmr: { port: port++ }
-      },
-      resolve: { tsconfigPaths: true },
-      define: {
-        ...config?.define,
-        KOSMO_PRODUCTION_BUILD: "false"
-      },
-      environments: {
-        api: {
-          resolve: {
-            conditions: ["node"]
-          }
-        }
-      },
-      cacheDir: cacheDir(sourceFolder, command, "backend")
-    });
-    const env = viteServer.environments.api;
-    const loadDevSetup = async () => {
-      env.runner.clearCache();
-      return env.runner.import(join(defaults.apiDir, "dev.ts")).then((e) => e.default);
-    };
-    let devSetup = await loadDevSetup();
-    for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) {
-      viteServer.watcher.on(evt, async (file) => {
-        const mods = env.moduleGraph.getModulesByFile(file);
-        if (mods?.size) {
-          await handler(file);
-          await devSetup?.teardownHandler?.();
-          devSetup = await loadDevSetup();
-        }
-      });
-    }
-    requestHandlers.push([
-      [sourceFolder.baseurl, sourceFolder.apiurl],
-      () => devSetup.requestMatcher || requestMatchers.api,
-      () => devSetup.requestHandler()
-    ]);
-    teardownHandlers.push(viteServer.close);
-  }
-  const requestHandlerWeight = ([
-    segments
-  ]) => {
-    const [base, api] = segments;
-    const weight = base.split("/").filter(Boolean).length;
-    return api ? weight + 5 : weight;
-  };
-  const handlers = requestHandlers.sort(
-    (a, b) => requestHandlerWeight(b) - requestHandlerWeight(a)
-  );
-  const httpServer = http.createServer((req, res) => {
-    for (const [, matcherFactory, handlerFactory] of handlers) {
-      const [matcher, handler] = [matcherFactory(), handlerFactory()];
-      if (matcher(req)) {
-        handler(req, res);
-        return;
-      }
-    }
-    res.writeHead(404, { "Content-Type": "text/html" });
-    res.end("<h1>404: Not Found</h1>");
-  });
-  httpServer.on("error", (error) => {
-    console.error(
-      styleText("red", `Failed to start dev server on port ${devPort}`)
-    );
-    console.error(error.message);
-    process.exit(1);
-  });
-  httpServer.listen(devPort);
-  teardownHandlers.push(async () => {
-    httpServer.close();
-  });
-  return async () => {
-    for (const handler of teardownHandlers) {
-      await handler().catch(console.error);
-    }
-    await new Promise((resolve3) => setTimeout(resolve3, 100));
-  };
+	const { devPort, command } = projectSettings;
+	for (const sourceFolder of projectSettings.sourceFolders) for (const base of folderGenerators(sourceFolder)) {
+		if (!base.meta?.name || typeof base.factory !== "function") throw new Error(`${sourceFolder.name}: Unrecognized generator - must be created via defineGenerator()`);
+		const factory = base.factory(sourceFolder);
+		if (!factory.meta?.name) throw new Error(`${sourceFolder.name}: ${base.meta.name} generator is missing meta property`);
+		try {
+			await factory.start?.();
+		} catch (error) {
+			console.error(styleText("red", `${sourceFolder.name}: ${base.meta.name} generator failed to initialize`));
+			throw error;
+		}
+	}
+	if (command === "build") {
+		for (const sourceFolder of projectSettings.sourceFolders) {
+			const { config } = sourceFolder;
+			const { createPath } = pathResolver$1(sourceFolder);
+			const resolvedRoutes = [];
+			{
+				const { resolvers } = await routesFactory(sourceFolder, cacheFactory);
+				const spinner = spinnerFactory(`${sourceFolder.name}: resolving routes`);
+				for (const { name, handler } of resolvers.values()) {
+					spinner.append(`[ ${resolvedRoutes.length + 1} of ${resolvers.size} ] ${name}`);
+					resolvedRoutes.push(await handler());
+				}
+				spinner.succeed("ready ✨");
+			}
+			const generators = folderGenerators(sourceFolder);
+			const plugins = [...config.plugins || []];
+			for (const base of generators) {
+				await base.factory(sourceFolder).build?.(resolvedRoutes);
+				plugins.push(...base.plugins?.(sourceFolder, command) || []);
+			}
+			{
+				const outDir = createPath.distDir("client");
+				await build({
+					...config,
+					configFile: false,
+					root: createPath.src(),
+					base: join(config.base, "/"),
+					plugins,
+					resolve: {
+						...config.resolve,
+						tsconfigPaths: true
+					},
+					build: {
+						...config?.build,
+						outDir,
+						manifest: true,
+						emptyOutDir: true
+					},
+					cacheDir: cacheDir(sourceFolder, command, "client")
+				});
+			}
+			const apiGenerator = generators.find((e) => e.meta.slot === "api");
+			if (apiGenerator) {
+				const dir = createPath.distDir("api");
+				const noExternal = Array.isArray(apiGenerator.options?.noExternal) ? apiGenerator.options.noExternal : generators.flatMap(({ meta }) => {
+					return Object.keys({
+						...meta.dependencies,
+						...meta.devDependencies
+					});
+				});
+				await build({
+					configFile: false,
+					root: createPath.src(),
+					appType: "custom",
+					plugins: [...apiGenerator.plugins?.(sourceFolder, command) || []],
+					define: {
+						...config.define,
+						KOSMO_PRODUCTION_BUILD: "true"
+					},
+					ssr: { noExternal },
+					resolve: {
+						...config.resolve,
+						tsconfigPaths: true,
+						conditions: ["node"]
+					},
+					build: {
+						ssr: true,
+						target: "esnext",
+						sourcemap: true,
+						emptyOutDir: true,
+						rolldownOptions: {
+							input: [createPath.api("app.ts"), createPath.api("server.ts")],
+							output: {
+								dir,
+								format: "esm"
+							}
+						}
+					},
+					cacheDir: cacheDir(sourceFolder, command, "backend")
+				});
+			}
+			for (const base of generators) await base.factory(sourceFolder).postBuild?.(resolvedRoutes);
+		}
+		return async () => {};
+	}
+	const requestHandlers = [];
+	const teardownHandlers = [];
+	const eventMap = {};
+	for (const sourceFolder of projectSettings.sourceFolders) eventMap[sourceFolder.name] = await eventFactory(sourceFolder);
+	let port = await findFreePort(devPort);
+	for (const sourceFolder of projectSettings.sourceFolders) {
+		const { config } = sourceFolder;
+		const { createPath } = pathResolver$1(sourceFolder);
+		const requestMatchers = matchersFactory(sourceFolder);
+		const generators = folderGenerators(sourceFolder);
+		const plugins = [...config.plugins || []];
+		for (const base of generators) plugins.push(...base.plugins?.(sourceFolder, command) || []);
+		const viteServer = await createServer({
+			...config,
+			configFile: false,
+			root: createPath.src(),
+			base: join(config.base, "/"),
+			plugins,
+			server: {
+				...config.server,
+				port: port++,
+				middlewareMode: true,
+				hmr: { port: port++ }
+			},
+			resolve: {
+				...config.resolve,
+				tsconfigPaths: true
+			},
+			define: { ...config.define },
+			cacheDir: cacheDir(sourceFolder, command, "client")
+		});
+		for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) viteServer.watcher.on(evt, handler);
+		requestHandlers.push([
+			[sourceFolder.config.base],
+			() => requestMatchers.base,
+			() => viteServer.middlewares
+		]);
+		teardownHandlers.push(viteServer.close);
+	}
+	for (const sourceFolder of projectSettings.sourceFolders) {
+		const { config } = sourceFolder;
+		if (!folderGenerators(sourceFolder).find((e) => e.meta.slot === "api")) continue;
+		const { createPath } = pathResolver$1(sourceFolder);
+		const requestMatchers = matchersFactory(sourceFolder);
+		const viteServer = await createServer({
+			configFile: false,
+			root: createPath.src(),
+			appType: "custom",
+			server: {
+				port: port++,
+				middlewareMode: true,
+				hmr: { port: port++ }
+			},
+			resolve: { tsconfigPaths: true },
+			define: {
+				...config?.define,
+				KOSMO_PRODUCTION_BUILD: "false"
+			},
+			environments: { api: { resolve: { conditions: ["node"] } } },
+			cacheDir: cacheDir(sourceFolder, command, "backend")
+		});
+		const env = viteServer.environments.api;
+		const loadDevSetup = async () => {
+			env.runner.clearCache();
+			return env.runner.import(join(defaults$3.apiDir, "dev.ts")).then((e) => e.default);
+		};
+		let devSetup = await loadDevSetup();
+		for (const [evt, handler] of Object.entries(eventMap[sourceFolder.name])) viteServer.watcher.on(evt, async (file) => {
+			if (env.moduleGraph.getModulesByFile(file)?.size) {
+				await handler(file);
+				await devSetup?.teardownHandler?.();
+				devSetup = await loadDevSetup();
+			}
+		});
+		requestHandlers.push([
+			[sourceFolder.config.base, sourceFolder.config.apiBase],
+			() => devSetup.requestMatcher || requestMatchers.api,
+			() => devSetup.requestHandler()
+		]);
+		teardownHandlers.push(viteServer.close);
+	}
+	/**
+	* Sorting is essential to ensure more specific paths are matched before broader ones.
+	*
+	* Given source folders:
+	*   - main app:  baseurl=/  apiurl=/api
+	*   - admin app: baseurl=/admin  apiurl=/admin/api
+	*
+	* Correct sort order:
+	*   1. /admin/api  — most specific
+	*   2. /api
+	*   3. /admin
+	*   4. /
+	* */
+	const requestHandlerWeight = ([segments]) => {
+		const [base, api] = segments;
+		/**
+		* set weight to number of non-empty segments:
+		* "/" weight is 0
+		* "/admin" weight is 1
+		* */
+		const weight = base.split("/").filter(Boolean).length;
+		return api ? weight + 5 : weight;
+	};
+	const handlers = requestHandlers.sort((a, b) => requestHandlerWeight(b) - requestHandlerWeight(a));
+	const httpServer = http.createServer((req, res) => {
+		for (const [, matcherFactory, handlerFactory] of handlers) {
+			const [matcher, handler] = [matcherFactory(), handlerFactory()];
+			if (matcher(req)) {
+				handler(req, res);
+				return;
+			}
+		}
+		res.writeHead(404, { "Content-Type": "text/html" });
+		res.end("<h1>404: Not Found</h1>");
+	});
+	httpServer.on("error", (error) => {
+		console.error(styleText("red", `Failed to start dev server on port ${devPort}`));
+		console.error(error.message);
+		process.exit(1);
+	});
+	httpServer.listen(devPort);
+	teardownHandlers.push(async () => {
+		httpServer.close();
+	});
+	return async () => {
+		for (const handler of teardownHandlers) await handler();
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	};
 };
 var cacheDir = ({ root, name }, command, mode) => {
-  return resolve2(root, `var/.vite/${name}/${command}/${mode}`);
+	return resolve(root, `var/.vite/${name}/${command}/${mode}`);
 };
 var folderGenerators = (sourceFolder) => {
-  const { generators = [] } = sourceFolder.config;
-  const coreGenerators = {};
-  const userGenerators = [];
-  for (const base of generators) {
-    if (base.meta.slot) {
-      coreGenerators[base.meta.slot] = base;
-    } else {
-      userGenerators.push(base);
-    }
-  }
-  return [
-    // core generator should run first
-    coreGenerator(),
-    // then api generator
-    ...coreGenerators.api ? [coreGenerators.api] : [],
-    // then fetch generator, only if api generator also enabled
-    ...coreGenerators.fetch && coreGenerators.api ? [coreGenerators.fetch] : [],
-    // then user generators in the order they were added
-    ...userGenerators,
-    // then ssr generator should run after user generators
-    ...coreGenerators.ssr ? [coreGenerators.ssr] : [],
-    // and ssg generator should run last
-    ...coreGenerators.ssg ? [coreGenerators.ssg] : []
-  ];
+	const { generators = [] } = sourceFolder.config;
+	const coreGenerators = {};
+	const userGenerators = [];
+	for (const base of generators) if (base.meta.slot) coreGenerators[base.meta.slot] = base;
+	else userGenerators.push(base);
+	return [
+		src_default(),
+		...coreGenerators.api ? [coreGenerators.api] : [],
+		...coreGenerators.fetch && coreGenerators.api ? [coreGenerators.fetch] : [],
+		...userGenerators,
+		...coreGenerators.ssr ? [coreGenerators.ssr] : [],
+		...coreGenerators.ssg ? [coreGenerators.ssg] : []
+	];
 };
 var eventFactory = async (sourceFolder) => {
-  const { resolvers, resolversFactory } = await routesFactory(
-    sourceFolder,
-    cacheFactory
-  );
-  const { createPath } = pathResolver2(sourceFolder);
-  const generators = [];
-  for (const base of folderGenerators(sourceFolder)) {
-    const factory = base.factory(sourceFolder);
-    generators.push({ name: base.meta.name, factory });
-  }
-  const resolvedRoutes = /* @__PURE__ */ new Map();
-  const runGenerators = async (event) => {
-    const entries = Array.from(resolvedRoutes.values());
-    for (const { name, factory } of generators) {
-      try {
-        await factory.watch?.(entries, event);
-      } catch (error) {
-        console.error(
-          styleText("red", `${sourceFolder.name}: ${name} generator failed`)
-        );
-        if (event) {
-          console.error(event);
-        }
-        console.error(error);
-      }
-    }
-  };
-  const updateResolvedEntry = async (file) => {
-    const resolver = resolvers.get(file);
-    if (!resolver) {
-      return;
-    }
-    try {
-      const resolvedEntry = await resolver.handler(file);
-      resolvedRoutes.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
-      return resolvedEntry;
-    } catch (error) {
-      const route = file.replace(`${createPath.api()}/`, "");
-      console.error(
-        styleText(
-          "red",
-          `${sourceFolder.name}: ${route} route resolution failed`
-        )
-      );
-      console.error(error);
-      return;
-    }
-  };
-  {
-    const spinner = spinnerFactory(`${sourceFolder.name}: resolving routes`);
-    for (const { name, handler } of resolvers.values()) {
-      spinner.append(
-        `[ ${resolvedRoutes.size + 1} of ${resolvers.size} ] ${name}`
-      );
-      const route = await handler();
-      resolvedRoutes.set(route.entry.fileFullpath, route);
-    }
-    spinner.succeed("ready \u2728");
-  }
-  await runGenerators();
-  return {
-    async add(file) {
-      const [resolver] = resolversFactory([file]).values();
-      if (!resolver) {
-        return;
-      }
-      resolvers.set(file, resolver);
-      const resolvedEntry = await updateResolvedEntry(file);
-      if (resolvedEntry) {
-        await runGenerators({ kind: "create", file });
-      }
-    },
-    async change(file) {
-      if (resolvedRoutes.has(file)) {
-        await updateResolvedEntry(file);
-      } else {
-        const relatedRoutes = resolvedRoutes.values().flatMap(({ kind, entry }) => {
-          return kind === "apiRoute" ? entry.referencedFiles.includes(file) ? [entry] : [] : [];
-        });
-        for (const route of relatedRoutes) {
-          await updateResolvedEntry(route.fileFullpath);
-        }
-      }
-      await runGenerators({ kind: "update", file });
-    },
-    async unlink(file) {
-      resolvers.delete(file);
-      resolvedRoutes.delete(file);
-      await runGenerators({ kind: "delete", file });
-    }
-  };
-};
-var matchersFactory = ({
-  baseurl,
-  apiurl
-}) => {
-  const basePattern = new RegExp(`^${baseurl}($|/*)`);
-  const apiPattern = new RegExp(`^${join(baseurl, apiurl)}($|/*)`);
-  return {
-    base(req) {
-      return apiPattern.test(req.url) ? false : basePattern.test(req.url);
-    },
-    api(req) {
-      return apiPattern.test(req.url);
-    }
-  };
+	const { resolvers, resolversFactory } = await routesFactory(sourceFolder, cacheFactory);
+	const { createPath } = pathResolver$1(sourceFolder);
+	const generators = [];
+	for (const base of folderGenerators(sourceFolder)) {
+		const factory = base.factory(sourceFolder);
+		generators.push({
+			name: base.meta.name,
+			factory
+		});
+	}
+	const resolvedRoutes = /* @__PURE__ */ new Map();
+	const runGenerators = async (event) => {
+		/**
+		* Watch handlers receive the full list of entries
+		* and should process only those whose source file or dependencies were updated.
+		* */
+		const entries = Array.from(resolvedRoutes.values());
+		for (const { name, factory } of generators) try {
+			await factory.watch?.(entries, event);
+		} catch (error) {
+			console.error(styleText("red", `${sourceFolder.name}: ${name} generator failed`));
+			if (event) console.error(event);
+			console.error(error);
+		}
+	};
+	const updateResolvedEntry = async (file) => {
+		const resolver = resolvers.get(file);
+		if (!resolver) return;
+		try {
+			const resolvedEntry = await resolver.handler(file);
+			resolvedRoutes.set(resolvedEntry.entry.fileFullpath, resolvedEntry);
+			return resolvedEntry;
+		} catch (error) {
+			const route = file.replace(`${createPath.api()}/`, "");
+			console.error(styleText("red", `${sourceFolder.name}: ${route} route resolution failed`));
+			console.error(error);
+			return;
+		}
+	};
+	{
+		const spinner = spinnerFactory(`${sourceFolder.name}: resolving routes`);
+		for (const { name, handler } of resolvers.values()) {
+			spinner.append(`[ ${resolvedRoutes.size + 1} of ${resolvers.size} ] ${name}`);
+			const route = await handler();
+			resolvedRoutes.set(route.entry.fileFullpath, route);
+		}
+		spinner.succeed("ready ✨");
+	}
+	await runGenerators();
+	return {
+		async add(file) {
+			const [resolver] = resolversFactory([file]).values();
+			if (!resolver) return;
+			resolvers.set(file, resolver);
+			if (await updateResolvedEntry(file)) await runGenerators({
+				kind: "create",
+				file
+			});
+		},
+		async change(file) {
+			if (resolvedRoutes.has(file)) await updateResolvedEntry(file);
+			else {
+				const relatedRoutes = resolvedRoutes.values().flatMap(({ kind, entry }) => {
+					return kind === "apiRoute" ? entry.referencedFiles.includes(file) ? [entry] : [] : [];
+				});
+				for (const route of relatedRoutes) await updateResolvedEntry(route.fileFullpath);
+			}
+			await runGenerators({
+				kind: "update",
+				file
+			});
+		},
+		async unlink(file) {
+			resolvers.delete(file);
+			resolvedRoutes.delete(file);
+			await runGenerators({
+				kind: "delete",
+				file
+			});
+		}
+	};
+};
+var matchersFactory = ({ config }) => {
+	const basePattern = new RegExp(`^${config.base}($|/*)`);
+	const apiPattern = new RegExp(`^${join(config.base, config.apiBase)}($|/*)`);
+	return {
+		base(req) {
+			return apiPattern.test(req.url) ? false : basePattern.test(req.url);
+		},
+		api(req) {
+			return apiPattern.test(req.url);
+		}
+	};
 };
 var findFreePort = async (devPort) => {
-  let minPort = 0;
-  let maxPort = 0;
-  for (const n of [3, 2, 1, ""]) {
-    minPort = Number(`${n}${devPort}`) + 100;
-    maxPort = minPort + 100;
-    if (maxPort < 65e3) {
-      break;
-    }
-  }
-  if (maxPort >= 65e3) {
-    throw new Error("the devPort in package.json should be less than 64000");
-  }
-  const range = maxPort - minPort + 1;
-  const startOffset = Math.floor(Math.random() * range);
-  const ports = Array.from({ length: range }, (_, i) => {
-    return minPort + (startOffset + i) % range;
-  });
-  const freePort = await ports.reduce(
-    async (prevPromise, port) => {
-      const freePort2 = await prevPromise;
-      if (freePort2) {
-        return freePort2;
-      }
-      const isFree = await isPortFree(port);
-      return isFree ? port : void 0;
-    },
-    Promise.resolve(void 0)
-  );
-  if (!freePort) {
-    throw new Error(`No free ports found in range ${minPort}-${maxPort}`);
-  }
-  return freePort;
+	let minPort = 0;
+	let maxPort = 0;
+	for (const n of [
+		3,
+		2,
+		1,
+		""
+	]) {
+		minPort = Number(`${n}${devPort}`) + 100;
+		maxPort = minPort + 100;
+		if (maxPort < 65e3) break;
+	}
+	if (maxPort >= 65e3) throw new Error("the devPort in package.json should be less than 64000");
+	const range = maxPort - minPort + 1;
+	const startOffset = Math.floor(Math.random() * range);
+	const freePort = await Array.from({ length: range }, (_, i) => {
+		return minPort + (startOffset + i) % range;
+	}).reduce(async (prevPromise, port) => {
+		const freePort = await prevPromise;
+		if (freePort) return freePort;
+		return await isPortFree(port) ? port : void 0;
+	}, Promise.resolve(void 0));
+	if (!freePort) throw new Error(`No free ports found in range ${minPort}-${maxPort}`);
+	return freePort;
 };
 var isPortFree = (port) => {
-  return new Promise((resolve3) => {
-    const server = net.createServer();
-    server.once("error", () => resolve3(false));
-    server.once("listening", () => {
-      server.close();
-      resolve3(true);
-    });
-    server.listen(port, "127.0.0.1");
-  });
-};
-export {
-  chassis_default as default
-};
-//# sourceMappingURL=chassis.js.map
+	return new Promise((resolve) => {
+		const server = net.createServer();
+		server.once("error", () => resolve(false));
+		server.once("listening", () => {
+			server.close();
+			resolve(true);
+		});
+		server.listen(port, "127.0.0.1");
+	});
+};
+//#endregion
+export { chassis_default as default };
+
+//# sourceMappingURL=chassis.js.map