@faapi/faapi 0.0.0-canary.22b65a2 → 0.0.0-canary.a3f7014

package/dist/cli/index.js

@@ -9,351 +9,277 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/router/constants.ts
-function isHttpMethod(value) {
-  return HTTP_METHOD_SET.has(value);
+// src/utils/resolveAlias.ts
+function resolveAlias(specifier, config) {
+  const candidates = [];
+  for (const [pattern, targets] of Object.entries(config.paths)) {
+    const wildcardIndex = pattern.indexOf("*");
+    if (wildcardIndex === -1) {
+      if (specifier === pattern) {
+        candidates.push(...targets);
+      }
+      continue;
+    }
+    const prefix = pattern.slice(0, wildcardIndex);
+    const suffix = pattern.slice(wildcardIndex + 1);
+    if (specifier.startsWith(prefix) && specifier.endsWith(suffix) && specifier.length >= prefix.length + suffix.length) {
+      const captured = specifier.slice(prefix.length, specifier.length - suffix.length);
+      for (const target of targets) {
+        candidates.push(target.replace("*", captured));
+      }
+    }
+  }
+  return candidates;
 }
-var HTTP_METHODS, HTTP_METHOD_SET;
-var init_constants = __esm({
-  "src/router/constants.ts"() {
+var init_resolveAlias = __esm({
+  "src/utils/resolveAlias.ts"() {
     "use strict";
-    HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
-    HTTP_METHOD_SET = new Set(HTTP_METHODS);
   }
 });
 
-// src/utils/normalizePath.ts
-function normalizePath(path17) {
-  if (!path17) return "";
-  let result = path17.replace(/\\/g, "/");
-  result = result.replace(/\/+/g, "/");
-  result = result.replace(/\/+$/, "");
-  if (result && !result.startsWith("/")) {
-    result = "/" + result;
+// src/utils/readTsconfig.ts
+import ts from "typescript";
+import path from "path";
+import fs from "fs";
+function readTsconfig(rootDir) {
+  const tsconfigPath = path.resolve(rootDir, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) return null;
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  if (configFile.error || !configFile.config) return null;
+  const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, rootDir);
+  const baseUrl = parsed.options.baseUrl ?? rootDir;
+  const rawPaths = parsed.options.paths;
+  if (!rawPaths) return null;
+  const paths = {};
+  for (const [pattern, targets] of Object.entries(rawPaths)) {
+    paths[pattern] = targets.map((t) => path.resolve(baseUrl, t));
   }
-  return result;
+  return { baseUrl, paths };
 }
-var init_normalizePath = __esm({
-  "src/utils/normalizePath.ts"() {
+var init_readTsconfig = __esm({
+  "src/utils/readTsconfig.ts"() {
     "use strict";
   }
 });
 
-// src/router/parseRouteFile.ts
-function dynamicSegmentToParam(segment) {
-  const match = segment.match(/^\[(.+)\]$/);
-  if (match) {
-    return ":" + match[1];
-  }
-  return segment;
+// src/cli/aliasPlugin.ts
+import path2 from "path";
+import fs2 from "fs";
+function toProdExtension(filePath) {
+  if (filePath.endsWith(".ts")) return filePath.slice(0, -3) + ".js";
+  if (filePath.endsWith(".tsx")) return filePath.slice(0, -4) + ".js";
+  if (filePath.endsWith(".jsx")) return filePath.slice(0, -4) + ".js";
+  return filePath;
 }
-function extractParamNames(urlPath) {
-  const params = [];
-  const segments = urlPath.split("/");
-  for (const segment of segments) {
-    if (segment.startsWith(":...")) {
-      params.push(segment.slice(4));
-    } else if (segment.startsWith(":")) {
-      params.push(segment.slice(1));
-    }
-  }
-  return params;
+function toProdImportPath(sourceFile, importer) {
+  const importerDir = path2.dirname(importer);
+  let rel = path2.relative(importerDir, sourceFile);
+  rel = rel.split(path2.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return toProdExtension(rel);
 }
-function isCatchAllSegment(segment) {
-  return /^\[\.\.\..+\]$/.test(segment);
+function createAliasPlugin(config) {
+  const EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  const INDEX_EXTS = [
+    "/index.ts",
+    "/index.tsx",
+    "/index.js",
+    "/index.jsx",
+    "/index.mjs",
+    "/index.cjs"
+  ];
+  const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
+  return {
+    name: "faapi-alias",
+    setup(build) {
+      build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
+        let source;
+        try {
+          source = fs2.readFileSync(args.path, "utf8");
+        } catch {
+          return void 0;
+        }
+        const importer = args.path;
+        let modified = false;
+        const newSource = source.replace(SPEC_RE, (full, prefix, quote, specifier) => {
+          if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("file:") || specifier.startsWith("node:")) {
+            return full;
+          }
+          const candidates = resolveAlias(specifier, config);
+          for (const candidate of candidates) {
+            for (const ext of EXTS) {
+              const file = candidate + ext;
+              if (fs2.existsSync(file)) {
+                modified = true;
+                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
+              }
+            }
+            for (const indexExt of INDEX_EXTS) {
+              const file = candidate + indexExt;
+              if (fs2.existsSync(file)) {
+                modified = true;
+                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
+              }
+            }
+          }
+          return full;
+        });
+        if (!modified) return void 0;
+        return { contents: newSource, loader: "default" };
+      });
+    }
+  };
 }
-function isRouteGroup(segment) {
-  return /^\(.+\)$/.test(segment);
+function buildAliasPlugins(rootDir) {
+  const tsconfig = readTsconfig(rootDir);
+  return tsconfig ? [createAliasPlugin(tsconfig)] : [];
 }
-function filePathToUrlPath(filePath, appDir = ".") {
-  const withoutPrefix = filePath.startsWith(appDir + "/") ? filePath.slice(appDir.length + 1) : filePath;
-  const lastSlashIndex = withoutPrefix.lastIndexOf("/");
-  const dirPath = lastSlashIndex === -1 ? "" : withoutPrefix.slice(0, lastSlashIndex);
-  if (!dirPath) {
-    return "";
+var init_aliasPlugin = __esm({
+  "src/cli/aliasPlugin.ts"() {
+    "use strict";
+    init_resolveAlias();
+    init_readTsconfig();
   }
-  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
-  return normalizePath(segments.join("/"));
+});
+
+// src/cli/compileDevRoutes.ts
+import path3 from "path";
+import fs3 from "fs";
+import fg from "fast-glob";
+async function compileDevRoutes(options) {
+  const { rootDir, appDir, outDir, files, logLevel = "silent" } = options;
+  const entryPoints = files ?? await fg([`${appDir}/**/*.ts`], {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
+  });
+  if (entryPoints.length === 0) {
+    return { compiledFiles: [] };
+  }
+  const absOutDir = path3.resolve(rootDir, outDir);
+  await fs3.promises.mkdir(absOutDir, { recursive: true });
+  const plugins = buildAliasPlugins(rootDir);
+  const esbuild = await import("esbuild");
+  const outbase = appDir === "." ? rootDir : path3.resolve(rootDir, appDir);
+  await esbuild.build({
+    entryPoints,
+    outdir: absOutDir,
+    outbase,
+    bundle: false,
+    platform: "node",
+    format: "esm",
+    sourcemap: true,
+    packages: "external",
+    plugins,
+    logLevel
+  });
+  return { compiledFiles: entryPoints };
 }
-var init_parseRouteFile = __esm({
-  "src/router/parseRouteFile.ts"() {
+var init_compileDevRoutes = __esm({
+  "src/cli/compileDevRoutes.ts"() {
     "use strict";
-    init_normalizePath();
+    init_aliasPlugin();
   }
 });
 
-// src/utils/importWithCacheBust.ts
-import { pathToFileURL } from "url";
-function setLoadTimestamp(ts7) {
-  loadTs = ts7;
-}
-async function importWithCacheBust(filePath) {
-  let url = pathToFileURL(filePath).href;
-  if (loadTs !== void 0) {
-    url += `?t=${loadTs}`;
+// src/config/deepMerge.ts
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overVal = override[key];
+    if (baseVal instanceof Date || overVal instanceof Date || baseVal instanceof RegExp || overVal instanceof RegExp || baseVal instanceof Map || overVal instanceof Map || baseVal instanceof Set || overVal instanceof Set) {
+      result[key] = overVal;
+      continue;
+    }
+    if (baseVal !== null && overVal !== null && typeof baseVal === "object" && typeof overVal === "object" && !Array.isArray(baseVal) && !Array.isArray(overVal) && !(baseVal instanceof Function) && !(overVal instanceof Function)) {
+      result[key] = deepMerge(
+        baseVal,
+        overVal
+      );
+    } else {
+      result[key] = overVal;
+    }
   }
-  return await import(url);
+  return result;
 }
-var loadTs;
-var init_importWithCacheBust = __esm({
-  "src/utils/importWithCacheBust.ts"() {
+var DEEP_MERGE_SOURCE;
+var init_deepMerge = __esm({
+  "src/config/deepMerge.ts"() {
     "use strict";
+    DEEP_MERGE_SOURCE = `const deepMerge = ${deepMerge.toString()};`;
   }
 });
 
-// src/middleware/loadMiddlewares.ts
-function invalidateMiddlewareCache() {
-  middlewareCache.clear();
-}
-function getCachedMiddlewares(absPath) {
-  return middlewareCache.get(absPath);
+// src/cli/compileConfig.ts
+import path4 from "path";
+import fs4 from "fs";
+function getEnv() {
+  return process.env.FAAPI_ENV || process.env.NODE_ENV || "development";
 }
-function setCachedMiddlewares(absPath, bundle) {
-  middlewareCache.set(absPath, bundle);
+function findBaseConfig(rootDir) {
+  for (const f of BASE_CONFIG_FILES) {
+    if (fs4.existsSync(path4.join(rootDir, f))) {
+      return f.replace(/\.(ts|js)$/, "");
+    }
+  }
+  return null;
 }
-async function loadMiddlewaresFile(filePath) {
-  try {
-    const module = await importWithCacheBust(filePath);
-    const middlewares = module.default ?? module.middlewares ?? [];
-    if (!Array.isArray(middlewares)) {
-      console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: [], injectors: {} };
+function findEnvConfig(rootDir, env) {
+  for (const ext of ENV_CONFIG_EXTS) {
+    const f = `faapi.config.${env}${ext}`;
+    if (fs4.existsSync(path4.join(rootDir, f))) {
+      return `faapi.config.${env}`;
     }
-    const validMiddlewares = middlewares.filter((m) => {
-      if (typeof m !== "function") {
-        console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
-        return false;
-      }
-      return true;
-    });
-    const injectors = module.injectors ?? {};
-    if (typeof injectors !== "object" || injectors === null) {
-      console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: validMiddlewares, injectors: {} };
-    }
-    const validInjectors = {};
-    for (const [name, injector] of Object.entries(injectors)) {
-      if (typeof injector !== "function") {
-        console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
-        continue;
-      }
-      validInjectors[name] = injector;
-    }
-    return { middlewares: validMiddlewares, injectors: validInjectors };
-  } catch {
-    return { middlewares: [], injectors: {} };
-  }
-}
-var middlewareCache;
-var init_loadMiddlewares = __esm({
-  "src/middleware/loadMiddlewares.ts"() {
-    "use strict";
-    init_importWithCacheBust();
-    middlewareCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/router/scanRoutes.ts
-import fg from "fast-glob";
-import path from "path";
-import fs from "fs";
-function toProdAbsPath(sourceAbsPath, rootDir, appDir, prodDir) {
-  let rel = path.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
-  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
-    rel = rel.slice(appDir.length + 1);
-  }
-  const prodRel = `${prodDir}/${rel.replace(/\.ts$/, ".js")}`;
-  return path.resolve(rootDir, prodRel);
-}
-async function findMergedMiddlewares(routeFilePath, rootDir, appDir, prodDir) {
-  const routeDir = path.dirname(routeFilePath);
-  const resolvedRoot = path.resolve(rootDir);
-  const mwPaths = [];
-  let currentDir = path.resolve(rootDir, routeDir);
-  while (true) {
-    if (prodDir) {
-      const mwPath = path.join(currentDir, "middlewares.js");
-      const absMwPath = path.resolve(rootDir, mwPath);
-      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, appDir, prodDir);
-      if (fs.existsSync(prodAbsMwPath)) {
-        mwPaths.push(prodAbsMwPath);
-      }
-    } else {
-      for (const ext of [".ts", ".js"]) {
-        const mwPath = path.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path.resolve(rootDir, mwPath);
-        if (fs.existsSync(absMwPath)) {
-          mwPaths.push(absMwPath);
-          break;
-        }
-      }
-    }
-    if (currentDir === resolvedRoot) break;
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
-  }
-  if (mwPaths.length === 0) return void 0;
-  mwPaths.reverse();
-  const mergedMiddlewares = [];
-  const mergedInjectors = {};
-  for (const absMwPath of mwPaths) {
-    let bundle = getCachedMiddlewares(absMwPath);
-    if (bundle === void 0) {
-      bundle = await loadMiddlewaresFile(absMwPath);
-      setCachedMiddlewares(absMwPath, bundle);
-    }
-    mergedMiddlewares.push(...bundle.middlewares);
-    for (const [name, injector] of Object.entries(bundle.injectors)) {
-      mergedInjectors[name] = injector;
-    }
-  }
-  if (mergedMiddlewares.length === 0 && Object.keys(mergedInjectors).length === 0) {
-    return void 0;
-  }
-  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
-}
-async function extractMethodsFromHandler(absPath) {
-  try {
-    const module = await importWithCacheBust(absPath);
-    const methods = [];
-    for (const key of Object.keys(module)) {
-      if (isHttpMethod(key) && typeof module[key] === "function") {
-        methods.push(key);
-      }
-    }
-    return methods;
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    console.warn(`[faapi] \u52A0\u8F7D\u8DEF\u7531\u6587\u4EF6\u5931\u8D25 ${absPath}: ${reason}`);
-    return [];
-  }
-}
-async function hasWsExport(absPath) {
-  try {
-    const module = await importWithCacheBust(absPath);
-    return typeof module["WS"] === "function";
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    console.warn(`[faapi] \u52A0\u8F7D\u8DEF\u7531\u6587\u4EF6\u5931\u8D25\uFF08WS \u68C0\u6D4B\uFF09${absPath}: ${reason}`);
-    return false;
   }
+  return null;
 }
-async function scanRoutes(rootDir, patterns, appDir, prodDir) {
-  const dir = appDir ?? ".";
-  const files = await fg(patterns, {
-    cwd: rootDir,
-    onlyFiles: true,
-    absolute: false
-  });
-  const routes = [];
-  const wsRoutes = [];
-  for (const file of files) {
-    const normalizedFile = file.replace(/\\/g, "/");
-    const fileName = normalizedFile.split("/").pop();
-    if (fileName === "handler.ts" || fileName === "handler.js") {
-      const absPath = path.resolve(rootDir, normalizedFile);
-      const importPath = prodDir ? toProdAbsPath(absPath, rootDir, dir, prodDir) : absPath;
-      const urlPath = filePathToUrlPath(normalizedFile, dir);
-      const paramNames = extractParamNames(urlPath);
-      const isDynamic = paramNames.length > 0;
-      const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
-      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, dir, prodDir);
-      const methods = await extractMethodsFromHandler(importPath);
-      for (const method of methods) {
-        routes.push({
-          method,
-          urlPath,
-          filePath: normalizedFile,
-          paramNames,
-          isDynamic,
-          isCatchAll: isCatchAll || void 0,
-          middlewares: middlewareBundle?.middlewares,
-          injectors: middlewareBundle?.injectors
-        });
-      }
-      const hasWs = await hasWsExport(importPath);
-      if (hasWs) {
-        wsRoutes.push({
-          urlPath,
-          filePath: normalizedFile,
-          paramNames,
-          isDynamic,
-          isCatchAll: isCatchAll || void 0,
-          middlewares: middlewareBundle?.middlewares,
-          injectors: middlewareBundle?.injectors
-        });
-      }
-      continue;
-    }
+async function compileConfig(options) {
+  const { rootDir, outDir } = options;
+  const baseConfig = findBaseConfig(rootDir);
+  if (!baseConfig) {
+    return { generated: false, outputFile: "" };
   }
-  return { routes, wsRoutes };
-}
-var init_scanRoutes = __esm({
-  "src/router/scanRoutes.ts"() {
-    "use strict";
-    init_constants();
-    init_parseRouteFile();
-    init_loadMiddlewares();
-    init_importWithCacheBust();
+  const env = getEnv();
+  const envConfig = findEnvConfig(rootDir, env);
+  const imports = [`import base from './${baseConfig}';`];
+  let exportDefault;
+  if (envConfig) {
+    imports.push(`import env from './${envConfig}';`);
+    exportDefault = "export default deepMerge(base, env);";
+  } else {
+    exportDefault = "export default base;";
   }
-});
-
-// src/router/sortRoutes.ts
-function sortRoutes(routes) {
-  return [...routes].sort((a, b) => {
-    if (a.isDynamic !== b.isDynamic) {
-      return a.isDynamic ? 1 : -1;
-    }
-    if (a.isCatchAll !== b.isCatchAll) {
-      return a.isCatchAll ? 1 : -1;
-    }
-    const aSegments = a.urlPath.split("/").filter(Boolean).length;
-    const bSegments = b.urlPath.split("/").filter(Boolean).length;
-    if (aSegments !== bSegments) {
-      return aSegments - bSegments;
-    }
-    return a.urlPath.localeCompare(b.urlPath);
+  const entryCode = [...imports, DEEP_MERGE_SOURCE, exportDefault].join("\n");
+  const outputFile = path4.resolve(rootDir, outDir, "faapi-config.js");
+  await fs4.promises.mkdir(path4.dirname(outputFile), { recursive: true });
+  const esbuild = await import("esbuild");
+  await esbuild.build({
+    stdin: { contents: entryCode, resolveDir: rootDir, loader: "ts" },
+    outfile: outputFile,
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    sourcemap: true,
+    packages: "external",
+    logLevel: "silent"
   });
+  return { generated: true, outputFile };
 }
-var init_sortRoutes = __esm({
-  "src/router/sortRoutes.ts"() {
-    "use strict";
-  }
-});
-
-// src/router/detectRouteConflicts.ts
-function detectRouteConflicts(routes) {
-  const map = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    const key = `${route.method} ${route.urlPath}`;
-    const existing = map.get(key);
-    if (existing) {
-      existing.files.push(route.filePath);
-    } else {
-      map.set(key, {
-        method: route.method,
-        urlPath: route.urlPath,
-        files: [route.filePath]
-      });
-    }
-  }
-  const conflicts = [];
-  for (const conflict of map.values()) {
-    if (conflict.files.length > 1) {
-      conflicts.push(conflict);
-    }
-  }
-  return conflicts;
-}
-var init_detectRouteConflicts = __esm({
-  "src/router/detectRouteConflicts.ts"() {
+var BASE_CONFIG_FILES, ENV_CONFIG_EXTS;
+var init_compileConfig = __esm({
+  "src/cli/compileConfig.ts"() {
     "use strict";
+    init_deepMerge();
+    BASE_CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
+    ENV_CONFIG_EXTS = [".ts", ".js"];
   }
 });
 
 // src/ast/createProgram.ts
-import ts from "typescript";
+import ts2 from "typescript";
 function invalidateProgramCache() {
   programCache.clear();
 }
@@ -362,11 +288,11 @@ function createProgram(filePath) {
   if (cached) {
     return cached;
   }
-  const program = ts.createProgram([filePath], {
+  const program = ts2.createProgram([filePath], {
     strict: true,
-    target: ts.ScriptTarget.ES2022,
-    module: ts.ModuleKind.NodeNext,
-    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+    target: ts2.ScriptTarget.ES2022,
+    module: ts2.ModuleKind.NodeNext,
+    moduleResolution: ts2.ModuleResolutionKind.NodeNext,
     skipLibCheck: true,
     noEmit: true
   });
@@ -382,83 +308,83 @@ var init_createProgram = __esm({
 });
 
 // src/ast/resolveTypeNode.ts
-import ts2 from "typescript";
+import ts3 from "typescript";
 function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
   const kind = typeNode.kind;
   switch (kind) {
-    case ts2.SyntaxKind.StringKeyword:
+    case ts3.SyntaxKind.StringKeyword:
       return { kind: "string" };
-    case ts2.SyntaxKind.NumberKeyword:
+    case ts3.SyntaxKind.NumberKeyword:
       return { kind: "number" };
-    case ts2.SyntaxKind.BooleanKeyword:
+    case ts3.SyntaxKind.BooleanKeyword:
       return { kind: "boolean" };
-    case ts2.SyntaxKind.BigIntKeyword:
+    case ts3.SyntaxKind.BigIntKeyword:
       throw new SchemaExtractionError(
         typeNode.getText(),
         "bigint \u65E0\u6CD5\u901A\u8FC7 HTTP/JSON \u4F20\u8F93,\u8BF7\u6539\u7528 string \u6216 number"
       );
-    case ts2.SyntaxKind.SymbolKeyword:
+    case ts3.SyntaxKind.SymbolKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "symbol \u65E0\u6CD5\u901A\u8FC7 HTTP/JSON \u4F20\u8F93");
-    case ts2.SyntaxKind.NullKeyword:
+    case ts3.SyntaxKind.NullKeyword:
       return { kind: "null" };
-    case ts2.SyntaxKind.UndefinedKeyword:
+    case ts3.SyntaxKind.UndefinedKeyword:
       return { kind: "undefined" };
-    case ts2.SyntaxKind.UnknownKeyword:
+    case ts3.SyntaxKind.UnknownKeyword:
       return { kind: "any" };
-    case ts2.SyntaxKind.AnyKeyword:
+    case ts3.SyntaxKind.AnyKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "any \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528 unknown \u8868\u793A\u4E0D\u6821\u9A8C");
-    case ts2.SyntaxKind.VoidKeyword:
+    case ts3.SyntaxKind.VoidKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "void \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
-    case ts2.SyntaxKind.NeverKeyword:
+    case ts3.SyntaxKind.NeverKeyword:
       throw new SchemaExtractionError(typeNode.getText(), "never \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
-    case ts2.SyntaxKind.ObjectKeyword:
+    case ts3.SyntaxKind.ObjectKeyword:
       throw new SchemaExtractionError(
         typeNode.getText(),
         "object \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528\u5177\u4F53\u5BF9\u8C61\u7C7B\u578B\u6216 unknown"
       );
   }
-  if (ts2.isLiteralTypeNode(typeNode)) {
+  if (ts3.isLiteralTypeNode(typeNode)) {
     const literal = typeNode.literal;
-    if (ts2.isStringLiteral(literal)) {
+    if (ts3.isStringLiteral(literal)) {
       return { kind: "literal", value: literal.text };
     }
-    if (ts2.isNumericLiteral(literal)) {
+    if (ts3.isNumericLiteral(literal)) {
       return { kind: "literal", value: Number(literal.text) };
     }
-    if (literal.kind === ts2.SyntaxKind.TrueKeyword) {
+    if (literal.kind === ts3.SyntaxKind.TrueKeyword) {
       return { kind: "literal", value: true };
     }
-    if (literal.kind === ts2.SyntaxKind.FalseKeyword) {
+    if (literal.kind === ts3.SyntaxKind.FalseKeyword) {
       return { kind: "literal", value: false };
     }
-    if (literal.kind === ts2.SyntaxKind.NullKeyword) {
+    if (literal.kind === ts3.SyntaxKind.NullKeyword) {
       return { kind: "null" };
     }
     throw new SchemaExtractionError(typeNode.getText(), "\u4E0D\u652F\u6301\u7684\u5B57\u9762\u91CF\u7C7B\u578B");
   }
-  if (ts2.isArrayTypeNode(typeNode)) {
+  if (ts3.isArrayTypeNode(typeNode)) {
     return {
       kind: "array",
       element: resolveTypeNode(typeNode.elementType, checker, visited)
     };
   }
-  if (ts2.isTupleTypeNode(typeNode)) {
+  if (ts3.isTupleTypeNode(typeNode)) {
     const elements = typeNode.elements.map((e) => {
-      if (ts2.isRestTypeNode(e)) {
+      if (ts3.isRestTypeNode(e)) {
         const inner = resolveTypeNode(e.type, checker, visited);
         if (inner.kind === "array") {
           return { type: inner.element, optional: false, rest: true };
         }
         return { type: inner, optional: false, rest: true };
       }
-      if (ts2.isNamedTupleMember(e)) {
+      if (ts3.isNamedTupleMember(e)) {
         return {
           type: resolveTypeNode(e.type, checker, visited),
           optional: !!e.questionToken,
           rest: false
         };
       }
-      if (ts2.isOptionalTypeNode(e)) {
+      if (ts3.isOptionalTypeNode(e)) {
         return {
           type: resolveTypeNode(e.type, checker, visited),
           optional: true,
@@ -473,11 +399,11 @@ function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set())
     });
     return { kind: "tuple", elements };
   }
-  if (ts2.isUnionTypeNode(typeNode)) {
+  if (ts3.isUnionTypeNode(typeNode)) {
     const members = typeNode.types.map((t) => resolveTypeNode(t, checker, visited));
     return { kind: "union", members };
   }
-  if (ts2.isIntersectionTypeNode(typeNode)) {
+  if (ts3.isIntersectionTypeNode(typeNode)) {
     const properties = [];
     for (const t of typeNode.types) {
       const resolved = resolveTypeNode(t, checker, visited);
@@ -487,13 +413,16 @@ function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set())
     }
     return { kind: "object", properties };
   }
-  if (ts2.isTypeLiteralNode(typeNode)) {
+  if (ts3.isTypeLiteralNode(typeNode)) {
     return resolveTypeLiteral(typeNode, checker, visited);
   }
-  if (ts2.isTypeOperatorNode(typeNode) && typeNode.operator === ts2.SyntaxKind.KeyOfKeyword) {
+  if (ts3.isTypeOperatorNode(typeNode) && typeNode.operator === ts3.SyntaxKind.KeyOfKeyword) {
     return resolveKeyOf(typeNode, checker);
   }
-  if (ts2.isTypeReferenceNode(typeNode)) {
+  if (ts3.isTypeOperatorNode(typeNode) && typeNode.operator === ts3.SyntaxKind.ReadonlyKeyword) {
+    return resolveTypeNode(typeNode.type, checker, visited);
+  }
+  if (ts3.isTypeReferenceNode(typeNode)) {
     return resolveTypeReference(typeNode, checker, visited);
   }
   throw new SchemaExtractionError(typeNode.getText(), "\u4E0D\u652F\u6301\u7684\u7C7B\u578B\u8BED\u6CD5");
@@ -501,13 +430,17 @@ function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set())
 function resolveTypeLiteral(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
   const properties = [];
   for (const member of typeNode.members) {
-    if (ts2.isPropertySignature(member) && member.name) {
+    if (ts3.isPropertySignature(member) && member.name) {
       const name = member.name.getText();
       const optional = !!member.questionToken;
       const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
-      properties.push({ name, type, optional });
+      const constraints = extractConstraintsFromJsDoc(member, name);
+      validateConstraints(constraints, type, name);
+      properties.push(
+        constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
+      );
     }
-    if (ts2.isIndexSignatureDeclaration(member)) {
+    if (ts3.isIndexSignatureDeclaration(member)) {
       const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
       const valueType = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
       return { kind: "record", key: keyType, value: valueType };
@@ -587,7 +520,7 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
   if (typeName === "Date") {
     return { kind: "date" };
   }
-  if (typeName === "Array" && typeNode.typeArguments?.length === 1) {
+  if ((typeName === "Array" || typeName === "ReadonlyArray") && typeNode.typeArguments?.length === 1) {
     return {
       kind: "array",
       element: resolveTypeNode(typeNode.typeArguments[0], checker, visited)
@@ -650,17 +583,17 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
   }
   visited.add(typeName);
   if (checker) {
-    const symbol = typeNode.typeName.kind === ts2.SyntaxKind.Identifier ? checker.getSymbolAtLocation(typeNode.typeName) : void 0;
+    const symbol = typeNode.typeName.kind === ts3.SyntaxKind.Identifier ? checker.getSymbolAtLocation(typeNode.typeName) : void 0;
     if (symbol) {
       const declaration = symbol.declarations?.[0];
       if (declaration) {
-        if (ts2.isInterfaceDeclaration(declaration)) {
+        if (ts3.isInterfaceDeclaration(declaration)) {
           return resolveInterfaceDeclaration(declaration, checker, visited);
         }
-        if (ts2.isTypeAliasDeclaration(declaration)) {
+        if (ts3.isTypeAliasDeclaration(declaration)) {
           return resolveTypeNode(declaration.type, checker, visited);
         }
-        if (ts2.isEnumDeclaration(declaration)) {
+        if (ts3.isEnumDeclaration(declaration)) {
           return resolveEnumDeclaration(declaration);
         }
       }
@@ -673,9 +606,9 @@ function resolveEnumDeclaration(node) {
   let nextNumericValue = 0;
   for (const member of node.members) {
     if (member.initializer) {
-      if (ts2.isStringLiteral(member.initializer)) {
+      if (ts3.isStringLiteral(member.initializer)) {
         members.push({ kind: "literal", value: member.initializer.text });
-      } else if (ts2.isNumericLiteral(member.initializer)) {
+      } else if (ts3.isNumericLiteral(member.initializer)) {
         const num = Number(member.initializer.text);
         members.push({ kind: "literal", value: num });
         nextNumericValue = num + 1;
@@ -696,7 +629,7 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
   const properties = [];
   const propMap = /* @__PURE__ */ new Map();
   for (const heritageClause of node.heritageClauses ?? []) {
-    if (heritageClause.token === ts2.SyntaxKind.ExtendsKeyword) {
+    if (heritageClause.token === ts3.SyntaxKind.ExtendsKeyword) {
       for (const expr of heritageClause.types) {
         const parentType = resolveTypeNode(expr, checker, visited);
         if (parentType.kind === "object") {
@@ -708,13 +641,18 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
     }
   }
   for (const member of node.members) {
-    if (ts2.isPropertySignature(member) && member.name) {
+    if (ts3.isPropertySignature(member) && member.name) {
       const name = member.name.getText();
       const optional = !!member.questionToken;
       const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
-      propMap.set(name, { name, type, optional });
+      const constraints = extractConstraintsFromJsDoc(member, name);
+      validateConstraints(constraints, type, name);
+      propMap.set(
+        name,
+        constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
+      );
     }
-    if (ts2.isIndexSignatureDeclaration(member)) {
+    if (ts3.isIndexSignatureDeclaration(member)) {
       const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
       const valueType = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
       return { kind: "record", key: keyType, value: valueType };
@@ -725,33 +663,169 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
   }
   return { kind: "object", properties };
 }
-var SchemaExtractionError;
-var init_resolveTypeNode = __esm({
-  "src/ast/resolveTypeNode.ts"() {
-    "use strict";
-    SchemaExtractionError = class extends Error {
-      constructor(typeText, reason, options) {
-        super(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B "${typeText}": ${reason}`, options);
-        this.typeText = typeText;
+function extractConstraintsFromJsDoc(node, fieldName) {
+  const jsDocs = ts3.getJSDocCommentsAndTags(node).filter((entry) => ts3.isJSDoc(entry));
+  if (jsDocs.length === 0) return [];
+  const constraints = [];
+  for (const jsDoc of jsDocs) {
+    if (!jsDoc.tags) continue;
+    for (const tag of jsDoc.tags) {
+      const constraint = parseJsDocTag(tag, fieldName);
+      if (constraint) constraints.push(constraint);
+    }
+  }
+  return constraints;
+}
+function getTagCommentText(tag) {
+  const comment = tag.comment;
+  if (typeof comment === "string") return comment;
+  return void 0;
+}
+function parseJsDocTag(tag, fieldName) {
+  const tagName = tag.tagName.text;
+  switch (tagName) {
+    // 数值约束（带值）
+    case "max":
+    case "min": {
+      const value = parseNumberValue(tag, fieldName, tagName);
+      return { kind: tagName, value };
+    }
+    // 长度约束（带值）
+    case "maxLength":
+    case "minLength":
+    case "length": {
+      const value = parseNumberValue(tag, fieldName, tagName);
+      return { kind: tagName, value };
+    }
+    // 正则约束（带 /pattern/flags 值）
+    case "regex":
+    case "pattern": {
+      const text = getTagCommentText(tag);
+      if (!text) {
+        throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u9700\u8981 /pattern/flags \u5F62\u5F0F\u7684\u503C`);
+      }
+      const regex = parseRegexLiteral(text.trim(), fieldName);
+      return { kind: "regex", pattern: regex.pattern, flags: regex.flags };
+    }
+    // 数值约束（无值）
+    case "int":
+    case "positive":
+    case "negative":
+    case "nonnegative":
+    case "nonpositive":
+      return { kind: tagName };
+    // 字符串格式约束（无值）
+    case "email":
+    case "url":
+    case "uuid":
+      return { kind: tagName };
+    default:
+      return null;
+  }
+}
+function parseNumberValue(tag, fieldName, tagName) {
+  const text = getTagCommentText(tag);
+  if (!text) {
+    throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u9700\u8981\u4E00\u4E2A\u6570\u5B57\u503C`);
+  }
+  const trimmed = text.trim();
+  const num = Number(trimmed);
+  if (!Number.isFinite(num)) {
+    throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u7684\u503C "${trimmed}" \u4E0D\u662F\u6709\u6548\u6570\u5B57`);
+  }
+  return num;
+}
+function parseRegexLiteral(text, fieldName) {
+  const match = /^\/(.+)\/([gimsuy]*)$/.exec(text);
+  if (!match) {
+    throw new SchemaExtractionError(fieldName, `\u6B63\u5219\u503C "${text}" \u4E0D\u662F /pattern/flags \u5F62\u5F0F`);
+  }
+  const [, pattern, flags] = match;
+  if (!pattern) {
+    throw new SchemaExtractionError(fieldName, `\u6B63\u5219\u503C "${text}" \u7684 pattern \u90E8\u5206\u4E3A\u7A7A`);
+  }
+  return flags ? { pattern, flags } : { pattern };
+}
+function validateConstraints(constraints, type, fieldName) {
+  if (constraints.length === 0) return;
+  for (const constraint of constraints) {
+    const kind = constraint.kind;
+    if (NUMBER_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "number") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E number \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+    if (LENGTH_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "string" && type.kind !== "array") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E string \u6216 array \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+    if (STRING_FORMAT_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "string") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E string \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+  }
+}
+var SchemaExtractionError, NUMBER_CONSTRAINT_KINDS, LENGTH_CONSTRAINT_KINDS, STRING_FORMAT_CONSTRAINT_KINDS;
+var init_resolveTypeNode = __esm({
+  "src/ast/resolveTypeNode.ts"() {
+    "use strict";
+    SchemaExtractionError = class extends Error {
+      constructor(typeText, reason, options) {
+        super(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B "${typeText}": ${reason}`, options);
+        this.typeText = typeText;
         this.reason = reason;
         this.name = "SchemaExtractionError";
       }
       typeText;
       reason;
     };
+    NUMBER_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
+      "max",
+      "min",
+      "int",
+      "positive",
+      "negative",
+      "nonnegative",
+      "nonpositive"
+    ]);
+    LENGTH_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
+      "maxLength",
+      "minLength",
+      "length"
+    ]);
+    STRING_FORMAT_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
+      "regex",
+      "email",
+      "url",
+      "uuid"
+    ]);
   }
 });
 
 // src/ast/extractHandlerTypes.ts
-import ts3 from "typescript";
+import ts4 from "typescript";
 function extractTypeInfo(program, filePath, typeName) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
   const checker = program.getTypeChecker();
   let result = null;
-  ts3.forEachChild(sourceFile, (node) => {
+  ts4.forEachChild(sourceFile, (node) => {
     if (result) return;
-    if (ts3.isInterfaceDeclaration(node) && node.name.text === typeName) {
+    if (ts4.isInterfaceDeclaration(node) && node.name.text === typeName) {
       const visited = /* @__PURE__ */ new Set();
       visited.add(typeName);
       const runtimeType = withFileContext(
@@ -766,7 +840,7 @@ function extractTypeInfo(program, filePath, typeName) {
       };
       return;
     }
-    if (ts3.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+    if (ts4.isTypeAliasDeclaration(node) && node.name.text === typeName) {
       const visited = /* @__PURE__ */ new Set();
       visited.add(typeName);
       const runtimeType = withFileContext(
@@ -789,8 +863,8 @@ function extractAllTypes(program, filePath) {
   if (!sourceFile) return /* @__PURE__ */ new Map();
   const checker = program.getTypeChecker();
   const result = /* @__PURE__ */ new Map();
-  ts3.forEachChild(sourceFile, (node) => {
-    if (ts3.isInterfaceDeclaration(node)) {
+  ts4.forEachChild(sourceFile, (node) => {
+    if (ts4.isInterfaceDeclaration(node)) {
       const visited = /* @__PURE__ */ new Set();
       visited.add(node.name.text);
       const runtimeType = withFileContext(
@@ -805,7 +879,7 @@ function extractAllTypes(program, filePath) {
       });
       return;
     }
-    if (ts3.isTypeAliasDeclaration(node)) {
+    if (ts4.isTypeAliasDeclaration(node)) {
       const visited = /* @__PURE__ */ new Set();
       visited.add(node.name.text);
       const runtimeType = withFileContext(
@@ -875,7 +949,7 @@ var init_schemaName = __esm({
 });
 
 // src/injection/resolveInjection.ts
-import ts4 from "typescript";
+import ts5 from "typescript";
 function resolveInjection(fn) {
   const fnStr = fn.toString();
   const params = extractParamsWithAst(fnStr);
@@ -890,53 +964,53 @@ function resolveInjection(fn) {
   });
 }
 function extractParamsWithAst(fnStr) {
-  const sourceFile = ts4.createSourceFile(
+  const sourceFile = ts5.createSourceFile(
     "__faapi_injection__.ts",
     fnStr,
-    ts4.ScriptTarget.Latest,
+    ts5.ScriptTarget.Latest,
     true
   );
   const paramNames = [];
   function visit(node) {
-    if (ts4.isFunctionDeclaration(node) && node.parameters.length > 0) {
+    if (ts5.isFunctionDeclaration(node) && node.parameters.length > 0) {
       for (const param of node.parameters) {
         extractParamName(param, paramNames);
       }
       return;
     }
-    if ((ts4.isArrowFunction(node) || ts4.isFunctionExpression(node)) && node.parameters.length > 0) {
+    if ((ts5.isArrowFunction(node) || ts5.isFunctionExpression(node)) && node.parameters.length > 0) {
       for (const param of node.parameters) {
         extractParamName(param, paramNames);
       }
       return;
     }
-    ts4.forEachChild(node, visit);
+    ts5.forEachChild(node, visit);
   }
   visit(sourceFile);
   return paramNames.map((name) => ({ name }));
 }
 function extractParamName(param, names) {
   const name = param.name;
-  if (ts4.isIdentifier(name)) {
+  if (ts5.isIdentifier(name)) {
     names.push(name.text);
     return;
   }
-  if (ts4.isObjectBindingPattern(name)) {
+  if (ts5.isObjectBindingPattern(name)) {
     for (const element of name.elements) {
-      if (ts4.isBindingElement(element)) {
+      if (ts5.isBindingElement(element)) {
         const elemName = element.name;
-        if (ts4.isIdentifier(elemName)) {
+        if (ts5.isIdentifier(elemName)) {
           names.push(elemName.text);
         }
       }
     }
     return;
   }
-  if (ts4.isArrayBindingPattern(name)) {
+  if (ts5.isArrayBindingPattern(name)) {
     for (const element of name.elements) {
-      if (element && ts4.isBindingElement(element)) {
+      if (element && ts5.isBindingElement(element)) {
         const elemName = element.name;
-        if (ts4.isIdentifier(elemName)) {
+        if (ts5.isIdentifier(elemName)) {
           names.push(elemName.text);
         }
       }
@@ -965,12 +1039,12 @@ var init_resolveInjection = __esm({
 });
 
 // src/injection/analyzeInjection.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 function analyzeInjection(code, functionName) {
-  const sourceFile = ts5.createSourceFile("temp.ts", code, ts5.ScriptTarget.Latest, true);
+  const sourceFile = ts6.createSourceFile("temp.ts", code, ts6.ScriptTarget.Latest, true);
   const params = [];
-  ts5.forEachChild(sourceFile, (node) => {
-    if (ts5.isFunctionDeclaration(node) && node.name?.text === functionName) {
+  ts6.forEachChild(sourceFile, (node) => {
+    if (ts6.isFunctionDeclaration(node) && node.name?.text === functionName) {
       for (const param of node.parameters) {
         const paramMeta = analyzeParam(param, sourceFile);
         params.push(paramMeta);
@@ -984,9 +1058,9 @@ function analyzeParam(param, sourceFile) {
   const type = PARAM_TYPE_MAP[name] || "unknown";
   const result = { name, type };
   if (param.type) {
-    if (ts5.isTypeReferenceNode(param.type)) {
+    if (ts6.isTypeReferenceNode(param.type)) {
       result.typeName = param.type.typeName.getText(sourceFile);
-    } else if (ts5.isTypeLiteralNode(param.type)) {
+    } else if (ts6.isTypeLiteralNode(param.type)) {
       result.schema = extractSchema(param.type, sourceFile);
     }
   }
@@ -995,7 +1069,7 @@ function analyzeParam(param, sourceFile) {
 function extractSchema(typeNode, sourceFile) {
   const schema = [];
   for (const member of typeNode.members) {
-    if (ts5.isPropertySignature(member) && member.name && ts5.isIdentifier(member.name)) {
+    if (ts6.isPropertySignature(member) && member.name && ts6.isIdentifier(member.name)) {
       const propName = member.name.text;
       const optional = !!member.questionToken;
       const propType = member.type?.getText(sourceFile) || "unknown";
@@ -1016,11 +1090,11 @@ var init_analyzeInjection = __esm({
 });
 
 // src/cli/collectRouteSchemaSources.ts
-import path2 from "path";
+import path5 from "path";
 function collectRouteSchemaSources(routes, rootDir) {
   const methodsByFile = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    const filePath = rootDir ? path2.resolve(rootDir, route.filePath) : route.filePath;
+    const filePath = rootDir ? path5.resolve(rootDir, route.filePath) : route.filePath;
     let entry = methodsByFile.get(filePath);
     if (!entry) {
       entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
@@ -1115,12 +1189,51 @@ function collectNamedTypes(type, ctx) {
     }
   }
 }
-function runtimeTypeToZodExpression(type, ctx) {
+function runtimeTypeToZodExpression(type, ctx, constraints) {
   const expr = baseExpression(type, ctx);
+  const withConstraints = constraints && constraints.length > 0 ? applyConstraints(expr, constraints, type.kind) : expr;
   if (ctx.coerce && (type.kind === "number" || type.kind === "boolean")) {
-    return wrapCoercePreprocess(type.kind, expr);
+    return wrapCoercePreprocess(type.kind, withConstraints);
+  }
+  return withConstraints;
+}
+function applyConstraints(baseExpr, constraints, typeKind) {
+  const suffix = constraints.map((c) => constraintToZodChain(c, typeKind)).join("");
+  return `${baseExpr}${suffix}`;
+}
+function constraintToZodChain(constraint, _typeKind) {
+  switch (constraint.kind) {
+    case "max":
+      return `.max(${constraint.value})`;
+    case "min":
+      return `.min(${constraint.value})`;
+    case "int":
+      return ".int()";
+    case "positive":
+      return ".positive()";
+    case "negative":
+      return ".negative()";
+    case "nonnegative":
+      return ".nonnegative()";
+    case "nonpositive":
+      return ".nonpositive()";
+    case "maxLength":
+      return `.max(${constraint.value})`;
+    case "minLength":
+      return `.min(${constraint.value})`;
+    case "length":
+      return `.length(${constraint.value})`;
+    case "regex": {
+      const flags = constraint.flags ?? "";
+      return `.regex(new RegExp(${JSON.stringify(constraint.pattern)}${flags ? `, ${JSON.stringify(flags)}` : ""}))`;
+    }
+    case "email":
+      return ".email()";
+    case "url":
+      return ".url()";
+    case "uuid":
+      return ".uuid()";
   }
-  return expr;
 }
 function baseExpression(type, ctx) {
   switch (type.kind) {
@@ -1215,8 +1328,9 @@ function generateTupleExpression(elements, ctx) {
 }
 function generateObjectExpression(properties, ctx) {
   const fields = properties.map((prop) => {
-    const expr = runtimeTypeToZodExpression(prop.type, ctx);
-    return `${JSON.stringify(prop.name)}: ${prop.optional ? `${expr}.optional()` : expr}`;
+    const expr = runtimeTypeToZodExpression(prop.type, ctx, prop.constraints);
+    const finalExpr = prop.optional ? `${expr}.optional()` : expr;
+    return `${JSON.stringify(prop.name)}: ${finalExpr}`;
   });
   return `z.object({ ${fields.join(", ")} })`;
 }
@@ -1314,8 +1428,8 @@ var init_generateZodSchema = __esm({
 });
 
 // src/cli/generateSchemaFiles.ts
-import path3 from "path";
-import fs2 from "fs/promises";
+import path6 from "path";
+import fs5 from "fs/promises";
 function getSchemaOutputPath(sourceFile, appDir, outDir, rootDir) {
   let rel = sourceFile.replace(/\\/g, "/");
   if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
@@ -1323,7 +1437,7 @@ function getSchemaOutputPath(sourceFile, appDir, outDir, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path3.resolve(rootDir, outDir, relDir, "zod.js");
+  return path6.resolve(rootDir, outDir, relDir, "zod.js");
 }
 function getRuntimeSchemaPath(filePath, appDir, outDir, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -1334,7 +1448,7 @@ function getRuntimeSchemaPath(filePath, appDir, outDir, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path3.resolve(rootDir, outDir, relDir, "zod.js");
+  return path6.resolve(rootDir, outDir, relDir, "zod.js");
 }
 function getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -1382,7 +1496,7 @@ async function generateSchemaFiles(routes, rootDir, appDir, outDir) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path3.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path6.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getSchemaOutputPath(relFile, appDir, outDir, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
@@ -1397,7 +1511,7 @@ async function generateSchemaFiles(routes, rootDir, appDir, outDir) {
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path3.resolve(rootDir, outDir, HELPERS_FILENAME);
+    const helpersPath = path6.resolve(rootDir, outDir, HELPERS_FILENAME);
     await writeSchemaFile(helpersPath, generateHelpersFileSource());
   }
   await Promise.all(
@@ -1405,8 +1519,8 @@ async function generateSchemaFiles(routes, rootDir, appDir, outDir) {
   );
 }
 async function writeSchemaFile(outputPath, source) {
-  await fs2.mkdir(path3.dirname(outputPath), { recursive: true });
-  await fs2.writeFile(outputPath, source, "utf-8");
+  await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+  await fs5.writeFile(outputPath, source, "utf-8");
 }
 var init_generateSchemaFiles = __esm({
   "src/cli/generateSchemaFiles.ts"() {
@@ -1416,9 +1530,80 @@ var init_generateSchemaFiles = __esm({
   }
 });
 
+// src/utils/importWithCacheBust.ts
+import { pathToFileURL } from "url";
+function setLoadTimestamp(ts7) {
+  loadTs = ts7;
+}
+async function importWithCacheBust(filePath) {
+  let url = pathToFileURL(filePath).href;
+  if (loadTs !== void 0) {
+    url += `?t=${loadTs}`;
+  }
+  return await import(url);
+}
+var loadTs;
+var init_importWithCacheBust = __esm({
+  "src/utils/importWithCacheBust.ts"() {
+    "use strict";
+  }
+});
+
+// src/middleware/loadMiddlewares.ts
+function invalidateMiddlewareCache() {
+  middlewareCache.clear();
+}
+function getCachedMiddlewares(absPath) {
+  return middlewareCache.get(absPath);
+}
+function setCachedMiddlewares(absPath, bundle) {
+  middlewareCache.set(absPath, bundle);
+}
+async function loadMiddlewaresFile(filePath) {
+  try {
+    const module = await importWithCacheBust(filePath);
+    const middlewares = module.default ?? module.middlewares ?? [];
+    if (!Array.isArray(middlewares)) {
+      console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+      return { middlewares: [], injectors: {} };
+    }
+    const validMiddlewares = middlewares.filter((m) => {
+      if (typeof m !== "function") {
+        console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
+        return false;
+      }
+      return true;
+    });
+    const injectors = module.injectors ?? {};
+    if (typeof injectors !== "object" || injectors === null) {
+      console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+      return { middlewares: validMiddlewares, injectors: {} };
+    }
+    const validInjectors = {};
+    for (const [name, injector] of Object.entries(injectors)) {
+      if (typeof injector !== "function") {
+        console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
+        continue;
+      }
+      validInjectors[name] = injector;
+    }
+    return { middlewares: validMiddlewares, injectors: validInjectors };
+  } catch {
+    return { middlewares: [], injectors: {} };
+  }
+}
+var middlewareCache;
+var init_loadMiddlewares = __esm({
+  "src/middleware/loadMiddlewares.ts"() {
+    "use strict";
+    init_importWithCacheBust();
+    middlewareCache = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/cli/generateRoutes.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path7 from "path";
 function toProdFilePath(filePath, appDir, prodDir) {
   let rel = filePath.replace(/\\/g, "/");
   if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
@@ -1449,23 +1634,23 @@ function serializeRoutes(routes, wsRoutes, rootDir, appDir = "src", prodDir = "d
   };
 }
 function extractMiddlewarePaths(routeFilePath, rootDir, appDir, prodDir) {
-  const routeDir = path4.dirname(routeFilePath);
-  const resolvedRoot = path4.resolve(rootDir);
+  const routeDir = path7.dirname(routeFilePath);
+  const resolvedRoot = path7.resolve(rootDir);
   const paths = [];
-  let currentDir = path4.resolve(rootDir, routeDir);
+  let currentDir = path7.resolve(rootDir, routeDir);
   while (true) {
-    const mwTsPath = path4.join(currentDir, "middlewares.ts");
-    const mwJsPath = path4.join(currentDir, "middlewares.js");
-    const absTsPath = path4.resolve(rootDir, mwTsPath);
-    const absJsPath = path4.resolve(rootDir, mwJsPath);
-    const absMwPath = fs3.existsSync(absTsPath) ? absTsPath : fs3.existsSync(absJsPath) ? absJsPath : null;
+    const mwTsPath = path7.join(currentDir, "middlewares.ts");
+    const mwJsPath = path7.join(currentDir, "middlewares.js");
+    const absTsPath = path7.resolve(rootDir, mwTsPath);
+    const absJsPath = path7.resolve(rootDir, mwJsPath);
+    const absMwPath = fs6.existsSync(absTsPath) ? absTsPath : fs6.existsSync(absJsPath) ? absJsPath : null;
     if (absMwPath) {
-      const relMwPath = path4.relative(rootDir, absMwPath);
-      const prodAbsPath = path4.resolve(rootDir, toProdFilePath(relMwPath, appDir, prodDir));
+      const relMwPath = path7.relative(rootDir, absMwPath);
+      const prodAbsPath = path7.resolve(rootDir, toProdFilePath(relMwPath, appDir, prodDir));
       paths.push(prodAbsPath);
     }
     if (currentDir === resolvedRoot) break;
-    const parentDir = path4.dirname(currentDir);
+    const parentDir = path7.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -1473,13 +1658,13 @@ function extractMiddlewarePaths(routeFilePath, rootDir, appDir, prodDir) {
   return paths;
 }
 async function writeRoutesModule(manifest, outputPath) {
-  const dir = path4.dirname(outputPath);
-  await fs3.promises.mkdir(dir, { recursive: true });
+  const dir = path7.dirname(outputPath);
+  await fs6.promises.mkdir(dir, { recursive: true });
   const content = `// \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91\uFF08faapi build \u4EA7\u7269\uFF09
 export const routes = ${JSON.stringify(manifest.routes, null, 2)};
 export const wsRoutes = ${JSON.stringify(manifest.wsRoutes, null, 2)};
 `;
-  await fs3.promises.writeFile(outputPath, content, "utf-8");
+  await fs6.promises.writeFile(outputPath, content, "utf-8");
 }
 async function hydrateRoutes(manifest) {
   const hydrateRoute = async (serialized) => {
@@ -1535,281 +1720,249 @@ var init_generateRoutes = __esm({
   }
 });
 
-// src/utils/resolveAlias.ts
-function resolveAlias(specifier, config) {
-  const candidates = [];
-  for (const [pattern, targets] of Object.entries(config.paths)) {
-    const wildcardIndex = pattern.indexOf("*");
-    if (wildcardIndex === -1) {
-      if (specifier === pattern) {
-        candidates.push(...targets);
-      }
-      continue;
-    }
-    const prefix = pattern.slice(0, wildcardIndex);
-    const suffix = pattern.slice(wildcardIndex + 1);
-    if (specifier.startsWith(prefix) && specifier.endsWith(suffix) && specifier.length >= prefix.length + suffix.length) {
-      const captured = specifier.slice(prefix.length, specifier.length - suffix.length);
-      for (const target of targets) {
-        candidates.push(target.replace("*", captured));
-      }
-    }
-  }
-  return candidates;
+// src/router/constants.ts
+function isHttpMethod(value) {
+  return HTTP_METHOD_SET.has(value);
 }
-var init_resolveAlias = __esm({
-  "src/utils/resolveAlias.ts"() {
+var HTTP_METHODS, HTTP_METHOD_SET;
+var init_constants = __esm({
+  "src/router/constants.ts"() {
     "use strict";
+    HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+    HTTP_METHOD_SET = new Set(HTTP_METHODS);
   }
 });
 
-// src/utils/readTsconfig.ts
-import ts6 from "typescript";
-import path5 from "path";
-import fs4 from "fs";
-function readTsconfig(rootDir) {
-  const tsconfigPath = path5.resolve(rootDir, "tsconfig.json");
-  if (!fs4.existsSync(tsconfigPath)) return null;
-  const configFile = ts6.readConfigFile(tsconfigPath, ts6.sys.readFile);
-  if (configFile.error || !configFile.config) return null;
-  const parsed = ts6.parseJsonConfigFileContent(configFile.config, ts6.sys, rootDir);
-  const baseUrl = parsed.options.baseUrl ?? rootDir;
-  const rawPaths = parsed.options.paths;
-  if (!rawPaths) return null;
-  const paths = {};
-  for (const [pattern, targets] of Object.entries(rawPaths)) {
-    paths[pattern] = targets.map((t) => path5.resolve(baseUrl, t));
+// src/utils/normalizePath.ts
+function normalizePath(path17) {
+  if (!path17) return "";
+  let result = path17.replace(/\\/g, "/");
+  result = result.replace(/\/+/g, "/");
+  result = result.replace(/\/+$/, "");
+  if (result && !result.startsWith("/")) {
+    result = "/" + result;
   }
-  return { baseUrl, paths };
+  return result;
 }
-var init_readTsconfig = __esm({
-  "src/utils/readTsconfig.ts"() {
+var init_normalizePath = __esm({
+  "src/utils/normalizePath.ts"() {
     "use strict";
   }
 });
 
-// src/cli/aliasPlugin.ts
-import path6 from "path";
-import fs5 from "fs";
-function toProdExtension(filePath) {
-  if (filePath.endsWith(".ts")) return filePath.slice(0, -3) + ".js";
-  if (filePath.endsWith(".tsx")) return filePath.slice(0, -4) + ".js";
-  if (filePath.endsWith(".jsx")) return filePath.slice(0, -4) + ".js";
-  return filePath;
-}
-function toProdImportPath(sourceFile, importer) {
-  const importerDir = path6.dirname(importer);
-  let rel = path6.relative(importerDir, sourceFile);
-  rel = rel.split(path6.sep).join("/");
-  if (!rel.startsWith(".")) rel = "./" + rel;
-  return toProdExtension(rel);
+// src/router/parseRouteFile.ts
+function dynamicSegmentToParam(segment) {
+  const match = segment.match(/^\[(.+)\]$/);
+  if (match) {
+    return ":" + match[1];
+  }
+  return segment;
 }
-function createAliasPlugin(config) {
-  const EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-  const INDEX_EXTS = [
-    "/index.ts",
-    "/index.tsx",
-    "/index.js",
-    "/index.jsx",
-    "/index.mjs",
-    "/index.cjs"
-  ];
-  const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
-  return {
-    name: "faapi-alias",
-    setup(build) {
-      build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
-        let source;
-        try {
-          source = fs5.readFileSync(args.path, "utf8");
-        } catch {
-          return void 0;
-        }
-        const importer = args.path;
-        let modified = false;
-        const newSource = source.replace(SPEC_RE, (full, prefix, quote, specifier) => {
-          if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("file:") || specifier.startsWith("node:")) {
-            return full;
-          }
-          const candidates = resolveAlias(specifier, config);
-          for (const candidate of candidates) {
-            for (const ext of EXTS) {
-              const file = candidate + ext;
-              if (fs5.existsSync(file)) {
-                modified = true;
-                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
-              }
-            }
-            for (const indexExt of INDEX_EXTS) {
-              const file = candidate + indexExt;
-              if (fs5.existsSync(file)) {
-                modified = true;
-                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
-              }
-            }
-          }
-          return full;
-        });
-        if (!modified) return void 0;
-        return { contents: newSource, loader: "default" };
-      });
+function extractParamNames(urlPath) {
+  const params = [];
+  const segments = urlPath.split("/");
+  for (const segment of segments) {
+    if (segment.startsWith(":...")) {
+      params.push(segment.slice(4));
+    } else if (segment.startsWith(":")) {
+      params.push(segment.slice(1));
     }
-  };
+  }
+  return params;
 }
-function buildAliasPlugins(rootDir) {
-  const tsconfig = readTsconfig(rootDir);
-  return tsconfig ? [createAliasPlugin(tsconfig)] : [];
+function isCatchAllSegment(segment) {
+  return /^\[\.\.\..+\]$/.test(segment);
 }
-var init_aliasPlugin = __esm({
-  "src/cli/aliasPlugin.ts"() {
-    "use strict";
-    init_resolveAlias();
-    init_readTsconfig();
-  }
-});
-
-// src/cli/compileBuildRoutes.ts
-import path7 from "path";
-import fs6 from "fs";
-async function compileBuildRoutes(options) {
-  const {
-    rootDir,
-    appDir,
-    outDir,
-    entries,
-    splitting = true,
-    define,
-    minifySyntax = true,
-    logLevel = "silent"
-  } = options;
-  if (entries.length === 0) {
-    return { compiledFiles: [] };
-  }
-  const absOutDir = path7.resolve(rootDir, outDir);
-  await fs6.promises.mkdir(absOutDir, { recursive: true });
-  const plugins = buildAliasPlugins(rootDir);
-  const esbuild = await import("esbuild");
-  const outbase = appDir === "." ? rootDir : path7.resolve(rootDir, appDir);
-  await esbuild.build({
-    entryPoints: entries,
-    outdir: absOutDir,
-    outbase,
-    bundle: true,
-    splitting,
-    platform: "node",
-    format: "esm",
-    sourcemap: true,
-    packages: "external",
-    plugins,
-    define,
-    minifySyntax,
-    logLevel
-  });
-  return { compiledFiles: entries };
+function isRouteGroup(segment) {
+  return /^\(.+\)$/.test(segment);
 }
-var init_compileBuildRoutes = __esm({
-  "src/cli/compileBuildRoutes.ts"() {
-    "use strict";
-    init_aliasPlugin();
-  }
-});
-
-// src/config/deepMerge.ts
-function deepMerge(base, override) {
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    const baseVal = base[key];
-    const overVal = override[key];
-    if (baseVal instanceof Date || overVal instanceof Date || baseVal instanceof RegExp || overVal instanceof RegExp || baseVal instanceof Map || overVal instanceof Map || baseVal instanceof Set || overVal instanceof Set) {
-      result[key] = overVal;
-      continue;
-    }
-    if (baseVal !== null && overVal !== null && typeof baseVal === "object" && typeof overVal === "object" && !Array.isArray(baseVal) && !Array.isArray(overVal) && !(baseVal instanceof Function) && !(overVal instanceof Function)) {
-      result[key] = deepMerge(
-        baseVal,
-        overVal
-      );
-    } else {
-      result[key] = overVal;
-    }
+function filePathToUrlPath(filePath, appDir = ".") {
+  const withoutPrefix = filePath.startsWith(appDir + "/") ? filePath.slice(appDir.length + 1) : filePath;
+  const lastSlashIndex = withoutPrefix.lastIndexOf("/");
+  const dirPath = lastSlashIndex === -1 ? "" : withoutPrefix.slice(0, lastSlashIndex);
+  if (!dirPath) {
+    return "";
   }
-  return result;
+  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
+  return normalizePath(segments.join("/"));
 }
-var DEEP_MERGE_SOURCE;
-var init_deepMerge = __esm({
-  "src/config/deepMerge.ts"() {
+var init_parseRouteFile = __esm({
+  "src/router/parseRouteFile.ts"() {
     "use strict";
-    DEEP_MERGE_SOURCE = `const deepMerge = ${deepMerge.toString()};`;
+    init_normalizePath();
   }
 });
 
-// src/cli/compileConfig.ts
+// src/router/scanRoutes.ts
+import fg2 from "fast-glob";
 import path8 from "path";
 import fs7 from "fs";
-function getEnv() {
-  return process.env.FAAPI_ENV || process.env.NODE_ENV || "development";
+function toProdAbsPath(sourceAbsPath, rootDir, appDir, prodDir) {
+  let rel = path8.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
+    rel = rel.slice(appDir.length + 1);
+  }
+  const prodRel = `${prodDir}/${rel.replace(/\.ts$/, ".js")}`;
+  return path8.resolve(rootDir, prodRel);
 }
-function findBaseConfig(rootDir) {
-  for (const f of BASE_CONFIG_FILES) {
-    if (fs7.existsSync(path8.join(rootDir, f))) {
-      return f.replace(/\.(ts|js)$/, "");
+async function findMergedMiddlewares(routeFilePath, rootDir, appDir, prodDir) {
+  const routeDir = path8.dirname(routeFilePath);
+  const resolvedRoot = path8.resolve(rootDir);
+  const mwPaths = [];
+  let currentDir = path8.resolve(rootDir, routeDir);
+  while (true) {
+    if (prodDir) {
+      const mwPath = path8.join(currentDir, "middlewares.js");
+      const absMwPath = path8.resolve(rootDir, mwPath);
+      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, appDir, prodDir);
+      if (fs7.existsSync(prodAbsMwPath)) {
+        mwPaths.push(prodAbsMwPath);
+      }
+    } else {
+      for (const ext of [".ts", ".js"]) {
+        const mwPath = path8.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path8.resolve(rootDir, mwPath);
+        if (fs7.existsSync(absMwPath)) {
+          mwPaths.push(absMwPath);
+          break;
+        }
+      }
     }
+    if (currentDir === resolvedRoot) break;
+    const parentDir = path8.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
   }
-  return null;
-}
-function findEnvConfig(rootDir, env) {
-  for (const ext of ENV_CONFIG_EXTS) {
-    const f = `faapi.config.${env}${ext}`;
-    if (fs7.existsSync(path8.join(rootDir, f))) {
-      return `faapi.config.${env}`;
+  if (mwPaths.length === 0) return void 0;
+  mwPaths.reverse();
+  const mergedMiddlewares = [];
+  const mergedInjectors = {};
+  for (const absMwPath of mwPaths) {
+    let bundle = getCachedMiddlewares(absMwPath);
+    if (bundle === void 0) {
+      bundle = await loadMiddlewaresFile(absMwPath);
+      setCachedMiddlewares(absMwPath, bundle);
+    }
+    mergedMiddlewares.push(...bundle.middlewares);
+    for (const [name, injector] of Object.entries(bundle.injectors)) {
+      mergedInjectors[name] = injector;
     }
   }
-  return null;
+  if (mergedMiddlewares.length === 0 && Object.keys(mergedInjectors).length === 0) {
+    return void 0;
+  }
+  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
 }
-async function compileConfig(options) {
-  const { rootDir, outDir } = options;
-  const baseConfig = findBaseConfig(rootDir);
-  if (!baseConfig) {
-    return { generated: false, outputFile: "" };
+async function extractMethodsFromHandler(absPath) {
+  try {
+    const module = await importWithCacheBust(absPath);
+    const methods = [];
+    for (const key of Object.keys(module)) {
+      if (isHttpMethod(key) && typeof module[key] === "function") {
+        methods.push(key);
+      }
+    }
+    return methods;
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    console.warn(`[faapi] \u52A0\u8F7D\u8DEF\u7531\u6587\u4EF6\u5931\u8D25 ${absPath}: ${reason}`);
+    return [];
   }
-  const env = getEnv();
-  const envConfig = findEnvConfig(rootDir, env);
-  const imports = [`import base from './${baseConfig}';`];
-  let exportDefault;
-  if (envConfig) {
-    imports.push(`import env from './${envConfig}';`);
-    exportDefault = "export default deepMerge(base, env);";
-  } else {
-    exportDefault = "export default base;";
+}
+async function hasWsExport(absPath) {
+  try {
+    const module = await importWithCacheBust(absPath);
+    return typeof module["WS"] === "function";
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    console.warn(`[faapi] \u52A0\u8F7D\u8DEF\u7531\u6587\u4EF6\u5931\u8D25\uFF08WS \u68C0\u6D4B\uFF09${absPath}: ${reason}`);
+    return false;
   }
-  const entryCode = [...imports, DEEP_MERGE_SOURCE, exportDefault].join("\n");
-  const outputFile = path8.resolve(rootDir, outDir, "faapi-config.js");
-  await fs7.promises.mkdir(path8.dirname(outputFile), { recursive: true });
-  const esbuild = await import("esbuild");
-  await esbuild.build({
-    stdin: { contents: entryCode, resolveDir: rootDir, loader: "ts" },
-    outfile: outputFile,
-    bundle: true,
-    format: "esm",
-    platform: "node",
-    target: "node20",
-    sourcemap: true,
-    packages: "external",
-    logLevel: "silent"
+}
+async function scanRoutes(rootDir, patterns, appDir, prodDir) {
+  const dir = appDir ?? ".";
+  const files = await fg2(patterns, {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: false
   });
-  return { generated: true, outputFile };
+  const routes = [];
+  const wsRoutes = [];
+  for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
+    const fileName = normalizedFile.split("/").pop();
+    if (fileName === "handler.ts" || fileName === "handler.js") {
+      const absPath = path8.resolve(rootDir, normalizedFile);
+      const importPath = prodDir ? toProdAbsPath(absPath, rootDir, dir, prodDir) : absPath;
+      const urlPath = filePathToUrlPath(normalizedFile, dir);
+      const paramNames = extractParamNames(urlPath);
+      const isDynamic = paramNames.length > 0;
+      const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
+      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, dir, prodDir);
+      const methods = await extractMethodsFromHandler(importPath);
+      for (const method of methods) {
+        routes.push({
+          method,
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      const hasWs = await hasWsExport(importPath);
+      if (hasWs) {
+        wsRoutes.push({
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      continue;
+    }
+  }
+  return { routes, wsRoutes };
 }
-var BASE_CONFIG_FILES, ENV_CONFIG_EXTS;
-var init_compileConfig = __esm({
-  "src/cli/compileConfig.ts"() {
+var init_scanRoutes = __esm({
+  "src/router/scanRoutes.ts"() {
     "use strict";
-    init_deepMerge();
-    BASE_CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
-    ENV_CONFIG_EXTS = [".ts", ".js"];
+    init_constants();
+    init_parseRouteFile();
+    init_loadMiddlewares();
+    init_importWithCacheBust();
   }
 });
 
-// src/config/loadConfig.ts
+// src/router/sortRoutes.ts
+function sortRoutes(routes) {
+  return [...routes].sort((a, b) => {
+    if (a.isDynamic !== b.isDynamic) {
+      return a.isDynamic ? 1 : -1;
+    }
+    if (a.isCatchAll !== b.isCatchAll) {
+      return a.isCatchAll ? 1 : -1;
+    }
+    const aSegments = a.urlPath.split("/").filter(Boolean).length;
+    const bSegments = b.urlPath.split("/").filter(Boolean).length;
+    if (aSegments !== bSegments) {
+      return aSegments - bSegments;
+    }
+    return a.urlPath.localeCompare(b.urlPath);
+  });
+}
+var init_sortRoutes = __esm({
+  "src/router/sortRoutes.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/loadConfig.ts
 import path9 from "path";
 import fs8 from "fs";
 async function loadConfig(rootDir, outDir) {
@@ -1835,162 +1988,6 @@ var init_loadConfig = __esm({
   }
 });
 
-// src/cli/buildCommand.ts
-var buildCommand_exports = {};
-__export(buildCommand_exports, {
-  buildCommand: () => buildCommand
-});
-import path10 from "path";
-import fs9 from "fs";
-import fg2 from "fast-glob";
-async function collectBundleEntries(rootDir, patterns, appDir) {
-  const entries = /* @__PURE__ */ new Set();
-  const handlerFiles = await fg2(patterns, {
-    cwd: rootDir,
-    onlyFiles: true,
-    absolute: true
-  });
-  for (const f of handlerFiles) {
-    if (f.endsWith("handler.ts")) entries.add(f);
-  }
-  const mwGlob = appDir === "." ? "**/middlewares.ts" : appDir + "/**/middlewares.ts";
-  const mwFiles = await fg2([mwGlob], {
-    cwd: rootDir,
-    onlyFiles: true,
-    absolute: true,
-    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
-  });
-  for (const f of mwFiles) entries.add(f);
-  return Array.from(entries);
-}
-async function buildCommand(options) {
-  const rootDir = options?.rootDir ?? process.cwd();
-  const outdir = PROD_OUT_DIR;
-  await compileConfig({ rootDir, outDir: outdir });
-  const _config = await loadConfig(rootDir, outdir);
-  const appDir = process.env.FAAPI_APP_DIR ?? "src";
-  const patterns = appDir === "." ? ["api/**/*.ts"] : [`${appDir}/api/**/*.ts`];
-  console.log("faapi build started");
-  console.log(`- Root: ${rootDir}`);
-  console.log(`- AppDir: ${appDir}`);
-  console.log(`- Output: ${outdir}`);
-  console.log("\n[1/7] Collecting bundle entries...");
-  const entries = await collectBundleEntries(rootDir, patterns, appDir);
-  console.log(`  ${entries.length} entry file(s)`);
-  if (entries.length === 0) {
-    console.warn("  ! No entry files found, nothing to build");
-    return;
-  }
-  console.log("\n[2/7] Compiling TypeScript (bundle mode)...");
-  const result = await compileBuildRoutes({
-    rootDir,
-    appDir,
-    outDir: outdir,
-    entries,
-    splitting: true,
-    define: { "process.env.NODE_ENV": JSON.stringify("production") },
-    minifySyntax: true,
-    logLevel: "silent"
-  });
-  console.log(`  Compiled ${result.compiledFiles.length} entry file(s)`);
-  console.log("\n[3/7] Compiling config...");
-  const configResult = await compileConfig({ rootDir, outDir: outdir });
-  if (configResult.generated) {
-    console.log(`  Written to ${configResult.outputFile}`);
-  } else {
-    console.log("  No config file found, skipped");
-  }
-  console.log("\n[4/7] Scanning routes...");
-  const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir, outdir);
-  const sorted = sortRoutes(routes);
-  console.log(`  Found ${sorted.length} routes, ${wsRoutes.length} WS routes`);
-  const conflicts = detectRouteConflicts(sorted);
-  if (conflicts.length > 0) {
-    console.warn("! \u68C0\u6D4B\u5230\u8DEF\u7531\u51B2\u7A81\uFF1A");
-    for (const conflict of conflicts) {
-      console.warn(`  ${conflict.method} ${conflict.urlPath}`);
-      for (const file of conflict.files) {
-        console.warn(`    - ${file}`);
-      }
-    }
-  }
-  console.log("\n[5/7] Generating schema...");
-  await generateSchemaFiles(sorted, rootDir, appDir, outdir);
-  console.log(`  Schema: zod.js files under ${path10.resolve(rootDir, outdir)}`);
-  console.log("\n[6/7] Generating routes manifest...");
-  const routesPath = path10.resolve(rootDir, outdir, "faapi-routes.js");
-  const serialized = serializeRoutes(sorted, wsRoutes, rootDir, appDir, outdir);
-  await writeRoutesModule(serialized, routesPath);
-  console.log(`  Written to ${routesPath}`);
-  console.log("\n[7/7] Generating entry file...");
-  const mainPath = path10.resolve(rootDir, outdir, "main.js");
-  const mainContent = `// \u7531 faapi build \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91
-import { createProdApp } from '@faapi/faapi';
-
-const app = await createProdApp();
-await app.listen();
-`;
-  await fs9.promises.writeFile(mainPath, mainContent, "utf-8");
-  console.log(`  Written to ${mainPath}`);
-  console.log("\nfaapi build completed");
-}
-var PROD_OUT_DIR;
-var init_buildCommand = __esm({
-  "src/cli/buildCommand.ts"() {
-    "use strict";
-    init_scanRoutes();
-    init_sortRoutes();
-    init_detectRouteConflicts();
-    init_generateSchemaFiles();
-    init_generateRoutes();
-    init_compileBuildRoutes();
-    init_compileConfig();
-    init_loadConfig();
-    PROD_OUT_DIR = "dist";
-  }
-});
-
-// src/cli/compileDevRoutes.ts
-import path11 from "path";
-import fs10 from "fs";
-import fg3 from "fast-glob";
-async function compileDevRoutes(options) {
-  const { rootDir, appDir, outDir, files, logLevel = "silent" } = options;
-  const entryPoints = files ?? await fg3([`${appDir}/**/*.ts`], {
-    cwd: rootDir,
-    onlyFiles: true,
-    absolute: true,
-    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
-  });
-  if (entryPoints.length === 0) {
-    return { compiledFiles: [] };
-  }
-  const absOutDir = path11.resolve(rootDir, outDir);
-  await fs10.promises.mkdir(absOutDir, { recursive: true });
-  const plugins = buildAliasPlugins(rootDir);
-  const esbuild = await import("esbuild");
-  const outbase = appDir === "." ? rootDir : path11.resolve(rootDir, appDir);
-  await esbuild.build({
-    entryPoints,
-    outdir: absOutDir,
-    outbase,
-    bundle: false,
-    platform: "node",
-    format: "esm",
-    sourcemap: true,
-    packages: "external",
-    plugins,
-    logLevel
-  });
-  return { compiledFiles: entryPoints };
-}
-var init_compileDevRoutes = __esm({
-  "src/cli/compileDevRoutes.ts"() {
-    "use strict";
-    init_aliasPlugin();
-  }
-});
-
 // ../../node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js
 import { stat, lstat, readdir, realpath } from "fs/promises";
 import { Readable } from "stream";
@@ -2542,10 +2539,10 @@ var init_handler = __esm({
         fn(val);
       }
     };
-    addAndConvert = (main2, prop, item) => {
-      let container = main2[prop];
+    addAndConvert = (main, prop, item) => {
+      let container = main[prop];
       if (!(container instanceof Set)) {
-        main2[prop] = container = /* @__PURE__ */ new Set([container]);
+        main[prop] = container = /* @__PURE__ */ new Set([container]);
       }
       container.add(item);
     };
@@ -2557,12 +2554,12 @@ var init_handler = __esm({
         delete cont[key];
       }
     };
-    delFromSet = (main2, prop, item) => {
-      const container = main2[prop];
+    delFromSet = (main, prop, item) => {
+      const container = main[prop];
       if (container instanceof Set) {
         container.delete(item);
       } else if (container === item) {
-        delete main2[prop];
+        delete main[prop];
       }
     };
     isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
@@ -2981,7 +2978,7 @@ var init_handler = __esm({
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
 import { stat as stat3, readdir as readdir2 } from "fs/promises";
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 import * as sysPath2 from "path";
 function arrify(item) {
   return Array.isArray(item) ? item : [item];
@@ -3184,7 +3181,7 @@ var init_esm2 = __esm({
         return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
       }
     };
-    FSWatcher = class extends EventEmitter {
+    FSWatcher = class extends EventEmitter2 {
       // Not indenting methods for history sake; for now.
       constructor(_opts = {}) {
         super();
@@ -3701,7 +3698,7 @@ var init_esm2 = __esm({
 });
 
 // src/cli/watcher.ts
-import path12 from "path";
+import path10 from "path";
 function startWatcher(options) {
   const { rootDir, appDir, app } = options;
   let rebuildTimer = null;
@@ -3755,11 +3752,11 @@ function startWatcher(options) {
     }
   });
   watcher.on("add", (file) => {
-    pendingFiles.add(path12.resolve(rootDir, file));
+    pendingFiles.add(path10.resolve(rootDir, file));
     scheduleRebuild();
   });
   watcher.on("change", (file) => {
-    pendingFiles.add(path12.resolve(rootDir, file));
+    pendingFiles.add(path10.resolve(rootDir, file));
     scheduleRebuild();
   });
   watcher.on("unlink", () => {
@@ -3787,6 +3784,36 @@ var init_watcher = __esm({
   }
 });
 
+// src/router/detectRouteConflicts.ts
+function detectRouteConflicts(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method} ${route.urlPath}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.files.push(route.filePath);
+    } else {
+      map.set(key, {
+        method: route.method,
+        urlPath: route.urlPath,
+        files: [route.filePath]
+      });
+    }
+  }
+  const conflicts = [];
+  for (const conflict of map.values()) {
+    if (conflict.files.length > 1) {
+      conflicts.push(conflict);
+    }
+  }
+  return conflicts;
+}
+var init_detectRouteConflicts = __esm({
+  "src/router/detectRouteConflicts.ts"() {
+    "use strict";
+  }
+});
+
 // src/router/matchRoute.ts
 function matchRoute(routes, method, path17) {
   for (const route of routes) {
@@ -4335,10 +4362,6 @@ var init_isPlainObject = __esm({
 });
 
 // src/response/toResponse.ts
-var toResponse_exports = {};
-__export(toResponse_exports, {
-  toResponse: () => toResponse
-});
 async function toResponse(value, meta) {
   if (value instanceof Promise) {
     return toResponse(await value, meta);
@@ -4672,16 +4695,13 @@ function mapZodCode(zodCode, message) {
       return "TYPE_MISMATCH";
     case "unrecognized_keys":
       return "INVALID_FORMAT";
-    case "invalid_enum_value":
+    case "invalid_value":
     case "invalid_string":
-    case "invalid_date":
     case "too_small":
     case "too_big":
     case "invalid_intersection_types":
     case "not_multiple_of":
       return "INVALID_VALUE";
-    case "not_finite":
-      return "COERCE_FAILED";
     case "custom":
       return "INVALID_VALUE";
     default:
@@ -4717,7 +4737,7 @@ function getClientIp(req) {
     const first = xff.split(",")[0]?.trim();
     if (first) return first;
   }
-  const remote = req.socket.remoteAddress;
+  const remote = req.socket?.remoteAddress;
   if (remote) {
     if (remote.startsWith("::ffff:")) {
       return remote.slice(7);
@@ -4937,14 +4957,7 @@ function nodeHttpToWebHeaders(req) {
   }
   return headers;
 }
-function buildErrorResponse(err, ctx, errorFormat) {
-  if (errorFormat) {
-    try {
-      const res = errorFormat(err, ctx);
-      if (res) return res;
-    } catch {
-    }
-  }
+function buildErrorResponse(err) {
   try {
     return formatErrorResponse(err);
   } catch {
@@ -4987,7 +5000,7 @@ var init_wsHandler = __esm({
 
 // src/server/handleWsUpgrade.ts
 import { WebSocketServer, WebSocket } from "ws";
-import path13 from "path";
+import path11 from "path";
 function getPathname(req) {
   const url = req.url ?? "/";
   const idx = url.indexOf("?");
@@ -5047,7 +5060,7 @@ async function sendResponseToSocket(socket, response) {
   socket.destroy();
 }
 function attachWebSocket(options) {
-  const { server, routesRef, rootDir, config, errorFormat, globalMiddlewares } = options;
+  const { server, routesRef, rootDir, config, globalMiddlewares } = options;
   const wss = new WebSocketServer({ noServer: true });
   server.on("upgrade", async (req, socket, head) => {
     const currentWsRoutes = routesRef.wsCurrent;
@@ -5069,7 +5082,7 @@ function attachWebSocket(options) {
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path13.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path11.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -5104,7 +5117,7 @@ function attachWebSocket(options) {
         console.error("[faapi] WS \u63E1\u624B\u540E\u4E2D\u95F4\u4EF6\u629B\u9519:", err);
         return;
       }
-      response = buildErrorResponse(err, ctx, errorFormat);
+      response = buildErrorResponse(err);
     }
     if (upgraded) {
       return;
@@ -5133,7 +5146,7 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable3 } from "stream";
-import path14 from "path";
+import path12 from "path";
 function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
   const forwardedProto = req.headers["x-forwarded-proto"];
   const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
@@ -5200,8 +5213,6 @@ function createServer(options) {
     appDir,
     outDir,
     cors: corsOption,
-    responseFormat,
-    errorFormat,
     onError,
     config,
     wsRoutes,
@@ -5240,8 +5251,6 @@ function createServer(options) {
       req,
       res,
       configMiddlewares,
-      responseFormat,
-      errorFormat,
       onError,
       config,
       globalMiddlewares,
@@ -5253,11 +5262,11 @@ function createServer(options) {
     });
   });
   if (routesRef.wsCurrent.length > 0) {
-    attachWebSocket({ server, routesRef, rootDir, config, errorFormat, globalMiddlewares });
+    attachWebSocket({ server, routesRef, rootDir, config, globalMiddlewares });
   }
   return { server, routesRef };
 }
-async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMiddlewares, responseFormat, errorFormat, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
   const request = toWebRequest(req, bodyLimit);
   const method = request.method.toUpperCase();
   const urlPath = new URL(request.url).pathname;
@@ -5274,7 +5283,7 @@ async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMi
     }
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path14.resolve(rootDir, route.filePath);
+    const absoluteFilePath = path12.resolve(rootDir, route.filePath);
     const routeModule = await loadRouteModule(absoluteFilePath, route.method);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
@@ -5285,22 +5294,13 @@ async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMi
     }
     const body = hasBody(route.method) ? result.data : void 0;
     const mergedInjectors = globalInjectors ? { ...globalInjectors, ...route.injectors } : route.injectors;
-    let response = await invokeHandler(
+    const response = await invokeHandler(
       routeModule.handler,
       ctx,
       body,
       route.middlewares,
       mergedInjectors
     );
-    if (responseFormat && response.status >= 200 && response.status < 300) {
-      const contentType = response.headers.get("Content-Type") ?? "";
-      if (contentType.includes("application/json")) {
-        const data = await response.json();
-        const formatted = responseFormat(data, ctx);
-        const { toResponse: toResponse2 } = await Promise.resolve().then(() => (init_toResponse(), toResponse_exports));
-        response = await toResponse2(formatted, meta);
-      }
-    }
     return response;
   };
   try {
@@ -5317,7 +5317,7 @@ async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMi
     }
     await sendNodeResponse(response, res);
   } catch (err) {
-    const errorResponse = buildErrorResponse(err, ctx, errorFormat);
+    const errorResponse = buildErrorResponse(err);
     await sendNodeResponse(mergeMeta(errorResponse, meta), res);
     if (onError) {
       try {
@@ -5448,8 +5448,8 @@ var init_loadPlugins = __esm({
 });
 
 // src/cli/createAppCore.ts
-import fs11 from "fs";
-import path15 from "path";
+import fs9 from "fs";
+import path13 from "path";
 import { PassThrough } from "stream";
 function isFaapiConfigKey(key) {
   return FAAPI_CONFIG_KEYS.has(key);
@@ -5457,8 +5457,8 @@ function isFaapiConfigKey(key) {
 async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const outDir = process.env.FAAPI_OUT_DIR ?? DEFAULT_OUT_DIR;
-  const routesPath = path15.resolve(rootDir, outDir, ROUTES_FILE);
-  if (!fs11.existsSync(routesPath)) {
+  const routesPath = path13.resolve(rootDir, outDir, ROUTES_FILE);
+  if (!fs9.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${outDir}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -5486,8 +5486,6 @@ async function createAppBase(options) {
     appDir,
     outDir,
     cors: config?.cors ?? true,
-    responseFormat: config?.responseFormat,
-    errorFormat: config?.errorFormat,
     onError: config?.lifecycle?.onError,
     config: config ?? void 0,
     wsRoutes,
@@ -5500,6 +5498,7 @@ async function createAppBase(options) {
   const { handlerWrappers, upgradeWrappers } = await loadPlugins(config?.plugins, {
     rootDir,
     routes: sorted,
+    getRoutes: () => sorted,
     server,
     config: pluginConfig
   });
@@ -5565,6 +5564,11 @@ async function createAppBase(options) {
           setHeader(name, value) {
             this._headers[name.toLowerCase()] = value;
           },
+          appendHeader(name, value) {
+            const key = name.toLowerCase();
+            const existing = this._headers[key];
+            this._headers[key] = existing ? `${existing}, ${value}` : value;
+          },
           writeHead(status, headers) {
             this.statusCode = status;
             if (headers) {
@@ -5606,6 +5610,7 @@ async function createAppBase(options) {
           host: "localhost",
           "content-type": body !== void 0 ? "application/json" : void 0
         };
+        mockReq.socket = { remoteAddress: "127.0.0.1" };
         if (body !== void 0) {
           mockReq.push(JSON.stringify(body));
         }
@@ -5618,8 +5623,13 @@ async function createAppBase(options) {
     async close() {
       if (closed) return;
       closed = true;
-      server.closeIdleConnections?.();
-      server.closeAllConnections?.();
+      const s = server;
+      if (typeof s.closeIdleConnections === "function") {
+        s.closeIdleConnections();
+      }
+      if (typeof s.closeAllConnections === "function") {
+        s.closeAllConnections();
+      }
       if (config?.lifecycle?.onClose) {
         await config.lifecycle.onClose({ rootDir, routes: sorted, server });
       }
@@ -5669,8 +5679,6 @@ var init_createAppCore = __esm({
     ROUTES_FILE = "faapi-routes.js";
     FAAPI_CONFIG_KEYS = /* @__PURE__ */ new Set([
       "cors",
-      "responseFormat",
-      "errorFormat",
       "lifecycle",
       "middlewares",
       "injectors",
@@ -5720,7 +5728,7 @@ __export(devCommand_exports, {
   devCommand: () => devCommand,
   generateRouteArtifacts: () => generateRouteArtifacts
 });
-import path16 from "path";
+import path14 from "path";
 async function devCommand() {
   const rootDir = process.cwd();
   process.env.FAAPI_OUT_DIR = DEV_OUT_DIR2;
@@ -5743,7 +5751,7 @@ async function devCommand() {
 async function generateRouteArtifacts(rootDir, appDir, patterns) {
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir, DEV_OUT_DIR2);
   const sorted = sortRoutes(routes);
-  const routesPath = path16.resolve(rootDir, DEV_OUT_DIR2, ROUTES_FILE2);
+  const routesPath = path14.resolve(rootDir, DEV_OUT_DIR2, ROUTES_FILE2);
   const serialized = serializeRoutes(sorted, wsRoutes, rootDir, appDir, DEV_OUT_DIR2);
   await writeRoutesModule(serialized, routesPath);
   await generateSchemaFiles(sorted, rootDir, appDir, DEV_OUT_DIR2);
@@ -5766,22 +5774,764 @@ var init_devCommand = __esm({
   }
 });
 
-// src/cli/index.ts
-async function main() {
-  const argv = process.argv.slice(2);
-  const firstArg = argv[0];
-  if (firstArg === "build") {
-    const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_buildCommand(), buildCommand_exports));
-    await buildCommand2();
+// src/cli/compileBuildRoutes.ts
+import path15 from "path";
+import fs10 from "fs";
+async function compileBuildRoutes(options) {
+  const {
+    rootDir,
+    appDir,
+    outDir,
+    entries,
+    splitting = true,
+    define,
+    minifySyntax = true,
+    logLevel = "silent"
+  } = options;
+  if (entries.length === 0) {
+    return { compiledFiles: [] };
+  }
+  const absOutDir = path15.resolve(rootDir, outDir);
+  await fs10.promises.mkdir(absOutDir, { recursive: true });
+  const plugins = buildAliasPlugins(rootDir);
+  const esbuild = await import("esbuild");
+  const outbase = appDir === "." ? rootDir : path15.resolve(rootDir, appDir);
+  await esbuild.build({
+    entryPoints: entries,
+    outdir: absOutDir,
+    outbase,
+    bundle: true,
+    splitting,
+    platform: "node",
+    format: "esm",
+    sourcemap: true,
+    packages: "external",
+    plugins,
+    define,
+    minifySyntax,
+    logLevel
+  });
+  return { compiledFiles: entries };
+}
+var init_compileBuildRoutes = __esm({
+  "src/cli/compileBuildRoutes.ts"() {
+    "use strict";
+    init_aliasPlugin();
+  }
+});
+
+// src/cli/buildCommand.ts
+var buildCommand_exports = {};
+__export(buildCommand_exports, {
+  buildCommand: () => buildCommand
+});
+import path16 from "path";
+import fs11 from "fs";
+import fg3 from "fast-glob";
+async function collectBundleEntries(rootDir, patterns, appDir) {
+  const entries = /* @__PURE__ */ new Set();
+  const handlerFiles = await fg3(patterns, {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true
+  });
+  for (const f of handlerFiles) {
+    if (f.endsWith("handler.ts")) entries.add(f);
+  }
+  const mwGlob = appDir === "." ? "**/middlewares.ts" : appDir + "/**/middlewares.ts";
+  const mwFiles = await fg3([mwGlob], {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
+  });
+  for (const f of mwFiles) entries.add(f);
+  return Array.from(entries);
+}
+async function buildCommand(options) {
+  const rootDir = options?.rootDir ?? process.cwd();
+  const outdir = PROD_OUT_DIR;
+  await compileConfig({ rootDir, outDir: outdir });
+  const _config = await loadConfig(rootDir, outdir);
+  const appDir = process.env.FAAPI_APP_DIR ?? "src";
+  const patterns = appDir === "." ? ["api/**/*.ts"] : [`${appDir}/api/**/*.ts`];
+  console.log("faapi build started");
+  console.log(`- Root: ${rootDir}`);
+  console.log(`- AppDir: ${appDir}`);
+  console.log(`- Output: ${outdir}`);
+  console.log("\n[1/7] Collecting bundle entries...");
+  const entries = await collectBundleEntries(rootDir, patterns, appDir);
+  console.log(`  ${entries.length} entry file(s)`);
+  if (entries.length === 0) {
+    console.warn("  ! No entry files found, nothing to build");
     return;
   }
+  console.log("\n[2/7] Compiling TypeScript (bundle mode)...");
+  const result = await compileBuildRoutes({
+    rootDir,
+    appDir,
+    outDir: outdir,
+    entries,
+    splitting: true,
+    define: { "process.env.NODE_ENV": JSON.stringify("production") },
+    minifySyntax: true,
+    logLevel: "silent"
+  });
+  console.log(`  Compiled ${result.compiledFiles.length} entry file(s)`);
+  console.log("\n[3/7] Compiling config...");
+  const configResult = await compileConfig({ rootDir, outDir: outdir });
+  if (configResult.generated) {
+    console.log(`  Written to ${configResult.outputFile}`);
+  } else {
+    console.log("  No config file found, skipped");
+  }
+  console.log("\n[4/7] Scanning routes...");
+  const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir, outdir);
+  const sorted = sortRoutes(routes);
+  console.log(`  Found ${sorted.length} routes, ${wsRoutes.length} WS routes`);
+  const conflicts = detectRouteConflicts(sorted);
+  if (conflicts.length > 0) {
+    console.warn("! \u68C0\u6D4B\u5230\u8DEF\u7531\u51B2\u7A81\uFF1A");
+    for (const conflict of conflicts) {
+      console.warn(`  ${conflict.method} ${conflict.urlPath}`);
+      for (const file of conflict.files) {
+        console.warn(`    - ${file}`);
+      }
+    }
+  }
+  console.log("\n[5/7] Generating schema...");
+  await generateSchemaFiles(sorted, rootDir, appDir, outdir);
+  console.log(`  Schema: zod.js files under ${path16.resolve(rootDir, outdir)}`);
+  console.log("\n[6/7] Generating routes manifest...");
+  const routesPath = path16.resolve(rootDir, outdir, "faapi-routes.js");
+  const serialized = serializeRoutes(sorted, wsRoutes, rootDir, appDir, outdir);
+  await writeRoutesModule(serialized, routesPath);
+  console.log(`  Written to ${routesPath}`);
+  console.log("\n[7/7] Generating entry file...");
+  const mainPath = path16.resolve(rootDir, outdir, "main.js");
+  const mainContent = `// \u7531 faapi build \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91
+import { createProdApp } from '@faapi/faapi';
+
+const app = await createProdApp();
+await app.listen();
+`;
+  await fs11.promises.writeFile(mainPath, mainContent, "utf-8");
+  console.log(`  Written to ${mainPath}`);
+  console.log("\nfaapi build completed");
+}
+var PROD_OUT_DIR;
+var init_buildCommand = __esm({
+  "src/cli/buildCommand.ts"() {
+    "use strict";
+    init_scanRoutes();
+    init_sortRoutes();
+    init_detectRouteConflicts();
+    init_generateSchemaFiles();
+    init_generateRoutes();
+    init_compileBuildRoutes();
+    init_compileConfig();
+    init_loadConfig();
+    PROD_OUT_DIR = "dist";
+  }
+});
+
+// ../../node_modules/.pnpm/cac@6.7.14/node_modules/cac/dist/index.mjs
+import { EventEmitter } from "events";
+function toArr(any) {
+  return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+  out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function mri2(args, opts) {
+  args = args || [];
+  opts = opts || {};
+  var k, arr, arg, name, val, out = { _: [] };
+  var i = 0, j = 0, idx = 0, len = args.length;
+  const alibi = opts.alias !== void 0;
+  const strict = opts.unknown !== void 0;
+  const defaults = opts.default !== void 0;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0; i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length; i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.boolean.push(arr[j]);
+  }
+  for (i = opts.string.length; i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.string.push(arr[j]);
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== void 0) {
+        opts[name].push(k);
+        for (i = 0; i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0; i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0; j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45) break;
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.substring(j + 3);
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1; idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61) break;
+      }
+      name = arg.substring(j, idx);
+      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
+      arr = j === 2 ? [name] : name;
+      for (idx = 0; idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === void 0) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}
+var removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
+var findAllBrackets = (v) => {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+};
+var getMriOptions = (options) => {
+  const result = { alias: {}, boolean: [] };
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+};
+var findLongest = (arr) => {
+  return arr.sort((a, b) => {
+    return a.length > b.length ? -1 : 1;
+  })[0];
+};
+var padRight = (str, length) => {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+};
+var camelcase = (input) => {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+};
+var setDotProp = (obj, keys, val) => {
+  let i = 0;
+  let length = keys.length;
+  let t = obj;
+  let x;
+  for (; i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+};
+var setByType = (obj, transforms) => {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+};
+var getFileName = (input) => {
+  const m = /([^\\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+};
+var camelcaseOptionName = (name) => {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+};
+var CACError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+};
+var Option = class {
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+};
+var processArgs = process.argv;
+var platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+var Command = class {
+  constructor(rawName, description, config = {}, cli2) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli2;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.versionNumber = version;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  isMatched(name) {
+    return this.name === name || this.aliasNames.includes(name);
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const { name, commands } = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  $ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      sections.push({
+        title: "Commands",
+        body: commands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join("\n")
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+        }).join("\n")
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join("\n")
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join("\n\n"));
+  }
+  outputVersion() {
+    const { name } = this.cli;
+    const { versionNumber } = this.cli.globalCommand;
+    if (versionNumber) {
+      console.log(`${name}/${versionNumber} ${platformInfo}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+  }
+  checkUnknownOptions() {
+    const { options, globalCommand } = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const { options: parsedOptions, globalCommand } = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new CACError(`option \`${option.rawName}\` value is missing`);
+        }
+      }
+    }
+  }
+};
+var GlobalCommand = class extends Command {
+  constructor(cli2) {
+    super("@@global@@", "", {}, cli2);
+  }
+};
+var __assign = Object.assign;
+var CAC = class extends EventEmitter {
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    const command = new Command(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version, customFlags = "-v, --version") {
+    this.globalCommand.version(version, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = void 0;
+    this.matchedCommandName = void 0;
+  }
+  parse(argv = processArgs, {
+    run = true
+  } = {}) {
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    for (const command of this.commands) {
+      const parsed = this.mri(argv.slice(2), command);
+      const commandName = parsed.args[0];
+      if (command.isMatched(commandName)) {
+        shouldParse = false;
+        const parsedInfo = __assign(__assign({}, parsed), {
+          args: parsed.args.slice(1)
+        });
+        this.setParsedInfo(parsedInfo, command, commandName);
+        this.emit(`command:${commandName}`, command);
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(argv.slice(2), command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = { args: this.args, options: this.options };
+    if (run) {
+      this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    let parsed = mri2(argv, mriOptions);
+    parsed = Object.keys(parsed).reduce((res, name) => {
+      return __assign(__assign({}, res), {
+        [camelcaseOptionName(name)]: parsed[name]
+      });
+    }, { _: [] });
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    let transforms = /* @__PURE__ */ Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== void 0) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === void 0) {
+          transforms[cliOption.name] = /* @__PURE__ */ Object.create(null);
+          transforms[cliOption.name]["shouldTransform"] = true;
+          transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    return command.commandAction.apply(this, actionArgs);
+  }
+};
+var cac = (name = "") => new CAC(name);
+
+// src/cli/index.ts
+var cli = cac("faapi");
+cli.command("").alias("dev").action(async () => {
   const { devCommand: devCommand2 } = await Promise.resolve().then(() => (init_devCommand(), devCommand_exports));
   await devCommand2();
-}
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
 });
+cli.command("build", "Build for production").action(async () => {
+  const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_buildCommand(), buildCommand_exports));
+  await buildCommand2();
+});
+cli.help();
+cli.parse();
 /*! Bundled license information:
 
 chokidar/esm/index.js: