@kosmojs/lib 0.0.30 → 0.1.1

package/pkg/index.js

@@ -1,1453 +1,1183 @@
-// src/ast.ts
-import { join, resolve } from "node:path";
+import { builtinModules } from "node:module";
+import { basename, dirname, join, resolve } from "node:path";
 import { styleText } from "node:util";
 import crc from "crc/crc32";
 import { flattener } from "tfusion";
-import {
-  Project,
-  SyntaxKind
-} from "ts-morph";
-import {
-  defaults,
-  RequestValidationTargets
-} from "@kosmojs/core";
-import { HTTPMethods } from "@kosmojs/core/api";
+import { Project, SyntaxKind } from "ts-morph";
+import picomatch from "picomatch";
+import { access, constants, mkdir, readFile, writeFile } from "node:fs/promises";
+import handlebars from "handlebars";
+import { glob } from "tinyglobby";
+import { parse } from "path-to-regexp";
+import mimeTypes from "mime-types";
+import { Spinner } from "@topcli/spinner";
+//#region ../core/pkg/index.js
+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)"
+};
+var RequestValidationTargets = {
+	...RequestMetadataTargets,
+	...RequestBodyTargets
+};
+//#endregion
+//#region ../core/pkg/api/index.js
+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;
+}({});
+//#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,
-      // first generic - the route name
-      paramsGeneric
-      // second generic - params refinements
-    ] = 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 [callExpression2, method] of callExpressions) {
-      const [vDefs, vOpts] = extractGenerics(callExpression2);
-      methods.push({
-        method,
-        validationDefinitions: extractValidationDefinitions(
-          route,
-          method,
-          vDefs,
-          vOpts
-        )
-      });
-    }
-    return methods;
-  };
-  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;
-      }
-    }
-    return void 0;
-  };
-  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 };
-  };
-  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 typeNode2 = prop.getTypeNodeOrThrow();
-      if (!typeNode2.isKind(SyntaxKind.TypeLiteral)) {
-        continue;
-      }
-      let contentType;
-      let runtimeValidation;
-      const customErrors = {};
-      for (const member of typeNode2.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;
-  };
-  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"],
-                  `\u2717 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) => {
-    const declarations = importIdentifier?.getSymbol()?.getAliasedSymbol()?.getDeclarations() || [];
-    return declarations.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.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
-  };
+	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.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
+	};
 };
-
-// src/generators.ts
-import picomatch from "picomatch";
+//#endregion
+//#region src/generators.ts
 var defineGenerator = (f) => f;
 var defineGeneratorFactory = (f) => f;
 var createTemplateResolver = (customTemplates, defaultTemplate) => {
-  const templates = Object.entries({
-    ...customTemplates
-  }).map(([pattern, template]) => [picomatch(pattern), template]);
-  return (pattern, entry) => {
-    const match = templates.find(([isMatch]) => isMatch(pattern));
-    if (!match) {
-      return defaultTemplate;
-    }
-    return typeof match[1] === "function" ? match[1](entry) : match[1];
-  };
+	const templates = Object.entries({ ...customTemplates }).map(([pattern, template]) => [picomatch(pattern), template]);
+	return (pattern, entry) => {
+		const match = templates.find(([isMatch]) => isMatch(pattern));
+		if (!match) return defaultTemplate;
+		return typeof match[1] === "function" ? match[1](entry) : match[1];
+	};
 };
-
-// src/paths.ts
-import { access, constants } from "node:fs/promises";
-import { join as join2, resolve as resolve2 } from "node:path";
-import { defaults as defaults2 } from "@kosmojs/core";
+//#endregion
+//#region src/paths.ts
 var pathResolver = (sourceFolder) => {
-  const createPath = (...a) => {
-    return sourceFolder.root ? resolve2(sourceFolder.root, join2(...a)) : join2(...a);
-  };
-  const createImport = {
-    src(a, { origin }) {
-      return origin === "src" ? join2(defaults2.srcPrefix, ...a) : join2(defaults2.appPrefix, defaults2.srcDir, sourceFolder.name, ...a);
-    },
-    config(a, o) {
-      return this.src([defaults2.configDir, ...a], o);
-    },
-    api(a, o) {
-      return this.src([defaults2.apiDir, ...a], o);
-    },
-    pages(a, o) {
-      return this.src([defaults2.pagesDir, ...a], o);
-    },
-    lib(a, { origin }) {
-      return origin === "src" ? join2(defaults2.libPrefix, ...a) : join2(defaults2.appPrefix, defaults2.libDir, sourceFolder.name, ...a);
-    },
-    libCore(a, o) {
-      return this.lib(["core", ...a], o);
-    },
-    libApi(a, o) {
-      return this.lib([defaults2.apiDir, ...a], o);
-    },
-    libEntry(a, o) {
-      return this.lib([defaults2.entryDir, ...a], o);
-    }
-  };
-  return {
-    createPath: {
-      src(...a) {
-        return createPath(defaults2.srcDir, sourceFolder.name, ...a);
-      },
-      api(...a) {
-        return this.src(defaults2.apiDir, ...a);
-      },
-      pages(...a) {
-        return this.src(defaults2.pagesDir, ...a);
-      },
-      config(...a) {
-        return this.src(defaults2.configDir, ...a);
-      },
-      entry(...a) {
-        return this.src(defaults2.entryDir, ...a);
-      },
-      lib(...a) {
-        return createPath(defaults2.libDir, sourceFolder.name, ...a);
-      },
-      libCore(...a) {
-        return this.lib("core", ...a);
-      },
-      libApi(...a) {
-        return this.lib(defaults2.apiDir, ...a);
-      },
-      libEntry(...a) {
-        return this.lib(defaults2.entryDir, ...a);
-      },
-      libPages(...a) {
-        return this.lib(defaults2.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);
-        }
-      };
-    }
-  };
+	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);
+		},
+		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) => {
-  try {
-    await access(path, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
 };
-
-// src/render.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join as join3 } from "node:path";
-import crc2 from "crc/crc32";
-import handlebars from "handlebars";
+//#endregion
+//#region src/render.ts
 var render = (template, context, options) => {
-  const { noEscape = true, renderer = handlebars } = { ...options };
-  return renderer.compile(template, { noEscape })(context);
+	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);
-  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 (crc2(content) === crc2(fileContent)) {
-      return;
-    }
-  }
-  await mkdir(dirname(file), { recursive: true });
-  await writeFile(file, content, "utf8");
+	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 ? join3(options.outdir, file) : file,
-        template,
-        context,
-        {
-          ...options,
-          ...selfOoptions,
-          renderer: createRenderer(selfOoptions)
-        }
-      );
-    }
-  };
+	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)
+			});
+		}
+	};
 };
-
-// src/routes/index.ts
-import {
-  defaults as defaults5
-} from "@kosmojs/core";
-
-// src/routes/base.ts
-import { dirname as dirname2, join as join4, resolve as resolve3 } from "node:path";
-import { styleText as styleText2 } from "node:util";
-import crc4 from "crc/crc32";
-import picomatch2 from "picomatch";
-import { glob } from "tinyglobby";
-import {
-  defaults as defaults3
-} from "@kosmojs/core";
-
-// src/routes/paths.ts
-import crc3 from "crc/crc32";
-import { parse } from "path-to-regexp";
-var pathTokensFactory = (path, {
-  transformStaticValue = normalizeStaticValue
-} = {}) => {
-  const extractParts = (tokens2, createConst, insideGroup = false) => {
-    const parts = [];
-    for (const token of tokens2) {
-      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 = [
-    // Transform required params: [id] => :id
-    // Only pure \w param names,
-    // [some-id] used as is, not treated as param,
-    // use [some_id] instead.
-    (s) => s.replace(/\[(\w+)\]/g, ":$1"),
-    // Transform optional params: {id} => {:id}
-    // Only pure \w param names,
-    // anything else treated as a path-to-regexp pattern and used as is.
-    // {some-id} treated as an optional static segment.
-    // use {some_id} for simple param syntax
-    // or {:some-id} pattern where :some is the param name and -id is a static segment.
-    (s) => s.replace(/\{(\w+)\}/g, "{:$1}"),
-    // Transform splat params: {...param} => {*param}
-    (s) => s.replace(/\{\.\.\./g, "{*"),
-    // Insert leading slash inside optional/splat groups.
-    // {:name} => {/:name}
-    // {*name} => {/*name}
-    (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) {
-        const match = s.slice(i + 1).match(/^\w+/);
-        return match?.[0] || ":";
-      }
-    }
-    return;
-  };
-  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: tokens2 } = parse(
-      pattern.replace(/\{[^}]*\}|(\+)/g, (m, p1) => p1 ? "\\+" : m)
-    );
-    const parts = extractParts(tokens2, (val) => {
-      return /\W/.test(val) || /^\d/.test(val) ? [val.replace(/^\d+|\W/g, "_"), crc3(orig)].join("_") : val;
-    });
-    const isStatic = parts.length === 1 ? parts[0].type === "static" : false;
-    const isParam = parts.length === 1 ? parts[0].type === "param" : false;
-    const kind = isStatic ? "static" : isParam ? "param" : "mixed";
-    return [
-      {
-        kind,
-        orig,
-        pattern,
-        parts
-      }
-    ];
-  });
-  return tokens;
+//#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.
+*
+* 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;
-    }
-    const slashRequired = tokens.slice(i + 1).some((e) => {
-      return e.parts.some((e2) => {
-        return e2.type === "static" || e2.kind === "required";
-      });
-    });
-    return slashRequired ? `${pattern}/` : pattern;
-  }).join("");
+	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 = (tokens2) => {
-    return tokens2.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: tokens2 } = parse(token.pattern.replace(/\//g, ""));
-    const regex = tokensToRegex(tokens2);
-    return [`:_${i}{${regex}}`];
-  }).join("/");
+	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, "\\\\+");
+	return value.replace(/\+/g, "\\\\+");
 };
-
-// src/routes/base.ts
+//#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 = `${API_USE_BASENAME}.ts`;
+var API_USE_PATTERN = `use.ts`;
 var PAGE_INDEX_BASENAME = "index";
 var PAGE_INDEX_PATTERN = `${PAGE_INDEX_BASENAME}.{tsx,vue,mdx,md}`;
 var PAGE_LAYOUT_BASENAME = "layout";
 var PAGE_LAYOUT_PATTERN = `${PAGE_LAYOUT_BASENAME}.{tsx,vue,mdx}`;
 var ROUTE_FILE_PATTERNS = [
-  // match index files in api dir
-  `${defaults3.apiDir}/**/${API_INDEX_PATTERN}`,
-  // match use files in api dir
-  `${defaults3.apiDir}/**/${API_USE_PATTERN}`,
-  // match index files in pages dir
-  `${defaults3.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
-  // match layout files in pages dir
-  `${defaults3.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
+	`${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: [
-      // ignore top-level matches, routes resides in folders, even index route
-      `${defaults3.apiDir}/${API_INDEX_PATTERN}`,
-      `${defaults3.apiDir}/${API_USE_PATTERN}`,
-      `${defaults3.pagesDir}/${PAGE_INDEX_PATTERN}`,
-      `${defaults3.pagesDir}/${PAGE_LAYOUT_PATTERN}`
-    ]
-  });
+	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 [
-    // source folder name
-    _sourceFolder,
-    // route folder, api or pages
-    _folder,
-    ...rest
-  ] = resolve3(sourceFolder.root, file).replace(`${sourceFolder.root}/${defaults3.srcDir}/`, "").split("/");
-  if (!_folder || _sourceFolder !== sourceFolder.name || rest.length < 2) {
-    return false;
-  }
-  return picomatch2.isMatch(join4(_folder, ...rest), ROUTE_FILE_PATTERNS) ? [_folder, rest.join("/")] : false;
+	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 picomatch2.matchBase(file, `**/${API_INDEX_PATTERN}`);
+	return picomatch.matchBase(file, `**/${API_INDEX_PATTERN}`);
 };
 var isApiUse = (file) => {
-  return picomatch2.matchBase(file, `**/${API_USE_PATTERN}`);
+	return picomatch.matchBase(file, `**/${API_USE_PATTERN}`);
 };
 var isPageRoute = (file) => {
-  return picomatch2.matchBase(file, `**/${PAGE_INDEX_PATTERN}`);
+	return picomatch.matchBase(file, `**/${PAGE_INDEX_PATTERN}`);
 };
 var isPageLayout = (file) => {
-  return picomatch2.matchBase(file, `**/${PAGE_LAYOUT_PATTERN}`);
+	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, "_")}_${crc4(file)}`;
-  const name = dirname2(file);
-  try {
-    const pathTokens = pathTokensFactory(dirname2(file));
-    return {
-      id,
-      name,
-      folder,
-      file,
-      fileFullpath,
-      pathTokens,
-      pathPattern: createPathPattern(pathTokens),
-      honoPattern: createHonoPattern(pathTokens)
-    };
-  } catch (error) {
-    console.error(
-      `\u2757${styleText2("red", "ERROR")}: Failed parsing path for "${styleText2("cyan", file)}"`
-    );
-    console.error(error);
-    return;
-  }
+	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;
+	}
 };
+/**
+* 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 part2 of token.parts) {
-      if (part2.type === "static") {
-        statics += 1;
-      } else if (part2.kind === "optional" || part2.kind === "splat") {
-        optionals += 1;
-      }
-    }
-    return 3 + statics * 0.01 - optionals * 5e-3;
-  }
-  const part = token.parts[0];
-  switch (part.kind) {
-    case "required":
-      return 2;
-    case "optional":
-      return 1;
-    case "splat":
-      return 0;
-  }
+	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;
-      const isSplat = extra?.kind === "param" ? extra.parts[0].kind === "splat" : false;
-      if (isSplat) {
-        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);
+	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);
 };
-
-// src/routes/resolve.ts
-import { dirname as dirname3, join as join5, resolve as resolve4 } from "node:path";
-import { styleText as styleText3 } from "node:util";
-import crc5 from "crc/crc32";
-import mimeTypes from "mime-types";
-import {
-  defaults as defaults4
-} from "@kosmojs/core";
-
-// src/templates/resolved-types.hbs
+//#endregion
+//#region src/templates/resolved-types.hbs?raw
 var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
-
-// src/templates/types.hbs
-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';
-
-// src/routes/resolve.ts
+//#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/routes/resolve.ts
 var resolverFactory = (sourceFolder, cacheFactory) => {
-  const {
-    //
-    generators = [],
-    refineTypeName = defaults4.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 () => {
-        const entry2 = {
-          id,
-          name,
-          pathTokens,
-          pathPattern,
-          honoPattern,
-          params: {
-            schema: pathTokens.flatMap((e) => {
-              return e.parts.filter((p) => p.type === "param");
-            })
-          },
-          folder,
-          file,
-          fileFullpath
-        };
-        return {
-          kind: "pageRoute",
-          entry: entry2
-        };
-      };
-      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: validationDefinitions2,
-            referencedFiles = []
-          } = await resolveRouteSignature(
-            { id, name, fileFullpath, optionalParams },
-            {
-              withReferencedFiles: true,
-              sourceFile: getSourceFile(fileFullpath),
-              relpathResolver(path) {
-                return join5(
-                  sourceFolder.name,
-                  defaults4.apiDir,
-                  dirname3(file),
-                  path
-                );
-              }
-            }
-          );
-          const validationTypes = validationDefinitions2.flatMap((def) => {
-            return def.target === "response" ? def.variants.flatMap(({ id: id2, body }) => {
-              return body ? [{ id: id2, 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(sourceFolder).createPath.libApi(
-            dirname3(file),
-            "types.ts"
-          );
-          const params = {
-            id: ["ParamsT", crc5(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.flatMap(({ id: id2 }) => id2)
-            ]
-          }) : void 0;
-          await renderToFile(
-            typesFile,
-            resolvedTypes ? resolved_types_default : typesFileContent,
-            { resolvedTypes }
-          );
-          params.resolvedType = resolvedTypes?.find(
-            (e) => e.name === params.id
-          );
-          cache = {
-            // placeholder values, if cacheFactory given,
-            // they will be replaced by persistCache
-            hash: 0,
-            referencedFiles: {},
-            // real values
-            params,
-            methods,
-            typeDeclarations,
-            numericParams,
-            validationDefinitions: validationDefinitions2.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(
-                      styleText3(
-                        ["bold", "red"],
-                        "\u2717 Failed resolving Response Content Type"
-                      )
-                    );
-                    console.warn(
-                      `  Invalid value provided for mime-types lookup - ${variant.contentType}`
-                    );
-                    console.warn(
-                      styleText3(
-                        ["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(
-                  styleText3(
-                    ["bold", "red"],
-                    "\u2717 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] : [];
-          }
-        );
-        const entry2 = {
-          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(
-            // expand referenced files path,
-            // they are stored as relative in cache
-            (e) => resolve4(sourceFolder.root, e)
-          )
-        };
-        return {
-          kind: "apiRoute",
-          entry: entry2
-        };
-      };
-      return { name, handler };
-    }
-  };
+	const { generators = [], refineTypeName = defaults.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.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(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.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(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
+			};
+		}
+	};
 };
-
-// src/routes/nesting.ts
-import { basename } from "node:path";
+//#endregion
+//#region src/routes/nesting.ts
 var nestedRoutesFactory = (routeEntries) => {
-  const entryStack = structuredClone(routeEntries).sort(sortRoutes);
-  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 [];
-    });
-  };
-  const findDescendantEntries = ({
-    name,
-    pathTokens
-  }) => {
-    const potentialChildren = entryStack.filter((entry) => {
-      if (entry.pathTokens.length <= pathTokens.length) {
-        return false;
-      }
-      if (!entry.name.startsWith(`${name}/`)) {
-        return false;
-      }
-      return true;
-    });
-    return potentialChildren.filter((child) => {
-      const hasIntermediateRoute = 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(`${intermediate.name}/`);
-      });
-      return !hasIntermediateRoute;
-    });
-  };
-  const rootEntries = entryStack.filter((entry) => {
-    const hasParent = entryStack.some((potential) => {
-      if (potential === entry) {
-        return false;
-      }
-      if (potential.pathTokens.length >= entry.pathTokens.length) {
-        return false;
-      }
-      return entry.name.startsWith(`${potential.name}/`);
-    });
-    return !hasParent;
-  });
-  return transformEntries(rootEntries);
+	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(`${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(`${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(`${potential.name}/`);
+		});
+	}));
 };
-
-// src/routes/index.ts
+//#endregion
+//#region src/routes/index.ts
 var routesFactory = async (sourceFolder, cacheFactory) => {
-  const {
-    apiRouteResolver,
-    apiUseResolver,
-    pageRouteResolver,
-    pageLayoutResolver
-  } = resolverFactory(sourceFolder, cacheFactory);
-  const resolversFactory = (routeFiles2) => {
-    const resolvers = /* @__PURE__ */ new Map();
-    const entries = routeFiles2.flatMap((file) => {
-      const entry = createRouteEntry(file, sourceFolder);
-      return entry ? [entry] : [];
-    });
-    for (const entry of entries) {
-      if (entry.folder === defaults5.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 === defaults5.pagesDir) {
-        if (isPageRoute(entry.file)) {
-          resolvers.set(entry.fileFullpath, pageRouteResolver(entry));
-        } else if (isPageLayout(entry.file)) {
-          resolvers.set(entry.fileFullpath, pageLayoutResolver(entry));
-        }
-      }
-    }
-    return resolvers;
-  };
-  const routeFiles = await scanRoutes(sourceFolder);
-  return {
-    resolvers: resolversFactory(routeFiles),
-    resolversFactory
-  };
+	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
+	};
 };
-
-// src/spinner.ts
-import { Spinner } from "@topcli/spinner";
+//#endregion
+//#region src/spinner.ts
 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} \u203A ${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();
-    }
-  };
+	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();
+		}
+	};
 };
 var withSpinner = (text, pipe, spinner) => pipe(spinner || spinnerFactory(text));
-
-// src/typebox.ts
-import { defaults as defaults6 } from "@kosmojs/core";
+//#endregion
+//#region src/typebox.ts
 var typeboxLiteralText = (text, sourceFolder) => {
-  const { refineTypeName = defaults6.refineTypeName } = sourceFolder.config;
-  return [
-    // Escape backticks for safe use in template literals
-    [/(?<!\\)`/g, "\\`"],
-    // Escape $ for safe use in template literals
-    [/(?<!\\)\$\{/g, "\\${"],
-    /**
-     * TypeBox's built-in `Options` type is not configurable.
-     * To allow a custom type name, exposing `refineTypeName` option,
-     * defaulted to VRefine, then renaming it to `Options`.
-     * */
-    [new RegExp(`\\b${refineTypeName}\\s*<`, "g"), "Options<"]
-  ].reduce((text2, [a, b]) => text2.replace(a, b), text);
+	const { refineTypeName = defaults.refineTypeName } = sourceFolder.config;
+	return [
+		[/(?<!\\)`/g, "\\`"],
+		[/(?<!\\)\$\{/g, "\\${"],
+		[new RegExp(`\\b${refineTypeName}\\s*<`, "g"), "Options<"]
+	].reduce((text, [a, b]) => text.replace(a, b), text);
 };
-
-// src/vite.ts
-import { builtinModules } from "node:module";
+//#endregion
+//#region src/vite.ts
 var nodePrefix = () => {
-  return {
-    name: "kosmojs:node-prefix",
-    enforce: "pre",
-    resolveId(source) {
-      return builtinModules.includes(source) ? { id: `node:${source}`, external: true } : void 0;
-    }
-  };
-};
-var vitePlugins = {
-  nodePrefix
+	return {
+		name: "kosmojs:node-prefix",
+		enforce: "pre",
+		resolveId(source) {
+			return builtinModules.includes(source) ? {
+				id: `node:${source}`,
+				external: true
+			} : void 0;
+		}
+	};
 };
-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,
-  createHonoPattern,
-  createPathPattern,
-  createRouteEntry,
-  createTemplateResolver,
-  defineGenerator,
-  defineGeneratorFactory,
-  isApiRoute,
-  isApiUse,
-  isPageLayout,
-  isPageRoute,
-  isRouteFile,
-  nestedRoutesFactory,
-  normalizeStaticValue,
-  pathExists,
-  pathResolver,
-  pathTokensFactory,
-  render,
-  renderFactory,
-  renderToFile,
-  routesFactory,
-  scanRoutes,
-  sortRoutes,
-  spinnerFactory,
-  typeboxLiteralText,
-  vitePlugins,
-  withSpinner
-};
-//# sourceMappingURL=index.js.map
+var vitePlugins = { nodePrefix };
+//#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, createHonoPattern, createPathPattern, createRouteEntry, createTemplateResolver, defineGenerator, defineGeneratorFactory, isApiRoute, isApiUse, isPageLayout, isPageRoute, isRouteFile, nestedRoutesFactory, normalizeStaticValue, pathExists, pathResolver, pathTokensFactory, render, renderFactory, renderToFile, routesFactory, scanRoutes, sortRoutes, spinnerFactory, typeboxLiteralText, vitePlugins, withSpinner };
+
+//# sourceMappingURL=index.js.map