@faapi/faapi 0.0.0-canary.2a7b6a3 → 0.0.0-canary.4e89b9b

package/dist/cli/index.js

@@ -78,17 +78,47 @@ function toProdImportPath(sourceFile, importer) {
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
-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;
+function toRealPath(p) {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function isInsideDir(filePath, dir) {
+  const rel = path2.relative(dir, filePath);
+  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+function toStrippedProdImportPath(sourceFile, rootDir) {
+  const appDirAbs = toRealPath(path2.resolve(rootDir, APP_DIR));
+  const sourceReal = toRealPath(sourceFile);
+  let rel = path2.relative(appDirAbs, sourceReal);
+  rel = rel.split(path2.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return toProdExtension(rel);
+}
+function resolveRelativeSpecifier(importer, specifier) {
+  const importerDir = path2.dirname(importer);
+  const base = path2.resolve(importerDir, specifier);
+  if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
+    return fs2.existsSync(base) ? base : null;
+  }
+  if (/\.(ts|tsx|jsx)$/.test(specifier)) {
+    return fs2.existsSync(base) ? base : null;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const file = base + ext;
+    if (fs2.existsSync(file)) return file;
+  }
+  for (const indexExt of INDEX_EXTS) {
+    const file = base + indexExt;
+    if (fs2.existsSync(file)) return file;
+  }
+  return null;
+}
+function createAliasPlugin(config, options) {
+  const SPEC_RE2 = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
+  const appDirAbs = options?.rootDir ? toRealPath(path2.resolve(options.rootDir, APP_DIR)) : null;
   return {
     name: "faapi-alias",
     setup(build) {
@@ -100,17 +130,42 @@ function createAliasPlugin(config) {
           return void 0;
         }
         const importer = args.path;
+        const importerOutsideAppDir = appDirAbs ? !isInsideDir(importer, appDirAbs) : false;
         let modified = false;
-        const newSource = source.replace(SPEC_RE, (full, prefix, quote, specifier) => {
-          if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("file:") || specifier.startsWith("node:")) {
+        const newSource = source.replace(SPEC_RE2, (full, prefix, quote, specifier) => {
+          if (specifier.startsWith("/") || specifier.startsWith("file:") || specifier.startsWith("node:")) {
+            return full;
+          }
+          if (specifier.startsWith("./") || specifier.startsWith("../")) {
+            const resolved = resolveRelativeSpecifier(importer, specifier);
+            if (resolved) {
+              if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
+                return full;
+              }
+              if (appDirAbs && importerOutsideAppDir && isInsideDir(resolved, appDirAbs)) {
+                modified = true;
+                return `${prefix}${quote}${toStrippedProdImportPath(
+                  resolved,
+                  options.rootDir
+                )}${quote}`;
+              }
+              modified = true;
+              return `${prefix}${quote}${toProdImportPath(resolved, importer)}${quote}`;
+            }
             return full;
           }
           const candidates = resolveAlias(specifier, config);
           for (const candidate of candidates) {
-            for (const ext of EXTS) {
+            for (const ext of SOURCE_EXTS) {
               const file = candidate + ext;
               if (fs2.existsSync(file)) {
                 modified = true;
+                if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
+                  return `${prefix}${quote}${toStrippedProdImportPath(
+                    file,
+                    options.rootDir
+                  )}${quote}`;
+                }
                 return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
               }
             }
@@ -118,6 +173,12 @@ function createAliasPlugin(config) {
               const file = candidate + indexExt;
               if (fs2.existsSync(file)) {
                 modified = true;
+                if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
+                  return `${prefix}${quote}${toStrippedProdImportPath(
+                    file,
+                    options.rootDir
+                  )}${quote}`;
+                }
                 return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
               }
             }
@@ -132,13 +193,25 @@ function createAliasPlugin(config) {
 }
 function buildAliasPlugins(rootDir) {
   const tsconfig = readTsconfig(rootDir);
-  return tsconfig ? [createAliasPlugin(tsconfig)] : [];
+  return [createAliasPlugin(tsconfig ?? { baseUrl: ".", paths: {} }, { rootDir })];
 }
+var APP_DIR, PROD_EXTS, SOURCE_EXTS, INDEX_EXTS;
 var init_aliasPlugin = __esm({
   "src/cli/aliasPlugin.ts"() {
     "use strict";
     init_resolveAlias();
     init_readTsconfig();
+    APP_DIR = "src";
+    PROD_EXTS = [".js", ".mjs", ".cjs"];
+    SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+    INDEX_EXTS = [
+      "/index.ts",
+      "/index.tsx",
+      "/index.js",
+      "/index.jsx",
+      "/index.mjs",
+      "/index.cjs"
+    ];
   }
 });
 
@@ -147,8 +220,8 @@ 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`], {
+  const { rootDir, dist, files, logLevel = "silent" } = options;
+  const entryPoints = files ?? await fg([`${APP_DIR2}/**/*.ts`], {
     cwd: rootDir,
     onlyFiles: true,
     absolute: true,
@@ -157,14 +230,14 @@ async function compileDevRoutes(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absOutDir = path3.resolve(rootDir, outDir);
-  await fs3.promises.mkdir(absOutDir, { recursive: true });
+  const absDist = path3.resolve(rootDir, dist);
+  await fs3.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = appDir === "." ? rootDir : path3.resolve(rootDir, appDir);
+  const outbase = path3.resolve(rootDir, APP_DIR2);
   await esbuild.build({
     entryPoints,
-    outdir: absOutDir,
+    outdir: absDist,
     outbase,
     bundle: false,
     platform: "node",
@@ -176,10 +249,12 @@ async function compileDevRoutes(options) {
   });
   return { compiledFiles: entryPoints };
 }
+var APP_DIR2;
 var init_compileDevRoutes = __esm({
   "src/cli/compileDevRoutes.ts"() {
     "use strict";
     init_aliasPlugin();
+    APP_DIR2 = "src";
   }
 });
 
@@ -215,13 +290,24 @@ var init_deepMerge = __esm({
 // src/cli/compileConfig.ts
 import path4 from "path";
 import fs4 from "fs";
+function toRealPath2(p) {
+  try {
+    return fs4.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function isInsideDir2(filePath, dir) {
+  const rel = path4.relative(dir, filePath);
+  return rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel);
+}
 function getEnv() {
   return process.env.FAAPI_ENV || process.env.NODE_ENV || "development";
 }
 function findBaseConfig(rootDir) {
   for (const f of BASE_CONFIG_FILES) {
     if (fs4.existsSync(path4.join(rootDir, f))) {
-      return f.replace(/\.(ts|js)$/, "");
+      return f;
     }
   }
   return null;
@@ -230,33 +316,137 @@ 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}`;
+      return f;
     }
   }
   return null;
 }
+function toProdExtension2(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 toProdImport(filename) {
+  return toProdExtension2(filename);
+}
+function extractRelativeSpecifiers(source) {
+  const specifiers = [];
+  let match;
+  SPEC_RE.lastIndex = 0;
+  while ((match = SPEC_RE.exec(source)) !== null) {
+    const specifier = match[3];
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      specifiers.push(specifier);
+    }
+  }
+  return specifiers;
+}
+async function collectRelativeImports(entryFiles, rootDir) {
+  const appDirAbs = toRealPath2(path4.resolve(rootDir, "src"));
+  const visited = /* @__PURE__ */ new Set();
+  const appDirFiles = /* @__PURE__ */ new Set();
+  const nonAppDirFiles = /* @__PURE__ */ new Set();
+  async function collect(filePath) {
+    if (visited.has(filePath)) return;
+    visited.add(filePath);
+    let source;
+    try {
+      source = await fs4.promises.readFile(filePath, "utf8");
+    } catch {
+      return;
+    }
+    const specifiers = extractRelativeSpecifiers(source);
+    for (const specifier of specifiers) {
+      const resolved = resolveRelativeSpecifier(filePath, specifier);
+      if (!resolved) continue;
+      if (/\.(js|mjs|cjs)$/.test(specifier)) continue;
+      if (isInsideDir2(resolved, appDirAbs)) {
+        appDirFiles.add(resolved);
+      } else {
+        nonAppDirFiles.add(resolved);
+      }
+      await collect(resolved);
+    }
+  }
+  for (const entry of entryFiles) {
+    await collect(entry);
+  }
+  return {
+    appDirFiles: Array.from(appDirFiles),
+    nonAppDirFiles: Array.from(nonAppDirFiles)
+  };
+}
+function createExternalRelativePlugin() {
+  return {
+    name: "faapi-external-relative",
+    setup(build) {
+      build.onResolve({ filter: /^\.{1,2}\// }, (args) => ({
+        path: args.path,
+        external: true
+      }));
+    }
+  };
+}
 async function compileConfig(options) {
-  const { rootDir, outDir } = options;
-  const baseConfig = findBaseConfig(rootDir);
-  if (!baseConfig) {
+  const { rootDir, dist } = options;
+  const baseConfigName = findBaseConfig(rootDir);
+  if (!baseConfigName) {
     return { generated: false, outputFile: "" };
   }
   const env = getEnv();
-  const envConfig = findEnvConfig(rootDir, env);
-  const imports = [`import base from './${baseConfig}';`];
+  const envConfigName = findEnvConfig(rootDir, env);
+  const absDist = path4.resolve(rootDir, dist);
+  await fs4.promises.mkdir(absDist, { recursive: true });
+  const configEntryPoints = [path4.resolve(rootDir, baseConfigName)];
+  if (envConfigName) {
+    configEntryPoints.push(path4.resolve(rootDir, envConfigName));
+  }
+  const { appDirFiles, nonAppDirFiles } = await collectRelativeImports(configEntryPoints, rootDir);
+  const esbuild = await import("esbuild");
+  const aliasPlugins = buildAliasPlugins(rootDir);
+  const step1aEntries = [...configEntryPoints, ...nonAppDirFiles];
+  await esbuild.build({
+    entryPoints: step1aEntries,
+    outdir: absDist,
+    outbase: rootDir,
+    bundle: false,
+    platform: "node",
+    format: "esm",
+    sourcemap: true,
+    packages: "external",
+    plugins: aliasPlugins,
+    logLevel: "silent"
+  });
+  if (appDirFiles.length > 0) {
+    const appOutbase = path4.resolve(rootDir, "src");
+    await esbuild.build({
+      entryPoints: appDirFiles,
+      outdir: absDist,
+      outbase: appOutbase,
+      bundle: false,
+      platform: "node",
+      format: "esm",
+      sourcemap: true,
+      packages: "external",
+      plugins: aliasPlugins,
+      logLevel: "silent"
+    });
+  }
+  const baseImport = `import base from './${toProdImport(baseConfigName)}';`;
+  const imports = [baseImport];
   let exportDefault;
-  if (envConfig) {
-    imports.push(`import env from './${envConfig}';`);
+  if (envConfigName) {
+    const envImport = `import env from './${toProdImport(envConfigName)}';`;
+    imports.push(envImport);
     exportDefault = "export default deepMerge(base, env);";
   } else {
     exportDefault = "export default base;";
   }
   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");
+  const outputFile = path4.resolve(absDist, "faapi-config.js");
   await esbuild.build({
-    stdin: { contents: entryCode, resolveDir: rootDir, loader: "ts" },
+    stdin: { contents: entryCode, resolveDir: absDist, loader: "ts" },
     outfile: outputFile,
     bundle: true,
     format: "esm",
@@ -264,17 +454,20 @@ async function compileConfig(options) {
     target: "node20",
     sourcemap: true,
     packages: "external",
+    plugins: [createExternalRelativePlugin()],
     logLevel: "silent"
   });
   return { generated: true, outputFile };
 }
-var BASE_CONFIG_FILES, ENV_CONFIG_EXTS;
+var BASE_CONFIG_FILES, ENV_CONFIG_EXTS, SPEC_RE;
 var init_compileConfig = __esm({
   "src/cli/compileConfig.ts"() {
     "use strict";
     init_deepMerge();
+    init_aliasPlugin();
     BASE_CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
     ENV_CONFIG_EXTS = [".ts", ".js"];
+    SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
   }
 });
 
@@ -563,10 +756,35 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
     const properties = typeName === "Pick" ? innerType.properties.filter((p) => keySet.has(p.name)) : innerType.properties.filter((p) => !keySet.has(p.name));
     return { kind: "object", properties };
   }
-  if (typeName === "Map" || typeName === "Set" || typeName === "WeakMap" || typeName === "WeakSet") {
+  if (typeName === "Map") {
+    if (!typeNode.typeArguments || typeNode.typeArguments.length !== 2) {
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        "Map \u5FC5\u987B\u5E26 2 \u4E2A\u7C7B\u578B\u53C2\u6570\uFF0C\u5982 Map<K, V>\uFF0C\u88F8 Map \u4E0D\u652F\u6301"
+      );
+    }
+    return {
+      kind: "map",
+      key: resolveTypeNode(typeNode.typeArguments[0], checker, visited),
+      value: resolveTypeNode(typeNode.typeArguments[1], checker, visited)
+    };
+  }
+  if (typeName === "Set") {
+    if (!typeNode.typeArguments || typeNode.typeArguments.length !== 1) {
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        "Set \u5FC5\u987B\u5E26 1 \u4E2A\u7C7B\u578B\u53C2\u6570\uFF0C\u5982 Set<T>\uFF0C\u88F8 Set \u4E0D\u652F\u6301"
+      );
+    }
+    return {
+      kind: "set",
+      element: resolveTypeNode(typeNode.typeArguments[0], checker, visited)
+    };
+  }
+  if (typeName === "WeakMap" || typeName === "WeakSet") {
     throw new SchemaExtractionError(
       typeNode.getText(),
-      `${typeName} \u8FD0\u884C\u65F6\u65E0\u6CD5\u6821\u9A8C\uFF0C\u8BF7\u6539\u7528\u5BF9\u8C61\u6216\u6570\u7EC4`
+      `${typeName} \u8FD0\u884C\u65F6\u65E0\u6CD5\u679A\u4E3E\u6821\u9A8C\uFF0C\u8BF7\u6539\u7528 Map / Set \u6216\u5BF9\u8C61`
     );
   }
   if (typeName === "Promise") {
@@ -1025,6 +1243,7 @@ var init_resolveInjection = __esm({
     PARAM_TYPE_MAP = {
       query: "query",
       body: "body",
+      form: "form",
       headers: "headers",
       params: "params",
       context: "context",
@@ -1123,9 +1342,16 @@ function collectRouteSchemaSources(routes, rootDir) {
       const inputType = getInputTypeForMethod(method);
       const schemaName = getSchemaName(method, inputType);
       const meta = analyzeInjection(code, method);
-      const param = meta.params.find((p) => p.type === inputType);
+      const param = meta.params.find((p) => p.type === inputType) ?? (inputType === "body" ? meta.params.find((p) => p.type === "form") : void 0);
+      const isForm = param?.type === "form";
       const typeInfo = param?.typeName ? extractTypeInfo(program, filePath, param.typeName) : null;
-      sources.push({ urlPath: entry.urlPath, filePath, schemaName, typeInfo });
+      sources.push({
+        urlPath: entry.urlPath,
+        filePath,
+        schemaName,
+        typeInfo,
+        coerce: isForm || void 0
+      });
     }
   }
   return { sources, allTypesByFile, mergedAllTypes };
@@ -1177,6 +1403,13 @@ function collectNamedTypes(type, ctx) {
       collectNamedTypes(type.key, ctx);
       collectNamedTypes(type.value, ctx);
       return;
+    case "map":
+      collectNamedTypes(type.key, ctx);
+      collectNamedTypes(type.value, ctx);
+      return;
+    case "set":
+      collectNamedTypes(type.element, ctx);
+      return;
     case "ref": {
       if (ctx.namedTypes.has(type.name)) return;
       ctx.namedTypes.set(type.name, { kind: "any" });
@@ -1266,6 +1499,10 @@ function baseExpression(type, ctx) {
       return 'z.preprocess((v) => (typeof v === "string" ? new Date(v) : v), z.date())';
     case "record":
       return `z.record(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)})`;
+    case "map":
+      return `z.preprocess(coerceMap, z.map(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)}))`;
+    case "set":
+      return `z.preprocess(coerceSet, z.set(${runtimeTypeToZodExpression(type.element, ctx)}))`;
     case "ref":
       if (type.name === ctx.entryTypeName) {
         return `${ctx.entryExportName}Schema`;
@@ -1278,11 +1515,13 @@ function generateHelpersFileSource() {
     "// faapi-helpers.js \u2014 faapi \u81EA\u52A8\u751F\u6210\u7684\u516C\u7528\u51FD\u6570\uFF08\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91\uFF09",
     COERCE_NUMBER_HELPER,
     COERCE_BOOLEAN_HELPER,
+    COERCE_MAP_HELPER,
+    COERCE_SET_HELPER,
     ""
   ].join("\n");
 }
 function usesCoerceHelpers(code) {
-  return code.includes("coerceNumber") || code.includes("coerceBoolean");
+  return code.includes("coerceNumber") || code.includes("coerceBoolean") || code.includes("coerceMap") || code.includes("coerceSet");
 }
 function wrapCoercePreprocess(kind, inner) {
   if (kind === "number") {
@@ -1369,6 +1608,10 @@ function containsRef(type, visited) {
       return type.members.some((m) => containsRef(m, visited));
     case "record":
       return containsRef(type.key, visited) || containsRef(type.value, visited);
+    case "map":
+      return containsRef(type.key, visited) || containsRef(type.value, visited);
+    case "set":
+      return containsRef(type.element, visited);
     default:
       return false;
   }
@@ -1397,7 +1640,7 @@ function generateZodSchemaSource(typeInfo, resolveType, exportName, coerce = fal
   }
   return lines.join("\n");
 }
-var CodeGenContext, COERCE_NUMBER_HELPER, COERCE_BOOLEAN_HELPER, HELPERS_FILENAME;
+var CodeGenContext, COERCE_NUMBER_HELPER, COERCE_BOOLEAN_HELPER, COERCE_MAP_HELPER, COERCE_SET_HELPER, HELPERS_FILENAME;
 var init_generateZodSchema = __esm({
   "src/ast/generateZodSchema.ts"() {
     "use strict";
@@ -1423,6 +1666,8 @@ var init_generateZodSchema = __esm({
     };
     COERCE_NUMBER_HELPER = 'export const coerceNumber = (v) => typeof v === "string" && v.trim() !== "" && !isNaN(Number(v)) ? Number(v) : v;';
     COERCE_BOOLEAN_HELPER = 'export const coerceBoolean = (v) => v === "true" || v === "1" ? true : v === "false" || v === "0" ? false : v;';
+    COERCE_MAP_HELPER = 'export const coerceMap = (v) => Array.isArray(v) ? new Map(v) : v instanceof Map ? v : (v && typeof v === "object" ? new Map(Object.entries(v)) : v);';
+    COERCE_SET_HELPER = "export const coerceSet = (v) => v instanceof Set ? v : (Array.isArray(v) ? new Set(v) : v);";
     HELPERS_FILENAME = "faapi-helpers.js";
   }
 });
@@ -1430,25 +1675,25 @@ var init_generateZodSchema = __esm({
 // src/cli/generateSchemaFiles.ts
 import path6 from "path";
 import fs5 from "fs/promises";
-function getSchemaOutputPath(sourceFile, appDir, outDir, rootDir) {
+function getSchemaOutputPath(sourceFile, dist, rootDir) {
   let rel = sourceFile.replace(/\\/g, "/");
-  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
-    rel = rel.slice(appDir.length + 1);
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path6.resolve(rootDir, outDir, relDir, "zod.js");
+  return path6.resolve(rootDir, dist, relDir, "zod.js");
 }
-function getRuntimeSchemaPath(filePath, appDir, outDir, rootDir) {
+function getRuntimeSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
-  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
-    rel = rel.slice(appDir.length + 1);
-  } else if (rel.startsWith(`${outDir}/`)) {
-    rel = rel.slice(outDir.length + 1);
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
+  } else if (rel.startsWith(`${dist}/`)) {
+    rel = rel.slice(dist.length + 1);
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path6.resolve(rootDir, outDir, relDir, "zod.js");
+  return path6.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -1464,7 +1709,7 @@ function generateSchemaFileSource(sources, allTypes, helpersImportPath) {
     if (!typeInfo) {
       continue;
     }
-    const coerce = /(?:Query|Params)$/.test(schemaName);
+    const coerce = source.coerce ?? /(?:Query|Params)$/.test(schemaName);
     const block = [`// ${schemaName}`];
     const schemaCode = generateZodSchemaSource(typeInfo, resolveType, schemaName, coerce).replace(
       /^import \{ z \} from 'zod';\s*\n\s*\n/,
@@ -1476,13 +1721,15 @@ function generateSchemaFileSource(sources, allTypes, helpersImportPath) {
   }
   const allSchemaCode = schemaBlocks.join("\n");
   if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
-    lines.push(`import { coerceNumber, coerceBoolean } from '${helpersImportPath}';`);
+    lines.push(
+      `import { coerceNumber, coerceBoolean, coerceMap, coerceSet } from '${helpersImportPath}';`
+    );
   }
   lines.push("");
   lines.push(...schemaBlocks);
   return lines.join("\n").replace(/\n+$/, "\n");
 }
-async function generateSchemaFiles(routes, rootDir, appDir, outDir) {
+async function generateSchemaFiles(routes, rootDir, dist) {
   if (routes.length === 0) return;
   const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
   const sourcesByFile = /* @__PURE__ */ new Map();
@@ -1497,11 +1744,11 @@ async function generateSchemaFiles(routes, rootDir, appDir, outDir) {
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
     const relFile = path6.relative(rootDir, filePath).replace(/\\/g, "/");
-    const outputPath = getSchemaOutputPath(relFile, appDir, outDir, rootDir);
+    const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
-    if (appDir !== "." && relForDir.startsWith(`${appDir}/`)) {
-      relForDir = relForDir.slice(appDir.length + 1);
+    if (relForDir.startsWith("src/")) {
+      relForDir = relForDir.slice(4);
     }
     const dirIdx = relForDir.lastIndexOf("/");
     const zodRelDir = dirIdx >= 0 ? relForDir.slice(0, dirIdx) : "";
@@ -1511,7 +1758,7 @@ async function generateSchemaFiles(routes, rootDir, appDir, outDir) {
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path6.resolve(rootDir, outDir, HELPERS_FILENAME);
+    const helpersPath = path6.resolve(rootDir, dist, HELPERS_FILENAME);
     await writeSchemaFile(helpersPath, generateHelpersFileSource());
   }
   await Promise.all(
@@ -1604,20 +1851,20 @@ var init_loadMiddlewares = __esm({
 // src/cli/generateRoutes.ts
 import fs6 from "fs";
 import path7 from "path";
-function toProdFilePath(filePath, appDir, prodDir) {
+function toProdFilePath(filePath, dist) {
   let rel = filePath.replace(/\\/g, "/");
-  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
-    rel = rel.slice(appDir.length + 1);
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
   }
   const jsPath = rel.replace(/\.ts$/, ".js");
-  return jsPath.startsWith(`${prodDir}/`) ? jsPath : `${prodDir}/${jsPath}`;
+  return jsPath.startsWith(`${dist}/`) ? jsPath : `${dist}/${jsPath}`;
 }
-function serializeRoutes(routes, wsRoutes, rootDir, appDir = "src", prodDir = "dist") {
+function serializeRoutes(routes, wsRoutes, rootDir, dist = "dist") {
   const serialize = (route) => {
-    const middlewarePaths = extractMiddlewarePaths(route.filePath, rootDir, appDir, prodDir);
+    const middlewarePaths = extractMiddlewarePaths(route.filePath, rootDir, dist);
     const serialized = {
       urlPath: route.urlPath,
-      filePath: toProdFilePath(route.filePath, appDir, prodDir),
+      filePath: toProdFilePath(route.filePath, dist),
       paramNames: route.paramNames,
       isDynamic: route.isDynamic,
       isCatchAll: route.isCatchAll,
@@ -1633,7 +1880,7 @@ function serializeRoutes(routes, wsRoutes, rootDir, appDir = "src", prodDir = "d
     wsRoutes: wsRoutes.map(serialize)
   };
 }
-function extractMiddlewarePaths(routeFilePath, rootDir, appDir, prodDir) {
+function extractMiddlewarePaths(routeFilePath, rootDir, dist) {
   const routeDir = path7.dirname(routeFilePath);
   const resolvedRoot = path7.resolve(rootDir);
   const paths = [];
@@ -1646,7 +1893,7 @@ function extractMiddlewarePaths(routeFilePath, rootDir, appDir, prodDir) {
     const absMwPath = fs6.existsSync(absTsPath) ? absTsPath : fs6.existsSync(absJsPath) ? absJsPath : null;
     if (absMwPath) {
       const relMwPath = path7.relative(rootDir, absMwPath);
-      const prodAbsPath = path7.resolve(rootDir, toProdFilePath(relMwPath, appDir, prodDir));
+      const prodAbsPath = path7.resolve(rootDir, toProdFilePath(relMwPath, dist));
       paths.push(prodAbsPath);
     }
     if (currentDir === resolvedRoot) break;
@@ -1776,8 +2023,8 @@ function isCatchAllSegment(segment) {
 function isRouteGroup(segment) {
   return /^\(.+\)$/.test(segment);
 }
-function filePathToUrlPath(filePath, appDir = ".") {
-  const withoutPrefix = filePath.startsWith(appDir + "/") ? filePath.slice(appDir.length + 1) : filePath;
+function filePathToUrlPath(filePath) {
+  const withoutPrefix = filePath.startsWith("src/") ? filePath.slice(4) : filePath;
   const lastSlashIndex = withoutPrefix.lastIndexOf("/");
   const dirPath = lastSlashIndex === -1 ? "" : withoutPrefix.slice(0, lastSlashIndex);
   if (!dirPath) {
@@ -1797,24 +2044,24 @@ var init_parseRouteFile = __esm({
 import fg2 from "fast-glob";
 import path8 from "path";
 import fs7 from "fs";
-function toProdAbsPath(sourceAbsPath, rootDir, appDir, prodDir) {
+function toProdAbsPath(sourceAbsPath, rootDir, dist) {
   let rel = path8.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
-  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
-    rel = rel.slice(appDir.length + 1);
+  if (rel.startsWith(`${APP_DIR3}/`)) {
+    rel = rel.slice(APP_DIR3.length + 1);
   }
-  const prodRel = `${prodDir}/${rel.replace(/\.ts$/, ".js")}`;
+  const prodRel = `${dist}/${rel.replace(/\.ts$/, ".js")}`;
   return path8.resolve(rootDir, prodRel);
 }
-async function findMergedMiddlewares(routeFilePath, rootDir, appDir, prodDir) {
+async function findMergedMiddlewares(routeFilePath, rootDir, dist) {
   const routeDir = path8.dirname(routeFilePath);
   const resolvedRoot = path8.resolve(rootDir);
   const mwPaths = [];
   let currentDir = path8.resolve(rootDir, routeDir);
   while (true) {
-    if (prodDir) {
+    if (dist) {
       const mwPath = path8.join(currentDir, "middlewares.js");
       const absMwPath = path8.resolve(rootDir, mwPath);
-      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, appDir, prodDir);
+      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, dist);
       if (fs7.existsSync(prodAbsMwPath)) {
         mwPaths.push(prodAbsMwPath);
       }
@@ -1879,8 +2126,7 @@ async function hasWsExport(absPath) {
     return false;
   }
 }
-async function scanRoutes(rootDir, patterns, appDir, prodDir) {
-  const dir = appDir ?? ".";
+async function scanRoutes(rootDir, patterns, dist) {
   const files = await fg2(patterns, {
     cwd: rootDir,
     onlyFiles: true,
@@ -1893,12 +2139,12 @@ async function scanRoutes(rootDir, patterns, appDir, prodDir) {
     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 importPath = dist ? toProdAbsPath(absPath, rootDir, dist) : absPath;
+      const urlPath = filePathToUrlPath(normalizedFile);
       const paramNames = extractParamNames(urlPath);
       const isDynamic = paramNames.length > 0;
       const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
-      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, dir, prodDir);
+      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, dist);
       const methods = await extractMethodsFromHandler(importPath);
       for (const method of methods) {
         routes.push({
@@ -1929,6 +2175,7 @@ async function scanRoutes(rootDir, patterns, appDir, prodDir) {
   }
   return { routes, wsRoutes };
 }
+var APP_DIR3;
 var init_scanRoutes = __esm({
   "src/router/scanRoutes.ts"() {
     "use strict";
@@ -1936,6 +2183,7 @@ var init_scanRoutes = __esm({
     init_parseRouteFile();
     init_loadMiddlewares();
     init_importWithCacheBust();
+    APP_DIR3 = "src";
   }
 });
 
@@ -1965,8 +2213,8 @@ var init_sortRoutes = __esm({
 // src/config/loadConfig.ts
 import path9 from "path";
 import fs8 from "fs";
-async function loadConfig(rootDir, outDir) {
-  const configProductPath = path9.resolve(rootDir, outDir, CONFIG_PRODUCT_FILE);
+async function loadConfig(rootDir, dist) {
+  const configProductPath = path9.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
   if (fs8.existsSync(configProductPath)) {
     const module = await importWithCacheBust(configProductPath);
     return module.default ?? {};
@@ -1974,7 +2222,7 @@ async function loadConfig(rootDir, outDir) {
   const hasSourceConfig = fs8.existsSync(path9.join(rootDir, "faapi.config.ts")) || fs8.existsSync(path9.join(rootDir, "faapi.config.js"));
   if (hasSourceConfig) {
     throw new Error(
-      `[faapi] ${outDir}/${CONFIG_PRODUCT_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
+      `[faapi] ${dist}/${CONFIG_PRODUCT_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
   }
   return null;
@@ -3700,7 +3948,7 @@ var init_esm2 = __esm({
 // src/cli/watcher.ts
 import path10 from "path";
 function startWatcher(options) {
-  const { rootDir, appDir, app } = options;
+  const { rootDir, app, devDist } = options;
   let rebuildTimer = null;
   let pendingFiles = /* @__PURE__ */ new Set();
   async function rebuildRoutes() {
@@ -3710,12 +3958,11 @@ function startWatcher(options) {
       if (filesToCompile.length > 0) {
         await compileDevRoutes({
           rootDir,
-          appDir,
-          outDir: DEV_OUT_DIR,
+          dist: devDist,
           files: filesToCompile
         });
       }
-      await compileConfig({ rootDir, outDir: DEV_OUT_DIR });
+      await compileConfig({ rootDir, dist: devDist });
       await app.reloadRoutes();
       const recompiledCount = filesToCompile.length;
       console.log(
@@ -3738,12 +3985,12 @@ function startWatcher(options) {
     "faapi.config.production.ts",
     "faapi.config.production.js"
   ];
-  const watchPaths = [appDir, ...CONFIG_FILES];
+  const watchPaths = ["src", ...CONFIG_FILES];
   const watcher = esm_default.watch(watchPaths, {
     cwd: rootDir,
     ignoreInitial: true,
     ignored: (filePath, stats) => {
-      if (filePath.includes("node_modules") || filePath.includes(".faapi") || filePath.includes("dist") || filePath.includes(".git")) {
+      if (filePath.includes("node_modules") || filePath.includes(".faapi") || filePath.includes(devDist) || filePath.includes(".git")) {
         return true;
       }
       if (!stats) return false;
@@ -3773,14 +4020,12 @@ function startWatcher(options) {
   });
   console.log("- Watch mode enabled");
 }
-var DEV_OUT_DIR;
 var init_watcher = __esm({
   "src/cli/watcher.ts"() {
     "use strict";
     init_esm2();
     init_compileDevRoutes();
     init_compileConfig();
-    DEV_OUT_DIR = ".faapi/dev";
   }
 });
 
@@ -4473,6 +4718,10 @@ function getBuiltinInjectionValue(type, ctx, body) {
       return ctx.ip;
     case "body":
       return body;
+    // form 与 body 共享解析结果（resolveInput 已按 Content-Type 解析 form-urlencoded）
+    // 差异仅在 schema 校验（form coerce=true，由 collectRouteSchemaSources 标记）
+    case "form":
+      return body;
     case "files":
       if (body && typeof body === "object" && "files" in body) {
         return body.files;
@@ -4891,6 +5140,44 @@ var init_helmet = __esm({
   }
 });
 
+// src/middleware/logger.ts
+function logger(options = {}) {
+  return async (ctx, next) => {
+    const log = options.log ?? console.log;
+    const start = Date.now();
+    try {
+      const response = await next();
+      const duration = Date.now() - start;
+      const entry = {
+        method: ctx.method,
+        path: ctx.path,
+        status: response.status,
+        durationMs: duration
+      };
+      log(entry, `${ctx.method} ${ctx.path} ${response.status} ${duration}ms`);
+      return response;
+    } catch (err) {
+      const duration = Date.now() - start;
+      const message = err instanceof Error ? err.message : String(err);
+      const status = err?.statusCode ?? 500;
+      const entry = {
+        method: ctx.method,
+        path: ctx.path,
+        status,
+        durationMs: duration,
+        error: message
+      };
+      log(entry, `${ctx.method} ${ctx.path} ${status} ${duration}ms - ${message}`);
+      throw err;
+    }
+  };
+}
+var init_logger = __esm({
+  "src/middleware/logger.ts"() {
+    "use strict";
+  }
+});
+
 // src/errors/formatErrorResponse.ts
 function formatErrorResponse(error) {
   if (error instanceof ValidationError) {
@@ -5210,8 +5497,7 @@ function createServer(options) {
   const {
     routes,
     rootDir,
-    appDir,
-    outDir,
+    dist,
     cors: corsOption,
     onError,
     config,
@@ -5219,6 +5505,7 @@ function createServer(options) {
     middlewares: globalMiddlewares,
     injectors: globalInjectors,
     helmet: helmetOption,
+    logger: loggerOption,
     bodyLimit = DEFAULT_BODY_LIMIT,
     http2: http2Option
   } = options;
@@ -5230,6 +5517,8 @@ function createServer(options) {
     const helmOpts = typeof helmetOption === "object" ? helmetOption : {};
     configMiddlewares.push(helmet(helmOpts));
   }
+  const loggerMiddlewareInst = loggerOption === false ? null : loggerOption === true || loggerOption === void 0 ? logger() : logger(loggerOption);
+  if (loggerMiddlewareInst) configMiddlewares.push(loggerMiddlewareInst);
   const server = (() => {
     if (http2Option) {
       const h2Opts = typeof http2Option === "object" ? http2Option : {};
@@ -5246,8 +5535,7 @@ function createServer(options) {
     handleRequest(
       currentRoutes,
       rootDir,
-      appDir,
-      outDir,
+      dist,
       req,
       res,
       configMiddlewares,
@@ -5266,7 +5554,7 @@ function createServer(options) {
   }
   return { server, routesRef };
 }
-async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+async function handleRequest(routes, rootDir, dist, 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;
@@ -5287,7 +5575,7 @@ async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMi
     const routeModule = await loadRouteModule(absoluteFilePath, route.method);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
-    const schemaPath = getRuntimeSchemaPath(route.filePath, appDir, outDir, rootDir);
+    const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
     const result = await validateInput(schemaPath, route.method, inputType, input);
     if (!result.valid) {
       throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", result.issues);
@@ -5343,6 +5631,7 @@ var init_createServer = __esm({
     init_getClientIp();
     init_cors();
     init_helmet();
+    init_logger();
     init_handleWsUpgrade();
     init_serverUtils();
     init_generateSchemaFiles();
@@ -5456,16 +5745,14 @@ 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 = path13.resolve(rootDir, outDir, ROUTES_FILE);
+  const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
+  const routesPath = path13.resolve(rootDir, dist, 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`
+      `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
   }
-  const config = await loadConfig(rootDir, outDir);
-  const appDir = options?.appDir ?? process.env.FAAPI_APP_DIR ?? DEFAULT_APP_DIR;
-  const patterns = appDir === "." ? ["api/**/*.ts"] : [`${appDir}/api/**/*.ts`];
+  const config = await loadConfig(rootDir, dist);
   const serialized = await importWithCacheBust(routesPath);
   const hydrated = await hydrateRoutes(serialized);
   let sorted = sortRoutes(hydrated.routes);
@@ -5483,8 +5770,7 @@ async function createAppBase(options) {
   const { server, routesRef } = createServer({
     routes: sorted,
     rootDir,
-    appDir,
-    outDir,
+    dist,
     cors: config?.cors ?? true,
     onError: config?.lifecycle?.onError,
     config: config ?? void 0,
@@ -5492,6 +5778,7 @@ async function createAppBase(options) {
     middlewares: config?.middlewares,
     injectors: config?.injectors,
     helmet: config?.helmet,
+    logger: config?.logger,
     bodyLimit: config?.bodyLimit,
     http2: config?.http2
   });
@@ -5644,9 +5931,8 @@ async function createAppBase(options) {
   };
   const ctx = {
     rootDir,
-    appDir,
-    outDir,
-    patterns,
+    dist,
+    patterns: PATTERNS,
     server,
     routesRef,
     config,
@@ -5661,7 +5947,7 @@ async function createAppBase(options) {
   };
   return { app, ctx };
 }
-var DEFAULT_OUT_DIR, DEFAULT_APP_DIR, DEFAULT_PORT, ROUTES_FILE, FAAPI_CONFIG_KEYS;
+var DEFAULT_DIST, DEFAULT_PORT, ROUTES_FILE, PATTERNS, FAAPI_CONFIG_KEYS;
 var init_createAppCore = __esm({
   "src/cli/createAppCore.ts"() {
     "use strict";
@@ -5673,10 +5959,10 @@ var init_createAppCore = __esm({
     init_generateRoutes();
     init_loadPlugins();
     init_importWithCacheBust();
-    DEFAULT_OUT_DIR = "dist";
-    DEFAULT_APP_DIR = "src";
+    DEFAULT_DIST = "dist";
     DEFAULT_PORT = 3e3;
     ROUTES_FILE = "faapi-routes.js";
+    PATTERNS = ["src/api/**/*.ts"];
     FAAPI_CONFIG_KEYS = /* @__PURE__ */ new Set([
       "cors",
       "lifecycle",
@@ -5701,9 +5987,9 @@ async function createDevApp(options) {
     invalidateMiddlewareCache();
     invalidateProgramCache();
     invalidateSchemaCache();
-    const reScanned = await scanRoutes(ctx.rootDir, ctx.patterns, ctx.appDir, ctx.outDir);
+    const reScanned = await scanRoutes(ctx.rootDir, ctx.patterns, ctx.dist);
     const sorted = sortRoutes(reScanned.routes);
-    await generateSchemaFiles(sorted, ctx.rootDir, ctx.appDir, ctx.outDir);
+    await generateSchemaFiles(sorted, ctx.rootDir, ctx.dist);
     ctx.updateRoutes(sorted, reScanned.wsRoutes);
   };
   return devApp;
@@ -5729,34 +6015,33 @@ __export(devCommand_exports, {
   generateRouteArtifacts: () => generateRouteArtifacts
 });
 import path14 from "path";
-async function devCommand() {
+async function devCommand(options) {
   const rootDir = process.cwd();
-  process.env.FAAPI_OUT_DIR = DEV_OUT_DIR2;
+  const devDist = DEV_DIST;
+  process.env.FAAPI_DIST = devDist;
   if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
   console.log("- Development mode");
   console.log("- Compiling config...");
-  await compileConfig({ rootDir, outDir: DEV_OUT_DIR2 });
-  const _config = await loadConfig(rootDir, DEV_OUT_DIR2);
-  const appDir = process.env.FAAPI_APP_DIR ?? "src";
-  const patterns = appDir === "." ? ["api/**/*.ts"] : [`${appDir}/api/**/*.ts`];
+  await compileConfig({ rootDir, dist: devDist });
+  const _config = await loadConfig(rootDir, devDist);
   console.log("- Compiling TypeScript...");
-  await compileDevRoutes({ rootDir, appDir, outDir: DEV_OUT_DIR2 });
+  await compileDevRoutes({ rootDir, dist: devDist });
   console.log("- Generating route manifest and schema...");
-  await generateRouteArtifacts(rootDir, appDir, patterns);
+  await generateRouteArtifacts(rootDir, PATTERNS2, devDist);
   console.log("- Starting dev app...");
-  const app = await createDevApp({ rootDir });
+  const app = await createDevApp({ rootDir, port: options?.port });
   await app.listen();
-  startWatcher({ rootDir, appDir, app });
+  startWatcher({ rootDir, app, devDist });
 }
-async function generateRouteArtifacts(rootDir, appDir, patterns) {
-  const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir, DEV_OUT_DIR2);
+async function generateRouteArtifacts(rootDir, patterns, dist) {
+  const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, dist);
   const sorted = sortRoutes(routes);
-  const routesPath = path14.resolve(rootDir, DEV_OUT_DIR2, ROUTES_FILE2);
-  const serialized = serializeRoutes(sorted, wsRoutes, rootDir, appDir, DEV_OUT_DIR2);
+  const routesPath = path14.resolve(rootDir, dist, ROUTES_FILE2);
+  const serialized = serializeRoutes(sorted, wsRoutes, rootDir, dist);
   await writeRoutesModule(serialized, routesPath);
-  await generateSchemaFiles(sorted, rootDir, appDir, DEV_OUT_DIR2);
+  await generateSchemaFiles(sorted, rootDir, dist);
 }
-var DEV_OUT_DIR2, ROUTES_FILE2;
+var DEV_DIST, ROUTES_FILE2, PATTERNS2;
 var init_devCommand = __esm({
   "src/cli/devCommand.ts"() {
     "use strict";
@@ -5769,54 +6054,54 @@ var init_devCommand = __esm({
     init_loadConfig();
     init_watcher();
     init_createDevApp();
-    DEV_OUT_DIR2 = ".faapi/dev";
+    DEV_DIST = ".faapi";
     ROUTES_FILE2 = "faapi-routes.js";
+    PATTERNS2 = ["src/api/**/*.ts"];
   }
 });
 
 // src/cli/compileBuildRoutes.ts
 import path15 from "path";
 import fs10 from "fs";
+import fg3 from "fast-glob";
 async function compileBuildRoutes(options) {
-  const {
-    rootDir,
-    appDir,
-    outDir,
-    entries,
-    splitting = true,
-    define,
-    minifySyntax = true,
-    logLevel = "silent"
-  } = options;
-  if (entries.length === 0) {
+  const { rootDir, dist, files, logLevel = "silent" } = options;
+  const entryPoints = files ?? await fg3([`${APP_DIR4}/**/*.ts`], {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
+  });
+  if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absOutDir = path15.resolve(rootDir, outDir);
-  await fs10.promises.mkdir(absOutDir, { recursive: true });
+  const absDist = path15.resolve(rootDir, dist);
+  await fs10.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = appDir === "." ? rootDir : path15.resolve(rootDir, appDir);
+  const outbase = path15.resolve(rootDir, APP_DIR4);
   await esbuild.build({
-    entryPoints: entries,
-    outdir: absOutDir,
+    entryPoints,
+    outdir: absDist,
     outbase,
-    bundle: true,
-    splitting,
+    bundle: false,
     platform: "node",
     format: "esm",
     sourcemap: true,
     packages: "external",
     plugins,
-    define,
-    minifySyntax,
+    define: { "process.env.NODE_ENV": '"production"' },
+    minifySyntax: true,
     logLevel
   });
-  return { compiledFiles: entries };
+  return { compiledFiles: entryPoints };
 }
+var APP_DIR4;
 var init_compileBuildRoutes = __esm({
   "src/cli/compileBuildRoutes.ts"() {
     "use strict";
     init_aliasPlugin();
+    APP_DIR4 = "src";
   }
 });
 
@@ -5827,66 +6112,35 @@ __export(buildCommand_exports, {
 });
 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 outdir = options?.dist ?? DEFAULT_DIST2;
+  await compileConfig({ rootDir, dist: 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(`- Source: src/`);
   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)...");
+  console.log("\n[1/6] Compiling TypeScript (bundle: false)...");
   const result = await compileBuildRoutes({
     rootDir,
-    appDir,
-    outDir: outdir,
-    entries,
-    splitting: true,
-    define: { "process.env.NODE_ENV": JSON.stringify("production") },
-    minifySyntax: true,
+    dist: outdir,
     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 });
+  console.log(`  Compiled ${result.compiledFiles.length} file(s)`);
+  if (result.compiledFiles.length === 0) {
+    console.warn("  ! No source files found, nothing to build");
+    return;
+  }
+  console.log("\n[2/6] Compiling config...");
+  const configResult = await compileConfig({ rootDir, dist: 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);
+  console.log("\n[3/6] Scanning routes...");
+  const { routes, wsRoutes } = await scanRoutes(rootDir, PATTERNS3, outdir);
   const sorted = sortRoutes(routes);
   console.log(`  Found ${sorted.length} routes, ${wsRoutes.length} WS routes`);
   const conflicts = detectRouteConflicts(sorted);
@@ -5899,27 +6153,28 @@ async function buildCommand(options) {
       }
     }
   }
-  console.log("\n[5/7] Generating schema...");
-  await generateSchemaFiles(sorted, rootDir, appDir, outdir);
+  console.log("\n[4/6] Generating schema...");
+  await generateSchemaFiles(sorted, rootDir, outdir);
   console.log(`  Schema: zod.js files under ${path16.resolve(rootDir, outdir)}`);
-  console.log("\n[6/7] Generating routes manifest...");
+  console.log("\n[5/6] Generating routes manifest...");
   const routesPath = path16.resolve(rootDir, outdir, "faapi-routes.js");
-  const serialized = serializeRoutes(sorted, wsRoutes, rootDir, appDir, outdir);
+  const serialized = serializeRoutes(sorted, wsRoutes, rootDir, outdir);
   await writeRoutesModule(serialized, routesPath);
   console.log(`  Written to ${routesPath}`);
-  console.log("\n[7/7] Generating entry file...");
+  console.log("\n[6/6] Generating entry file...");
   const mainPath = path16.resolve(rootDir, outdir, "main.js");
+  const createProdAppArgs = options?.dist && options.dist !== DEFAULT_DIST2 ? `{ dist: '${outdir}' }` : "";
   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();
+const app = await createProdApp(${createProdAppArgs});
 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 DEFAULT_DIST2, PATTERNS3;
 var init_buildCommand = __esm({
   "src/cli/buildCommand.ts"() {
     "use strict";
@@ -5931,7 +6186,8 @@ var init_buildCommand = __esm({
     init_compileBuildRoutes();
     init_compileConfig();
     init_loadConfig();
-    PROD_OUT_DIR = "dist";
+    DEFAULT_DIST2 = "dist";
+    PATTERNS3 = ["src/api/**/*.ts"];
   }
 });
 
@@ -6522,13 +6778,13 @@ var cac = (name = "") => new CAC(name);
 
 // src/cli/index.ts
 var cli = cac("faapi");
-cli.command("").alias("dev").action(async () => {
+cli.command("").alias("dev").option("--port <number>", "\u670D\u52A1\u7AEF\u53E3\uFF08\u9ED8\u8BA4 3000\uFF09").action(async (options) => {
   const { devCommand: devCommand2 } = await Promise.resolve().then(() => (init_devCommand(), devCommand_exports));
-  await devCommand2();
+  await devCommand2(options);
 });
-cli.command("build", "Build for production").action(async () => {
+cli.command("build", "Build for production").option("--dist <dir>", "\u4EA7\u7269\u8F93\u51FA\u76EE\u5F55\uFF0C\u9ED8\u8BA4 dist").action(async (options) => {
   const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_buildCommand(), buildCommand_exports));
-  await buildCommand2();
+  await buildCommand2(options);
 });
 cli.help();
 cli.parse();