@faapi/faapi 1.1.1 → 1.2.1

package/dist/index.js

@@ -1,6 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/ast/createProgram.ts
 import ts from "typescript";
-var programCache = /* @__PURE__ */ new Map();
 function invalidateProgramCache() {
   programCache.clear();
 }
@@ -20,22 +29,16 @@ function createProgram(filePath) {
   programCache.set(filePath, program);
   return program;
 }
-
-// src/ast/extractHandlerTypes.ts
-import ts3 from "typescript";
+var programCache;
+var init_createProgram = __esm({
+  "src/ast/createProgram.ts"() {
+    "use strict";
+    programCache = /* @__PURE__ */ new Map();
+  }
+});
 
 // src/ast/resolveTypeNode.ts
 import ts2 from "typescript";
-var 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;
-};
 function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
   const kind = typeNode.kind;
   switch (kind) {
@@ -415,26 +418,6 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
   }
   return { kind: "object", properties };
 }
-var NUMBER_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
-  "max",
-  "min",
-  "int",
-  "positive",
-  "negative",
-  "nonnegative",
-  "nonpositive"
-]);
-var LENGTH_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
-  "maxLength",
-  "minLength",
-  "length"
-]);
-var STRING_FORMAT_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
-  "regex",
-  "email",
-  "url",
-  "uuid"
-]);
 function extractConstraintsFromJsDoc(node, fieldName) {
   const jsDocs = ts2.getJSDocCommentsAndTags(node).filter((entry) => ts2.isJSDoc(entry));
   if (jsDocs.length === 0) return [];
@@ -551,8 +534,45 @@ function validateConstraints(constraints, type, fieldName) {
     }
   }
 }
+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";
 function extractTypeInfo(program, filePath, typeName) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
@@ -648,6 +668,12 @@ function withFileContext(filePath, typeName, fn) {
     throw err;
   }
 }
+var init_extractHandlerTypes = __esm({
+  "src/ast/extractHandlerTypes.ts"() {
+    "use strict";
+    init_resolveTypeNode();
+  }
+});
 
 // src/runtime/inputType.ts
 function getInputTypeForMethod(method) {
@@ -661,32 +687,24 @@ function hasBody(method) {
   const upper = method.toUpperCase();
   return upper === "POST" || upper === "PUT" || upper === "PATCH" || upper === "DELETE";
 }
+var init_inputType = __esm({
+  "src/runtime/inputType.ts"() {
+    "use strict";
+  }
+});
 
 // src/validator/schemaName.ts
 function getSchemaName(method, inputType) {
   return `${method.toUpperCase()}${inputType.charAt(0).toUpperCase() + inputType.slice(1)}`;
 }
-
-// src/injection/analyzeInjection.ts
-import ts5 from "typescript";
+var init_schemaName = __esm({
+  "src/validator/schemaName.ts"() {
+    "use strict";
+  }
+});
 
 // src/injection/resolveInjection.ts
 import ts4 from "typescript";
-var PARAM_TYPE_MAP = {
-  query: "query",
-  body: "body",
-  form: "form",
-  headers: "headers",
-  params: "params",
-  context: "context",
-  ctx: "context",
-  // 别名
-  cookies: "cookies",
-  ip: "ip",
-  ua: "ua",
-  files: "files",
-  fields: "fields"
-};
 function resolveInjection(fn) {
   const fnStr = fn.toString();
   const params = extractParamsWithAst(fnStr);
@@ -755,8 +773,30 @@ function extractParamName(param, names) {
     return;
   }
 }
+var PARAM_TYPE_MAP;
+var init_resolveInjection = __esm({
+  "src/injection/resolveInjection.ts"() {
+    "use strict";
+    PARAM_TYPE_MAP = {
+      query: "query",
+      body: "body",
+      form: "form",
+      headers: "headers",
+      params: "params",
+      context: "context",
+      ctx: "context",
+      // 别名
+      cookies: "cookies",
+      ip: "ip",
+      ua: "ua",
+      files: "files",
+      fields: "fields"
+    };
+  }
+});
 
 // src/injection/analyzeInjection.ts
+import ts5 from "typescript";
 function analyzeInjection(code, functionName) {
   const sourceFile = ts5.createSourceFile("temp.ts", code, ts5.ScriptTarget.Latest, true);
   const params = [];
@@ -799,6 +839,12 @@ function extractSchema(typeNode, sourceFile) {
   }
   return schema;
 }
+var init_analyzeInjection = __esm({
+  "src/injection/analyzeInjection.ts"() {
+    "use strict";
+    init_resolveInjection();
+  }
+});
 
 // src/cli/collectRouteSchemaSources.ts
 import path from "path";
@@ -848,192 +894,632 @@ function collectRouteSchemaSources(routes, rootDir) {
   }
   return { sources, allTypesByFile, mergedAllTypes };
 }
+var init_collectRouteSchemaSources = __esm({
+  "src/cli/collectRouteSchemaSources.ts"() {
+    "use strict";
+    init_createProgram();
+    init_extractHandlerTypes();
+    init_inputType();
+    init_schemaName();
+    init_analyzeInjection();
+  }
+});
 
-// src/middleware/cors.ts
-var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
-function cors(options = {}) {
-  const {
-    origin = true,
-    methods = DEFAULT_METHODS,
-    allowedHeaders,
-    exposeHeaders,
-    credentials = false,
-    maxAge
-  } = options;
-  return async (ctx, next) => {
-    const reqOrigin = ctx.headers.get("origin");
-    if (!reqOrigin) {
-      await next();
+// src/ast/generateZodSchema.ts
+function collectNamedTypes(type, ctx) {
+  switch (type.kind) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "null":
+    case "undefined":
+    case "any":
+    case "unknown":
+    case "literal":
+    case "date":
       return;
-    }
-    let allowOrigin = null;
-    if (origin === true) {
-      allowOrigin = reqOrigin;
-    } else if (typeof origin === "string") {
-      allowOrigin = reqOrigin === origin ? origin : null;
-    } else if (Array.isArray(origin)) {
-      allowOrigin = origin.includes(reqOrigin) ? reqOrigin : null;
-    }
-    if (!allowOrigin) {
-      await next();
+    case "array":
+      collectNamedTypes(type.element, ctx);
       return;
-    }
-    ctx.setHeader("Access-Control-Allow-Origin", allowOrigin);
-    if (origin === true || Array.isArray(origin)) {
-      const existingVary = ctx.headers.get("vary");
-      if (existingVary) {
-        if (!existingVary.toLowerCase().includes("origin")) {
-          ctx.setHeader("Vary", `${existingVary}, Origin`);
-        }
-      } else {
-        ctx.setHeader("Vary", "Origin");
+    case "tuple":
+      for (const el of type.elements) {
+        collectNamedTypes(el.type, ctx);
       }
-    }
-    ctx.setHeader("Access-Control-Allow-Methods", methods.join(", "));
-    if (allowedHeaders) {
-      ctx.setHeader("Access-Control-Allow-Headers", allowedHeaders.join(", "));
-    } else {
-      const requestHeaders = ctx.headers.get("access-control-request-headers");
-      if (requestHeaders) {
-        ctx.setHeader("Access-Control-Allow-Headers", requestHeaders);
+      return;
+    case "object":
+      for (const prop of type.properties) {
+        collectNamedTypes(prop.type, ctx);
       }
+      return;
+    case "union":
+      for (const member of type.members) {
+        collectNamedTypes(member, ctx);
+      }
+      return;
+    case "record":
+      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" });
+      const resolved = ctx.resolveType(type.name);
+      if (resolved) {
+        ctx.namedTypes.set(type.name, resolved);
+        collectNamedTypes(resolved, ctx);
+      }
+      return;
     }
-    if (exposeHeaders && exposeHeaders.length > 0) {
-      ctx.setHeader("Access-Control-Expose-Headers", exposeHeaders.join(", "));
-    }
-    if (credentials) {
-      ctx.setHeader("Access-Control-Allow-Credentials", "true");
-    }
-    if (maxAge !== void 0) {
-      ctx.setHeader("Access-Control-Max-Age", String(maxAge));
-    }
-    if (ctx.method === "OPTIONS") {
-      return new Response(null, { status: 204 });
-    }
-    await next();
-  };
-}
-
-// 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;
-    }
-  };
-}
-
-// src/middleware/helmet.ts
-var DEFAULTS = {
-  contentSecurityPolicy: "default-src 'self'",
-  xFrameOptions: "SAMEORIGIN",
-  xContentTypeOptions: true,
-  referrerPolicy: "no-referrer",
-  strictTransportSecurity: "max-age=31536000; includeSubDomains",
-  xDnsPrefetchControl: true,
-  xDownloadOptions: true,
-  xPermittedCrossDomainPolicies: "none",
-  crossOriginOpenerPolicy: "same-origin",
-  crossOriginResourcePolicy: "same-origin",
-  crossOriginEmbedderPolicy: false,
-  originAgentCluster: true,
-  xPoweredBy: true
-};
-function helmet(options = {}) {
-  const opts = { ...DEFAULTS, ...options };
-  return async (ctx, next) => {
-    if (opts.contentSecurityPolicy !== false) {
-      ctx.setHeader("Content-Security-Policy", opts.contentSecurityPolicy);
-    }
-    if (opts.xFrameOptions !== false) {
-      ctx.setHeader("X-Frame-Options", opts.xFrameOptions);
-    }
-    if (opts.xContentTypeOptions) {
-      ctx.setHeader("X-Content-Type-Options", "nosniff");
-    }
-    if (opts.referrerPolicy !== false) {
-      ctx.setHeader("Referrer-Policy", opts.referrerPolicy);
-    }
-    if (opts.strictTransportSecurity !== false) {
-      ctx.setHeader("Strict-Transport-Security", opts.strictTransportSecurity);
-    }
-    if (opts.xDnsPrefetchControl) {
-      ctx.setHeader("X-DNS-Prefetch-Control", "off");
-    }
-    if (opts.xDownloadOptions) {
-      ctx.setHeader("X-Download-Options", "noopen");
-    }
-    if (opts.xPermittedCrossDomainPolicies !== false) {
-      ctx.setHeader("X-Permitted-Cross-Domain-Policies", opts.xPermittedCrossDomainPolicies);
-    }
-    if (opts.crossOriginOpenerPolicy !== false) {
-      ctx.setHeader("Cross-Origin-Opener-Policy", opts.crossOriginOpenerPolicy);
-    }
-    if (opts.crossOriginResourcePolicy !== false) {
-      ctx.setHeader("Cross-Origin-Resource-Policy", opts.crossOriginResourcePolicy);
-    }
-    if (opts.crossOriginEmbedderPolicy !== false) {
-      ctx.setHeader("Cross-Origin-Embedder-Policy", opts.crossOriginEmbedderPolicy);
-    }
-    if (opts.originAgentCluster) {
-      ctx.setHeader("Origin-Agent-Cluster", "?1");
-    }
-    if (opts.xPoweredBy) {
-      ctx.setHeader("X-Powered-By", "faapi");
-    }
-    return await next();
-  };
-}
-
-// src/config/loadConfig.ts
-import path2 from "path";
-import fs from "fs";
-
-// src/utils/importWithCacheBust.ts
-import { pathToFileURL } from "url";
-var loadTs;
-function setLoadTimestamp(ts6) {
-  loadTs = ts6;
-}
-function getVitestImportActual() {
-  const vi = globalThis.vi;
-  if (typeof vi?.importActual !== "function") return void 0;
-  return vi.importActual.bind(vi);
-}
-async function importWithCacheBust(filePath) {
-  const importActual = getVitestImportActual();
-  if (importActual) {
-    return await importActual(filePath);
   }
-  let url = pathToFileURL(filePath).href;
-  if (loadTs !== void 0) {
-    url += `?t=${loadTs}`;
+}
+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, withConstraints);
   }
-  return await import(url);
+  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()";
+  }
+}
+function baseExpression(type, ctx) {
+  switch (type.kind) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "bigint":
+      return "z.never()";
+    case "null":
+      return "z.null()";
+    case "undefined":
+      return "z.undefined()";
+    case "any":
+    case "unknown":
+      return "z.unknown()";
+    case "literal":
+      return `z.literal(${JSON.stringify(type.value)})`;
+    case "array":
+      return `z.array(${runtimeTypeToZodExpression(type.element, ctx)})`;
+    case "tuple":
+      return generateTupleExpression(type.elements, ctx);
+    case "object":
+      return generateObjectExpression(type.properties, ctx);
+    case "union":
+      return generateUnionExpression(type.members, ctx);
+    case "date":
+      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`;
+      }
+      return `${type.name}Schema`;
+  }
+}
+function generateHelpersFileSource() {
+  return [
+    "// 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") || code.includes("coerceMap") || code.includes("coerceSet");
+}
+function wrapCoercePreprocess(kind, inner) {
+  if (kind === "number") {
+    return `z.preprocess(coerceNumber, ${inner})`;
+  }
+  return `z.preprocess(coerceBoolean, ${inner})`;
+}
+function generateTupleExpression(elements, ctx) {
+  const fixedExprs = [];
+  const fixedOptional = [];
+  let restExpression = "";
+  let restStarted = false;
+  for (const el of elements) {
+    if (el.rest) {
+      restExpression = runtimeTypeToZodExpression(el.type, ctx);
+      restStarted = true;
+    } else if (!restStarted) {
+      fixedExprs.push(runtimeTypeToZodExpression(el.type, ctx));
+      fixedOptional.push(el.optional);
+    }
+  }
+  if (restExpression) {
+    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
+  }
+  const hasOptional = fixedOptional.some((o) => o);
+  if (!hasOptional) {
+    return `z.tuple([${fixedExprs.join(", ")}])`;
+  }
+  const variants = [];
+  for (let len = fixedExprs.length; len >= 0; len--) {
+    const removed = fixedOptional.slice(len);
+    if (removed.length > 0 && removed.some((o) => !o)) {
+      break;
+    }
+    const subset = fixedExprs.slice(0, len);
+    variants.push(`z.tuple([${subset.join(", ")}])`);
+  }
+  variants.reverse();
+  if (variants.length === 1) {
+    return variants[0];
+  }
+  return `z.union([${variants.join(", ")}])`;
+}
+function generateObjectExpression(properties, ctx) {
+  const fields = properties.map((prop) => {
+    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(", ")} })`;
+}
+function generateUnionExpression(members, ctx) {
+  const hasNull = members.some((m) => m.kind === "null");
+  const nonNull = members.filter((m) => m.kind !== "null");
+  if (hasNull && nonNull.length === 1) {
+    return `${runtimeTypeToZodExpression(nonNull[0], ctx)}.nullable()`;
+  }
+  if (hasNull) {
+    const unionInner2 = nonNull.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
+    return `z.union([${unionInner2}]).nullable()`;
+  }
+  const unionInner = members.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
+  return `z.union([${unionInner}])`;
+}
+function generateNamedTypeDeclaration(name, type, ctx) {
+  const expr = runtimeTypeToZodExpression(type, ctx);
+  const hasRef = containsRef(type, /* @__PURE__ */ new Set([name]));
+  if (hasRef) {
+    return `const ${name}Schema = z.lazy(() => ${expr});`;
+  }
+  return `const ${name}Schema = ${expr};`;
+}
+function containsRef(type, visited) {
+  switch (type.kind) {
+    case "ref":
+      return visited.has(type.name);
+    case "array":
+      return containsRef(type.element, visited);
+    case "tuple":
+      return type.elements.some((el) => containsRef(el.type, visited));
+    case "object":
+      return type.properties.some((prop) => containsRef(prop.type, visited));
+    case "union":
+      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;
+  }
+}
+function generateZodSchemaSource(typeInfo, resolveType, exportName, coerce = false) {
+  const ctx = new CodeGenContext(resolveType);
+  const name = exportName ?? typeInfo.name;
+  ctx.entryTypeName = typeInfo.name;
+  ctx.entryExportName = name;
+  ctx.coerce = coerce;
+  collectNamedTypes(typeInfo.runtimeType, ctx);
+  ctx.namedTypes.delete(typeInfo.name);
+  const lines = [];
+  lines.push("import { z } from 'zod';");
+  lines.push("");
+  for (const [n, type] of ctx.namedTypes) {
+    lines.push(generateNamedTypeDeclaration(n, type, ctx));
+  }
+  if (ctx.namedTypes.size > 0) lines.push("");
+  const entryExpr = runtimeTypeToZodExpression(typeInfo.runtimeType, ctx);
+  const hasSelfRef = containsRef(typeInfo.runtimeType, /* @__PURE__ */ new Set([typeInfo.name]));
+  if (hasSelfRef) {
+    lines.push(`export const ${name}Schema = z.lazy(() => ${entryExpr});`);
+  } else {
+    lines.push(`export const ${name}Schema = ${entryExpr};`);
+  }
+  return lines.join("\n");
+}
+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";
+    CodeGenContext = class {
+      /** 命名类型集合：name → RuntimeType */
+      namedTypes = /* @__PURE__ */ new Map();
+      /** 类型解析器（用于解析 ref 的实际类型） */
+      resolveType;
+      /** 入口类型原始名（typeInfo.name，用于识别入口类型的自引用） */
+      entryTypeName = "";
+      /** 入口类型导出名（exportName，自引用时用此名生成变量名） */
+      entryExportName = "";
+      /**
+       * 是否生成 coerce 逻辑（query/params 场景，URL 来源均为 string）
+       *
+       * true 时为 number/boolean 字段包 z.preprocess，把合法的字符串转成对应类型。
+       * 嵌套类型（array/object/tuple/union 等）的元素递归处理。
+       */
+      coerce = false;
+      constructor(resolveType) {
+        this.resolveType = resolveType;
+      }
+    };
+    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";
+  }
+});
+
+// src/cli/generateSchemaFiles.ts
+var generateSchemaFiles_exports = {};
+__export(generateSchemaFiles_exports, {
+  generateSchemaFileSource: () => generateSchemaFileSource,
+  generateSchemaFiles: () => generateSchemaFiles,
+  getHelpersImportPath: () => getHelpersImportPath,
+  getRuntimeSchemaPath: () => getRuntimeSchemaPath,
+  getSchemaOutputPath: () => getSchemaOutputPath
+});
+import path5 from "path";
+import fs4 from "fs/promises";
+function getSchemaOutputPath(sourceFile, dist, rootDir) {
+  let rel = sourceFile.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
+  }
+  const idx = rel.lastIndexOf("/");
+  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
+  return path5.resolve(rootDir, dist, relDir, "zod.js");
+}
+function getRuntimeSchemaPath(filePath, dist, rootDir) {
+  let rel = filePath.replace(/\\/g, "/");
+  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 path5.resolve(rootDir, dist, relDir, "zod.js");
+}
+function getHelpersImportPath(relDir) {
+  if (!relDir) return `./${HELPERS_FILENAME}`;
+  const depth = relDir.split("/").filter(Boolean).length;
+  return `${"../".repeat(depth)}${HELPERS_FILENAME}`;
+}
+function generateSchemaFileSource(sources, allTypes, helpersImportPath) {
+  const resolveType = (name) => allTypes.get(name)?.runtimeType;
+  const lines = ["import { z } from 'zod';"];
+  const schemaBlocks = [];
+  for (const source of sources) {
+    const { schemaName, typeInfo } = source;
+    if (!typeInfo) {
+      continue;
+    }
+    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/,
+      ""
+    );
+    block.push(schemaCode);
+    block.push("");
+    schemaBlocks.push(block.join("\n"));
+  }
+  const allSchemaCode = schemaBlocks.join("\n");
+  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
+    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, dist) {
+  if (routes.length === 0) return;
+  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
+  const sourcesByFile = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    let list = sourcesByFile.get(source.filePath);
+    if (!list) {
+      list = [];
+      sourcesByFile.set(source.filePath, list);
+    }
+    list.push(source);
+  }
+  const fileEntries = [];
+  for (const [filePath, fileSources] of sourcesByFile) {
+    const relFile = path5.relative(rootDir, filePath).replace(/\\/g, "/");
+    const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
+    const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
+    let relForDir = relFile;
+    if (relForDir.startsWith("src/")) {
+      relForDir = relForDir.slice(4);
+    }
+    const dirIdx = relForDir.lastIndexOf("/");
+    const zodRelDir = dirIdx >= 0 ? relForDir.slice(0, dirIdx) : "";
+    const helpersImportPath = getHelpersImportPath(zodRelDir);
+    const source = generateSchemaFileSource(fileSources, allTypes, helpersImportPath);
+    fileEntries.push({ outputPath, source });
+  }
+  const allSourceCode = fileEntries.map((e) => e.source).join("\n");
+  if (usesCoerceHelpers(allSourceCode)) {
+    const helpersPath = path5.resolve(rootDir, dist, HELPERS_FILENAME);
+    await writeSchemaFile(helpersPath, generateHelpersFileSource());
+  }
+  await Promise.all(
+    fileEntries.map(({ outputPath, source }) => writeSchemaFile(outputPath, source))
+  );
+}
+async function writeSchemaFile(outputPath, source) {
+  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
+  await fs4.writeFile(outputPath, source, "utf-8");
+}
+var init_generateSchemaFiles = __esm({
+  "src/cli/generateSchemaFiles.ts"() {
+    "use strict";
+    init_collectRouteSchemaSources();
+    init_generateZodSchema();
+  }
+});
+
+// src/index.ts
+init_createProgram();
+init_extractHandlerTypes();
+init_resolveTypeNode();
+init_inputType();
+init_collectRouteSchemaSources();
+
+// src/middleware/cors.ts
+var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+function cors(options = {}) {
+  const {
+    origin = true,
+    methods = DEFAULT_METHODS,
+    allowedHeaders,
+    exposeHeaders,
+    credentials = false,
+    maxAge
+  } = options;
+  return async (ctx, next) => {
+    const reqOrigin = ctx.headers.get("origin");
+    if (!reqOrigin) {
+      await next();
+      return;
+    }
+    let allowOrigin = null;
+    if (origin === true) {
+      allowOrigin = reqOrigin;
+    } else if (typeof origin === "string") {
+      allowOrigin = reqOrigin === origin ? origin : null;
+    } else if (Array.isArray(origin)) {
+      allowOrigin = origin.includes(reqOrigin) ? reqOrigin : null;
+    }
+    if (!allowOrigin) {
+      await next();
+      return;
+    }
+    ctx.setHeader("Access-Control-Allow-Origin", allowOrigin);
+    if (origin === true || Array.isArray(origin)) {
+      const existingVary = ctx.headers.get("vary");
+      if (existingVary) {
+        if (!existingVary.toLowerCase().includes("origin")) {
+          ctx.setHeader("Vary", `${existingVary}, Origin`);
+        }
+      } else {
+        ctx.setHeader("Vary", "Origin");
+      }
+    }
+    ctx.setHeader("Access-Control-Allow-Methods", methods.join(", "));
+    if (allowedHeaders) {
+      ctx.setHeader("Access-Control-Allow-Headers", allowedHeaders.join(", "));
+    } else {
+      const requestHeaders = ctx.headers.get("access-control-request-headers");
+      if (requestHeaders) {
+        ctx.setHeader("Access-Control-Allow-Headers", requestHeaders);
+      }
+    }
+    if (exposeHeaders && exposeHeaders.length > 0) {
+      ctx.setHeader("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+    }
+    if (credentials) {
+      ctx.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+    if (maxAge !== void 0) {
+      ctx.setHeader("Access-Control-Max-Age", String(maxAge));
+    }
+    if (ctx.method === "OPTIONS") {
+      return new Response(null, { status: 204 });
+    }
+    await next();
+  };
+}
+
+// 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;
+    }
+  };
+}
+
+// src/middleware/helmet.ts
+var DEFAULTS = {
+  contentSecurityPolicy: "default-src 'self'",
+  xFrameOptions: "SAMEORIGIN",
+  xContentTypeOptions: true,
+  referrerPolicy: "no-referrer",
+  strictTransportSecurity: "max-age=31536000; includeSubDomains",
+  xDnsPrefetchControl: true,
+  xDownloadOptions: true,
+  xPermittedCrossDomainPolicies: "none",
+  crossOriginOpenerPolicy: "same-origin",
+  crossOriginResourcePolicy: "same-origin",
+  crossOriginEmbedderPolicy: false,
+  originAgentCluster: true,
+  xPoweredBy: true
+};
+function helmet(options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  return async (ctx, next) => {
+    if (opts.contentSecurityPolicy !== false) {
+      ctx.setHeader("Content-Security-Policy", opts.contentSecurityPolicy);
+    }
+    if (opts.xFrameOptions !== false) {
+      ctx.setHeader("X-Frame-Options", opts.xFrameOptions);
+    }
+    if (opts.xContentTypeOptions) {
+      ctx.setHeader("X-Content-Type-Options", "nosniff");
+    }
+    if (opts.referrerPolicy !== false) {
+      ctx.setHeader("Referrer-Policy", opts.referrerPolicy);
+    }
+    if (opts.strictTransportSecurity !== false) {
+      ctx.setHeader("Strict-Transport-Security", opts.strictTransportSecurity);
+    }
+    if (opts.xDnsPrefetchControl) {
+      ctx.setHeader("X-DNS-Prefetch-Control", "off");
+    }
+    if (opts.xDownloadOptions) {
+      ctx.setHeader("X-Download-Options", "noopen");
+    }
+    if (opts.xPermittedCrossDomainPolicies !== false) {
+      ctx.setHeader("X-Permitted-Cross-Domain-Policies", opts.xPermittedCrossDomainPolicies);
+    }
+    if (opts.crossOriginOpenerPolicy !== false) {
+      ctx.setHeader("Cross-Origin-Opener-Policy", opts.crossOriginOpenerPolicy);
+    }
+    if (opts.crossOriginResourcePolicy !== false) {
+      ctx.setHeader("Cross-Origin-Resource-Policy", opts.crossOriginResourcePolicy);
+    }
+    if (opts.crossOriginEmbedderPolicy !== false) {
+      ctx.setHeader("Cross-Origin-Embedder-Policy", opts.crossOriginEmbedderPolicy);
+    }
+    if (opts.originAgentCluster) {
+      ctx.setHeader("Origin-Agent-Cluster", "?1");
+    }
+    if (opts.xPoweredBy) {
+      ctx.setHeader("X-Powered-By", "faapi");
+    }
+    return await next();
+  };
+}
+
+// src/config/loadConfig.ts
+import path2 from "path";
+import fs from "fs";
+
+// src/utils/importWithCacheBust.ts
+import { pathToFileURL } from "url";
+var loadTs;
+function setLoadTimestamp(ts7) {
+  loadTs = ts7;
+}
+function getVitestImportActual() {
+  const vi = globalThis.vi;
+  if (typeof vi?.importActual !== "function") return void 0;
+  return vi.importActual.bind(vi);
+}
+async function importWithCacheBust(filePath, bustViteCache = false) {
+  const importActual = getVitestImportActual();
+  if (importActual) {
+    if (bustViteCache) {
+      let url2 = pathToFileURL(filePath).href;
+      url2 += `?t=${Date.now()}`;
+      return await import(url2);
+    }
+    return await importActual(filePath);
+  }
+  let url = pathToFileURL(filePath).href;
+  if (loadTs !== void 0) {
+    url += `?t=${loadTs}`;
+  }
+  return await import(url);
 }
 
 // src/config/loadConfig.ts
@@ -1160,14 +1646,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path11) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path11}`, 404);
+  constructor(path15) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path15}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path11, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path11}`, 405);
+  constructor(method, path15, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path15}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -1497,6 +1983,9 @@ async function toResponse(value, meta) {
   });
 }
 
+// src/injection/injectParams.ts
+init_resolveInjection();
+
 // src/utils/queryToObject.ts
 function queryToObject(params) {
   const result = {};
@@ -1648,9 +2137,9 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
 }
 
 // src/testServer.ts
-import path8 from "path";
+import path12 from "path";
 import os from "os";
-import fs5 from "fs/promises";
+import fs11 from "fs/promises";
 
 // src/router/scanRoutes.ts
 import fg from "fast-glob";
@@ -1660,14 +2149,11 @@ import fs3 from "fs";
 // src/router/constants.ts
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var HTTP_METHOD_SET = new Set(HTTP_METHODS);
-function isHttpMethod(value) {
-  return HTTP_METHOD_SET.has(value);
-}
 
 // src/utils/normalizePath.ts
-function normalizePath(path11) {
-  if (!path11) return "";
-  let result = path11.replace(/\\/g, "/");
+function normalizePath(path15) {
+  if (!path15) return "";
+  let result = path15.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -1757,50 +2243,11 @@ async function loadMiddlewaresFile(filePath) {
     return { middlewares: [], injectors: {} };
   }
 }
-
-// src/router/scanRoutes.ts
-var APP_DIR = "src";
-function toProdAbsPath(sourceAbsPath, rootDir, dist) {
-  let rel = path4.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
-  if (rel.startsWith(`${APP_DIR}/`)) {
-    rel = rel.slice(APP_DIR.length + 1);
-  }
-  const prodRel = `${dist}/${rel.replace(/\.ts$/, ".js")}`;
-  return path4.resolve(rootDir, prodRel);
-}
-async function findMergedMiddlewares(routeFilePath, rootDir, dist) {
-  const routeDir = path4.dirname(routeFilePath);
-  const resolvedRoot = path4.resolve(rootDir);
-  const mwPaths = [];
-  let currentDir = path4.resolve(rootDir, routeDir);
-  while (true) {
-    if (dist) {
-      const mwPath = path4.join(currentDir, "middlewares.js");
-      const absMwPath = path4.resolve(rootDir, mwPath);
-      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, dist);
-      if (fs3.existsSync(prodAbsMwPath)) {
-        mwPaths.push(prodAbsMwPath);
-      }
-    } else {
-      for (const ext of [".ts", ".js"]) {
-        const mwPath = path4.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path4.resolve(rootDir, mwPath);
-        if (fs3.existsSync(absMwPath)) {
-          mwPaths.push(absMwPath);
-          break;
-        }
-      }
-    }
-    if (currentDir === resolvedRoot) break;
-    const parentDir = path4.dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
-  }
-  if (mwPaths.length === 0) return void 0;
-  mwPaths.reverse();
+async function loadMergedMiddlewares(middlewarePaths) {
+  if (middlewarePaths.length === 0) return void 0;
   const mergedMiddlewares = [];
   const mergedInjectors = {};
-  for (const absMwPath of mwPaths) {
+  for (const absMwPath of middlewarePaths) {
     let bundle = getCachedMiddlewares(absMwPath);
     if (bundle === void 0) {
       bundle = await loadMiddlewaresFile(absMwPath);
@@ -1816,31 +2263,63 @@ async function findMergedMiddlewares(routeFilePath, rootDir, dist) {
   }
   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);
+
+// src/router/scanRoutes.ts
+var HTTP_OR_WS_EXPORT_RE = new RegExp(
+  String.raw`export\s+(?:async\s+)?(?:function\s+|const\s+)(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|WS)\b`,
+  "g"
+);
+function extractExportsFromSource(source) {
+  const names = /* @__PURE__ */ new Set();
+  let match;
+  HTTP_OR_WS_EXPORT_RE.lastIndex = 0;
+  while ((match = HTTP_OR_WS_EXPORT_RE.exec(source)) !== null) {
+    names.add(match[1]);
+  }
+  return names;
+}
+function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
+  const routeDir = path4.dirname(routeFilePath);
+  const resolvedRoot = path4.resolve(rootDir);
+  const paths = [];
+  let currentDir = path4.resolve(rootDir, routeDir);
+  while (true) {
+    if (dist) {
+      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;
+      if (absMwPath) {
+        const relMwPath = path4.relative(rootDir, absMwPath);
+        const prodAbsPath = path4.resolve(rootDir, toProdFilePath(relMwPath, dist));
+        paths.push(prodAbsPath);
+      }
+    } else {
+      for (const ext of [".ts", ".js"]) {
+        const mwPath = path4.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path4.resolve(rootDir, mwPath);
+        if (fs3.existsSync(absMwPath)) {
+          paths.push(absMwPath);
+          break;
+        }
       }
     }
-    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 [];
+    if (currentDir === resolvedRoot) break;
+    const parentDir = path4.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
   }
+  paths.reverse();
+  return paths;
 }
-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;
+function toProdFilePath(filePath, dist) {
+  let rel = filePath.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
   }
+  const jsPath = rel.replace(/\.ts$/, ".js");
+  return jsPath.startsWith(`${dist}/`) ? jsPath : `${dist}/${jsPath}`;
 }
 async function scanRoutes(rootDir, patterns, dist) {
   const files = await fg(patterns, {
@@ -1855,13 +2334,21 @@ async function scanRoutes(rootDir, patterns, dist) {
     const fileName = normalizedFile.split("/").pop();
     if (fileName === "handler.ts" || fileName === "handler.js") {
       const absPath = path4.resolve(rootDir, normalizedFile);
-      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, dist);
-      const methods = await extractMethodsFromHandler(importPath);
+      let middlewarePaths;
+      let middlewareBundle;
+      if (dist) {
+        middlewarePaths = collectMiddlewarePaths(normalizedFile, rootDir, dist);
+      } else {
+        const mwPaths = collectMiddlewarePaths(normalizedFile, rootDir);
+        middlewareBundle = await loadMergedMiddlewares(mwPaths);
+      }
+      const source = await fs3.promises.readFile(absPath, "utf8").catch(() => "");
+      const exportNames = extractExportsFromSource(source);
+      const methods = HTTP_METHODS.filter((m) => exportNames.has(m));
       for (const method of methods) {
         routes.push({
           method,
@@ -1870,18 +2357,19 @@ async function scanRoutes(rootDir, patterns, dist) {
           paramNames,
           isDynamic,
           isCatchAll: isCatchAll || void 0,
+          middlewarePaths,
           middlewares: middlewareBundle?.middlewares,
           injectors: middlewareBundle?.injectors
         });
       }
-      const hasWs = await hasWsExport(importPath);
-      if (hasWs) {
+      if (exportNames.has("WS")) {
         wsRoutes.push({
           urlPath,
           filePath: normalizedFile,
           paramNames,
           isDynamic,
           isCatchAll: isCatchAll || void 0,
+          middlewarePaths,
           middlewares: middlewareBundle?.middlewares,
           injectors: middlewareBundle?.injectors
         });
@@ -1910,403 +2398,357 @@ function sortRoutes(routes) {
   });
 }
 
-// src/cli/generateSchemaFiles.ts
-import path5 from "path";
-import fs4 from "fs/promises";
+// src/testServer.ts
+init_generateSchemaFiles();
 
-// src/ast/generateZodSchema.ts
-var CodeGenContext = class {
-  /** 命名类型集合：name → RuntimeType */
-  namedTypes = /* @__PURE__ */ new Map();
-  /** 类型解析器（用于解析 ref 的实际类型） */
-  resolveType;
-  /** 入口类型原始名（typeInfo.name，用于识别入口类型的自引用） */
-  entryTypeName = "";
-  /** 入口类型导出名（exportName，自引用时用此名生成变量名） */
-  entryExportName = "";
-  /**
-   * 是否生成 coerce 逻辑（query/params 场景，URL 来源均为 string）
-   *
-   * true 时为 number/boolean 字段包 z.preprocess，把合法的字符串转成对应类型。
-   * 嵌套类型（array/object/tuple/union 等）的元素递归处理。
-   */
-  coerce = false;
-  constructor(resolveType) {
-    this.resolveType = resolveType;
-  }
-};
-function collectNamedTypes(type, ctx) {
-  switch (type.kind) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "null":
-    case "undefined":
-    case "any":
-    case "unknown":
-    case "literal":
-    case "date":
-      return;
-    case "array":
-      collectNamedTypes(type.element, ctx);
-      return;
-    case "tuple":
-      for (const el of type.elements) {
-        collectNamedTypes(el.type, ctx);
-      }
-      return;
-    case "object":
-      for (const prop of type.properties) {
-        collectNamedTypes(prop.type, ctx);
-      }
-      return;
-    case "union":
-      for (const member of type.members) {
-        collectNamedTypes(member, ctx);
-      }
-      return;
-    case "record":
-      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" });
-      const resolved = ctx.resolveType(type.name);
-      if (resolved) {
-        ctx.namedTypes.set(type.name, resolved);
-        collectNamedTypes(resolved, ctx);
-      }
-      return;
-    }
-  }
-}
-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, 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()";
-  }
-}
-function baseExpression(type, ctx) {
-  switch (type.kind) {
-    case "string":
-      return "z.string()";
-    case "number":
-      return "z.number()";
-    case "boolean":
-      return "z.boolean()";
-    case "bigint":
-      return "z.never()";
-    case "null":
-      return "z.null()";
-    case "undefined":
-      return "z.undefined()";
-    case "any":
-    case "unknown":
-      return "z.unknown()";
-    case "literal":
-      return `z.literal(${JSON.stringify(type.value)})`;
-    case "array":
-      return `z.array(${runtimeTypeToZodExpression(type.element, ctx)})`;
-    case "tuple":
-      return generateTupleExpression(type.elements, ctx);
-    case "object":
-      return generateObjectExpression(type.properties, ctx);
-    case "union":
-      return generateUnionExpression(type.members, ctx);
-    case "date":
-      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`;
-      }
-      return `${type.name}Schema`;
-  }
-}
-var COERCE_NUMBER_HELPER = 'export const coerceNumber = (v) => typeof v === "string" && v.trim() !== "" && !isNaN(Number(v)) ? Number(v) : v;';
-var COERCE_BOOLEAN_HELPER = 'export const coerceBoolean = (v) => v === "true" || v === "1" ? true : v === "false" || v === "0" ? false : v;';
-var 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);';
-var COERCE_SET_HELPER = "export const coerceSet = (v) => v instanceof Set ? v : (Array.isArray(v) ? new Set(v) : v);";
-var HELPERS_FILENAME = "faapi-helpers.js";
-function generateHelpersFileSource() {
-  return [
-    "// 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") || code.includes("coerceMap") || code.includes("coerceSet");
-}
-function wrapCoercePreprocess(kind, inner) {
-  if (kind === "number") {
-    return `z.preprocess(coerceNumber, ${inner})`;
-  }
-  return `z.preprocess(coerceBoolean, ${inner})`;
-}
-function generateTupleExpression(elements, ctx) {
-  const fixedExprs = [];
-  const fixedOptional = [];
-  let restExpression = "";
-  let restStarted = false;
-  for (const el of elements) {
-    if (el.rest) {
-      restExpression = runtimeTypeToZodExpression(el.type, ctx);
-      restStarted = true;
-    } else if (!restStarted) {
-      fixedExprs.push(runtimeTypeToZodExpression(el.type, ctx));
-      fixedOptional.push(el.optional);
-    }
-  }
-  if (restExpression) {
-    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
-  }
-  const hasOptional = fixedOptional.some((o) => o);
-  if (!hasOptional) {
-    return `z.tuple([${fixedExprs.join(", ")}])`;
-  }
-  const variants = [];
-  for (let len = fixedExprs.length; len >= 0; len--) {
-    const removed = fixedOptional.slice(len);
-    if (removed.length > 0 && removed.some((o) => !o)) {
-      break;
-    }
-    const subset = fixedExprs.slice(0, len);
-    variants.push(`z.tuple([${subset.join(", ")}])`);
-  }
-  variants.reverse();
-  if (variants.length === 1) {
-    return variants[0];
-  }
-  return `z.union([${variants.join(", ")}])`;
-}
-function generateObjectExpression(properties, ctx) {
-  const fields = properties.map((prop) => {
-    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(", ")} })`;
-}
-function generateUnionExpression(members, ctx) {
-  const hasNull = members.some((m) => m.kind === "null");
-  const nonNull = members.filter((m) => m.kind !== "null");
-  if (hasNull && nonNull.length === 1) {
-    return `${runtimeTypeToZodExpression(nonNull[0], ctx)}.nullable()`;
-  }
-  if (hasNull) {
-    const unionInner2 = nonNull.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
-    return `z.union([${unionInner2}]).nullable()`;
+// src/validator/validateInput.ts
+init_schemaName();
+
+// src/cli/compileOnDemand.ts
+import path9 from "path";
+import fs8 from "fs";
+
+// src/cli/compileDevRoutes.ts
+import path8 from "path";
+import fs7 from "fs";
+import fg2 from "fast-glob";
+
+// src/cli/aliasPlugin.ts
+import path7 from "path";
+import fs6 from "fs";
+
+// 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));
+      }
+    }
   }
-  const unionInner = members.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
-  return `z.union([${unionInner}])`;
+  return candidates;
 }
-function generateNamedTypeDeclaration(name, type, ctx) {
-  const expr = runtimeTypeToZodExpression(type, ctx);
-  const hasRef = containsRef(type, /* @__PURE__ */ new Set([name]));
-  if (hasRef) {
-    return `const ${name}Schema = z.lazy(() => ${expr});`;
-  }
-  return `const ${name}Schema = ${expr};`;
+
+// src/utils/readTsconfig.ts
+import ts6 from "typescript";
+import path6 from "path";
+import fs5 from "fs";
+function readTsconfig(rootDir) {
+  const tsconfigPath = path6.resolve(rootDir, "tsconfig.json");
+  if (!fs5.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) => path6.resolve(baseUrl, t));
+  }
+  return { baseUrl, paths };
 }
-function containsRef(type, visited) {
-  switch (type.kind) {
-    case "ref":
-      return visited.has(type.name);
-    case "array":
-      return containsRef(type.element, visited);
-    case "tuple":
-      return type.elements.some((el) => containsRef(el.type, visited));
-    case "object":
-      return type.properties.some((prop) => containsRef(prop.type, visited));
-    case "union":
-      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;
+
+// src/cli/aliasPlugin.ts
+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 = path7.dirname(importer);
+  let rel = path7.relative(importerDir, sourceFile);
+  rel = rel.split(path7.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return toProdExtension(rel);
+}
+function toRealPath(p) {
+  try {
+    return fs6.realpathSync(p);
+  } catch {
+    return p;
   }
 }
-function generateZodSchemaSource(typeInfo, resolveType, exportName, coerce = false) {
-  const ctx = new CodeGenContext(resolveType);
-  const name = exportName ?? typeInfo.name;
-  ctx.entryTypeName = typeInfo.name;
-  ctx.entryExportName = name;
-  ctx.coerce = coerce;
-  collectNamedTypes(typeInfo.runtimeType, ctx);
-  ctx.namedTypes.delete(typeInfo.name);
-  const lines = [];
-  lines.push("import { z } from 'zod';");
-  lines.push("");
-  for (const [n, type] of ctx.namedTypes) {
-    lines.push(generateNamedTypeDeclaration(n, type, ctx));
-  }
-  if (ctx.namedTypes.size > 0) lines.push("");
-  const entryExpr = runtimeTypeToZodExpression(typeInfo.runtimeType, ctx);
-  const hasSelfRef = containsRef(typeInfo.runtimeType, /* @__PURE__ */ new Set([typeInfo.name]));
-  if (hasSelfRef) {
-    lines.push(`export const ${name}Schema = z.lazy(() => ${entryExpr});`);
-  } else {
-    lines.push(`export const ${name}Schema = ${entryExpr};`);
+function isInsideDir(filePath, dir) {
+  const rel = path7.relative(dir, filePath);
+  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
+}
+var APP_DIR = "src";
+function toStrippedProdImportPath(sourceFile, rootDir) {
+  const appDirAbs = toRealPath(path7.resolve(rootDir, APP_DIR));
+  const sourceReal = toRealPath(sourceFile);
+  let rel = path7.relative(appDirAbs, sourceReal);
+  rel = rel.split(path7.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return toProdExtension(rel);
+}
+var PROD_EXTS = [".js", ".mjs", ".cjs"];
+var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var INDEX_EXTS = [
+  "/index.ts",
+  "/index.tsx",
+  "/index.js",
+  "/index.jsx",
+  "/index.mjs",
+  "/index.cjs"
+];
+function resolveRelativeSpecifier(importer, specifier) {
+  const importerDir = path7.dirname(importer);
+  const base = path7.resolve(importerDir, specifier);
+  if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
+    return fs6.existsSync(base) ? base : null;
+  }
+  if (/\.(ts|tsx|jsx)$/.test(specifier)) {
+    return fs6.existsSync(base) ? base : null;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const file = base + ext;
+    if (fs6.existsSync(file)) return file;
+  }
+  for (const indexExt of INDEX_EXTS) {
+    const file = base + indexExt;
+    if (fs6.existsSync(file)) return file;
   }
-  return lines.join("\n");
+  return null;
+}
+function createAliasPlugin(config, options) {
+  const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
+  const appDirAbs = options?.rootDir ? toRealPath(path7.resolve(options.rootDir, APP_DIR)) : null;
+  return {
+    name: "faapi-alias",
+    setup(build) {
+      build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
+        let source;
+        try {
+          source = fs6.readFileSync(args.path, "utf8");
+        } catch {
+          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("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 SOURCE_EXTS) {
+              const file = candidate + ext;
+              if (fs6.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}`;
+              }
+            }
+            for (const indexExt of INDEX_EXTS) {
+              const file = candidate + indexExt;
+              if (fs6.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}`;
+              }
+            }
+          }
+          return full;
+        });
+        if (!modified) return void 0;
+        return { contents: newSource, loader: "default" };
+      });
+    }
+  };
+}
+function buildAliasPlugins(rootDir) {
+  const tsconfig = readTsconfig(rootDir);
+  return [createAliasPlugin(tsconfig ?? { baseUrl: ".", paths: {} }, { rootDir })];
 }
 
-// src/cli/generateSchemaFiles.ts
-function getSchemaOutputPath(sourceFile, dist, rootDir) {
-  let rel = sourceFile.replace(/\\/g, "/");
-  if (rel.startsWith("src/")) {
-    rel = rel.slice(4);
+// src/cli/compileDevRoutes.ts
+var APP_DIR2 = "src";
+async function compileDevRoutes(options) {
+  const { rootDir, dist, files, logLevel = "silent" } = options;
+  const entryPoints = files ?? await fg2([`${APP_DIR2}/**/*.ts`], {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
+  });
+  if (entryPoints.length === 0) {
+    return { compiledFiles: [] };
+  }
+  const absDist = path8.resolve(rootDir, dist);
+  await fs7.promises.mkdir(absDist, { recursive: true });
+  const plugins = buildAliasPlugins(rootDir);
+  const esbuild = await import("esbuild");
+  const outbase = path8.resolve(rootDir, APP_DIR2);
+  const result = await esbuild.build({
+    entryPoints,
+    outdir: absDist,
+    outbase,
+    bundle: false,
+    platform: "node",
+    format: "esm",
+    sourcemap: true,
+    packages: "external",
+    plugins,
+    logLevel,
+    write: false
+  });
+  if (result.outputFiles) {
+    await Promise.all(
+      result.outputFiles.map(async (file) => {
+        await fs7.promises.mkdir(path8.dirname(file.path), { recursive: true });
+        const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+        await fs7.promises.writeFile(tmp, file.contents);
+        await fs7.promises.rename(tmp, file.path);
+      })
+    );
   }
-  const idx = rel.lastIndexOf("/");
-  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
+  return { compiledFiles: entryPoints };
 }
-function getRuntimeSchemaPath(filePath, dist, rootDir) {
-  let rel = filePath.replace(/\\/g, "/");
-  if (rel.startsWith("src/")) {
-    rel = rel.slice(4);
-  } else if (rel.startsWith(`${dist}/`)) {
-    rel = rel.slice(dist.length + 1);
+
+// src/cli/compileOnDemand.ts
+init_generateSchemaFiles();
+init_generateSchemaFiles();
+function isProductFresh(sourceAbsPath, productAbsPath) {
+  try {
+    const srcStat = fs8.statSync(sourceAbsPath);
+    const prodStat = fs8.statSync(productAbsPath);
+    return prodStat.mtimeMs >= srcStat.mtimeMs;
+  } catch {
+    return false;
   }
-  const idx = rel.lastIndexOf("/");
-  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
 }
-function getHelpersImportPath(relDir) {
-  if (!relDir) return `./${HELPERS_FILENAME}`;
-  const depth = relDir.split("/").filter(Boolean).length;
-  return `${"../".repeat(depth)}${HELPERS_FILENAME}`;
+var compiledFiles = /* @__PURE__ */ new Set();
+function clearCompiledFiles() {
+  compiledFiles.clear();
 }
-function generateSchemaFileSource(sources, allTypes, helpersImportPath) {
-  const resolveType = (name) => allTypes.get(name)?.runtimeType;
-  const lines = ["import { z } from 'zod';"];
-  const schemaBlocks = [];
-  for (const source of sources) {
-    const { schemaName, typeInfo } = source;
-    if (!typeInfo) {
-      continue;
-    }
-    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/,
-      ""
-    );
-    block.push(schemaCode);
-    block.push("");
-    schemaBlocks.push(block.join("\n"));
+async function ensureCompiled(sourceAbsPath, rootDir, dist) {
+  if (compiledFiles.has(sourceAbsPath)) {
+    return false;
   }
-  const allSchemaCode = schemaBlocks.join("\n");
-  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
-    lines.push(
-      `import { coerceNumber, coerceBoolean, coerceMap, coerceSet } from '${helpersImportPath}';`
-    );
+  if (!fs8.existsSync(sourceAbsPath)) {
+    return false;
   }
-  lines.push("");
-  lines.push(...schemaBlocks);
-  return lines.join("\n").replace(/\n+$/, "\n");
-}
-async function generateSchemaFiles(routes, rootDir, dist) {
-  if (routes.length === 0) return;
-  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
-  const sourcesByFile = /* @__PURE__ */ new Map();
-  for (const source of sources) {
-    let list = sourcesByFile.get(source.filePath);
-    if (!list) {
-      list = [];
-      sourcesByFile.set(source.filePath, list);
-    }
-    list.push(source);
+  const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
+  if (productPath && isProductFresh(sourceAbsPath, productPath)) {
+    compiledFiles.add(sourceAbsPath);
+    return false;
   }
-  const fileEntries = [];
-  for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path5.relative(rootDir, filePath).replace(/\\/g, "/");
-    const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
-    const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
-    let relForDir = relFile;
-    if (relForDir.startsWith("src/")) {
-      relForDir = relForDir.slice(4);
+  await compileDevRoutes({
+    rootDir,
+    dist,
+    files: [sourceAbsPath],
+    logLevel: "silent"
+  });
+  compiledFiles.add(sourceAbsPath);
+  return true;
+}
+function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
+  const rel = path9.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  if (!rel.startsWith("src/")) return null;
+  const relWithoutSrc = rel.slice(4);
+  const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
+  return path9.resolve(rootDir, dist, jsRel);
+}
+var generatedSchemas = /* @__PURE__ */ new Set();
+function clearGeneratedSchemas() {
+  generatedSchemas.clear();
+}
+async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
+  if (generatedSchemas.has(schemaPath)) {
+    return false;
+  }
+  const prodAbsPath = path9.resolve(rootDir, routeFilePath);
+  const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
+  if (!fs8.existsSync(sourceAbsPath)) {
+    return false;
+  }
+  if (isProductFresh(sourceAbsPath, schemaPath)) {
+    generatedSchemas.add(schemaPath);
+    return false;
+  }
+  const fileRoutes = routes.filter((r) => r.filePath === routeFilePath);
+  if (fileRoutes.length === 0) {
+    return false;
+  }
+  const sourceRelPath = path9.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
+  await generateSchemaFiles(sourceRoutes, rootDir, dist);
+  generatedSchemas.add(schemaPath);
+  return true;
+}
+async function deleteSchemaFiles(routes, rootDir, dist) {
+  const deleted = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
+    if (deleted.has(schemaPath)) continue;
+    deleted.add(schemaPath);
+    try {
+      await fs8.promises.unlink(schemaPath);
+    } catch {
     }
-    const dirIdx = relForDir.lastIndexOf("/");
-    const zodRelDir = dirIdx >= 0 ? relForDir.slice(0, dirIdx) : "";
-    const helpersImportPath = getHelpersImportPath(zodRelDir);
-    const source = generateSchemaFileSource(fileSources, allTypes, helpersImportPath);
-    fileEntries.push({ outputPath, source });
   }
-  const allSourceCode = fileEntries.map((e) => e.source).join("\n");
-  if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path5.resolve(rootDir, dist, HELPERS_FILENAME);
-    await writeSchemaFile(helpersPath, generateHelpersFileSource());
+}
+function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
+  const rel = path9.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  let relWithoutDist = rel;
+  if (relWithoutDist.startsWith(`${dist}/`)) {
+    relWithoutDist = relWithoutDist.slice(dist.length + 1);
   }
-  await Promise.all(
-    fileEntries.map(({ outputPath, source }) => writeSchemaFile(outputPath, source))
-  );
+  const srcRel = `src/${relWithoutDist}`;
+  const tsRel = srcRel.replace(/\.js$/, ".ts");
+  const tsAbs = path9.resolve(rootDir, tsRel);
+  if (fs8.existsSync(tsAbs)) return tsAbs;
+  return path9.resolve(rootDir, srcRel);
 }
-async function writeSchemaFile(outputPath, source) {
-  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
-  await fs4.writeFile(outputPath, source, "utf-8");
+var devOnDemandEnabled = false;
+function isDevOnDemandEnabled() {
+  return devOnDemandEnabled;
+}
+var devDistDir;
+function getDevDist() {
+  return devDistDir;
 }
 
 // src/validator/validateInput.ts
@@ -2317,7 +2759,7 @@ function invalidateSchemaCache() {
 async function loadSchemaModule(schemaPath) {
   let mod = moduleCache.get(schemaPath);
   if (!mod) {
-    mod = await importWithCacheBust(schemaPath);
+    mod = await importWithCacheBust(schemaPath, isDevOnDemandEnabled());
     moduleCache.set(schemaPath, mod);
   }
   return mod;
@@ -2353,9 +2795,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue.code, issue.message);
-    const path11 = issue.path.map(String).join(".") || "";
+    const path15 = issue.path.map(String).join(".") || "";
     return {
-      path: path11,
+      path: path15,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -2403,45 +2845,45 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable2 } from "stream";
-import path7 from "path";
+import path11 from "path";
 
 // src/router/matchRoute.ts
-function matchRoute(routes, method, path11) {
+function matchRoute(routes, method, path15) {
   for (const route of routes) {
     if (route.method !== method) {
       continue;
     }
     if (!route.isDynamic) {
-      if (route.urlPath === path11) {
+      if (route.urlPath === path15) {
         return { route, params: {} };
       }
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path11) {
+function matchWsRoute(wsRoutes, path15) {
   for (const route of wsRoutes) {
     if (!route.isDynamic) {
-      if (route.urlPath === path11) {
+      if (route.urlPath === path15) {
         return { route, params: {} };
       }
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchDynamicPath(pattern, path11, paramNames, isCatchAll) {
+function matchDynamicPath(pattern, path15, paramNames, isCatchAll) {
   const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path11.split("/").filter(Boolean);
+  const pathSegments = path15.split("/").filter(Boolean);
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -2486,6 +2928,9 @@ function matchDynamicPath(pattern, path11, paramNames, isCatchAll) {
   return params;
 }
 
+// src/loader/loadRouteModule.ts
+import fs9 from "fs";
+
 // src/loader/resolveExports.ts
 function resolveExport(module, exportName) {
   if (exportName in module && typeof module[exportName] !== "undefined") {
@@ -2511,10 +2956,26 @@ function validateRouteModule(value, method, filePath) {
 }
 
 // src/loader/loadRouteModule.ts
-async function loadRouteModule(filePath, method) {
+async function loadRouteModule(filePath, method, rootDir) {
+  if (isDevOnDemandEnabled() && rootDir) {
+    const dist = getDevDist();
+    if (dist) {
+      const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+      if (sourcePath && fs9.existsSync(sourcePath)) {
+        try {
+          await ensureCompiled(sourcePath, rootDir, dist);
+        } catch (compileErr) {
+          const reason = compileErr instanceof Error ? compileErr.message : String(compileErr);
+          throw new Error(`Failed to compile route module "${sourcePath}": ${reason}`, {
+            cause: compileErr
+          });
+        }
+      }
+    }
+  }
   let module;
   try {
-    module = await importWithCacheBust(filePath);
+    module = await importWithCacheBust(filePath, isDevOnDemandEnabled());
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to load route module "${filePath}": ${reason}`, { cause: err });
@@ -2565,6 +3026,7 @@ async function parseMultipart(request) {
 }
 
 // src/runtime/resolveInput.ts
+init_inputType();
 async function resolveInput(method, request) {
   const inputType = getInputTypeForMethod(method);
   if (inputType === "body") {
@@ -2628,6 +3090,9 @@ async function sendNodeResponse(response, res) {
   res.end();
 }
 
+// src/server/createServer.ts
+init_inputType();
+
 // src/utils/getClientIp.ts
 function getClientIp(req) {
   const xff = req.headers["x-forwarded-for"];
@@ -2646,8 +3111,9 @@ function getClientIp(req) {
 }
 
 // src/server/handleWsUpgrade.ts
+import fs10 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path6 from "path";
+import path10 from "path";
 
 // src/errors/formatErrorResponse.ts
 function formatErrorResponse(error) {
@@ -2744,8 +3210,17 @@ function getPathname(req) {
   const idx = url.indexOf("?");
   return idx >= 0 ? url.slice(0, idx) : url;
 }
-async function loadWsHandler(filePath, ctx) {
-  const module = await importWithCacheBust(filePath);
+async function loadWsHandler(filePath, ctx, rootDir) {
+  if (isDevOnDemandEnabled() && rootDir) {
+    const dist = getDevDist();
+    if (dist) {
+      const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+      if (sourcePath && fs10.existsSync(sourcePath)) {
+        await ensureCompiled(sourcePath, rootDir, dist);
+      }
+    }
+  }
+  const module = await importWithCacheBust(filePath, isDevOnDemandEnabled());
   const handler = module["WS"];
   if (typeof handler !== "function") {
     throw new Error(`WS export not found in ${filePath}`);
@@ -2820,8 +3295,8 @@ function attachWebSocket(options) {
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path6.resolve(rootDir, route.filePath);
-        handlers = await loadWsHandler(absoluteFilePath, ctx);
+        const absoluteFilePath = path10.resolve(rootDir, route.filePath);
+        handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
         console.error(`[faapi] WS handler \u52A0\u8F7D\u5931\u8D25 ${route.filePath}: ${reason}`);
@@ -2843,6 +3318,14 @@ function attachWebSocket(options) {
     };
     let response;
     try {
+      if (route.middlewares === void 0 && route.middlewarePaths) {
+        const bundle = await loadMergedMiddlewares(route.middlewarePaths);
+        if (bundle) {
+          route.middlewares = bundle.middlewares;
+        } else {
+          route.middlewares = [];
+        }
+      }
       const dirMiddlewares = route.middlewares ?? [];
       const allMiddlewares = globalMiddlewares && globalMiddlewares.length > 0 ? [...globalMiddlewares, ...dirMiddlewares] : dirMiddlewares;
       if (allMiddlewares.length > 0) {
@@ -2866,6 +3349,7 @@ function attachWebSocket(options) {
 }
 
 // src/server/createServer.ts
+init_generateSchemaFiles();
 var DEFAULT_BODY_LIMIT = 10 * 1024 * 1024;
 function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
   const forwardedProto = req.headers["x-forwarded-proto"];
@@ -2910,15 +3394,15 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path11) {
+function findAllowedMethods(routes, path15) {
   const methods = /* @__PURE__ */ new Set();
   for (const route of routes) {
-    if (route.urlPath === path11) {
+    if (route.urlPath === path15) {
       methods.add(route.method);
       continue;
     }
     if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+      const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
       if (params !== null) {
         methods.add(route.method);
       }
@@ -3004,16 +3488,32 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
     }
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path7.resolve(rootDir, route.filePath);
-    const routeModule = await loadRouteModule(absoluteFilePath, route.method);
+    const absoluteFilePath = path11.resolve(rootDir, route.filePath);
+    const routeModule = await loadRouteModule(absoluteFilePath, route.method, rootDir);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
     const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
+    if (isDevOnDemandEnabled()) {
+      const devDist = getDevDist();
+      if (devDist) {
+        await ensureSchemaGenerated(schemaPath, route.filePath, routes, rootDir, dist);
+      }
+    }
     const result = await validateInput(schemaPath, route.method, inputType, input);
     if (!result.valid) {
       throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", result.issues);
     }
     const body = hasBody(route.method) ? result.data : void 0;
+    if (route.middlewares === void 0 && route.injectors === void 0 && route.middlewarePaths) {
+      const bundle = await loadMergedMiddlewares(route.middlewarePaths);
+      if (bundle) {
+        route.middlewares = bundle.middlewares;
+        route.injectors = bundle.injectors;
+      } else {
+        route.middlewares = [];
+        route.injectors = {};
+      }
+    }
     const mergedInjectors = globalInjectors ? { ...globalInjectors, ...route.injectors } : route.injectors;
     const response = await invokeHandler(
       routeModule.handler,
@@ -3068,7 +3568,7 @@ async function createTestServer(options) {
   } = options;
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns);
   const sorted = sortRoutes(routes);
-  const schemaDist = dist ? path8.isAbsolute(dist) ? dist : path8.resolve(rootDir, dist) : await fs5.mkdtemp(path8.join(os.tmpdir(), "faapi-test-schema-"));
+  const schemaDist = dist ? path12.isAbsolute(dist) ? dist : path12.resolve(rootDir, dist) : await fs11.mkdtemp(path12.join(os.tmpdir(), "faapi-test-schema-"));
   await generateSchemaFiles(sorted, rootDir, schemaDist);
   const { server } = createServer({
     routes: sorted,
@@ -3101,7 +3601,7 @@ async function createTestServer(options) {
       await new Promise((resolve) => {
         server.close(() => resolve());
       });
-      await fs5.rm(schemaDist, { recursive: true, force: true }).catch(() => {
+      await fs11.rm(schemaDist, { recursive: true, force: true }).catch(() => {
       });
       invalidateSchemaCache();
     }
@@ -3243,8 +3743,8 @@ async function connectWs(baseUrl, pathname, options = {}) {
 }
 
 // src/cli/createAppCore.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs13 from "fs";
+import path14 from "path";
 import { PassThrough } from "stream";
 
 // src/router/detectRouteConflicts.ts
@@ -3301,55 +3801,30 @@ function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
 }
 
 // src/cli/generateRoutes.ts
-import fs6 from "fs";
-import path9 from "path";
+import fs12 from "fs";
+import path13 from "path";
 async function hydrateRoutes(manifest) {
-  const hydrateRoute = async (serialized) => {
-    const bundle = await loadMiddlewarePaths(serialized.middlewarePaths);
-    return {
-      method: serialized.method,
-      urlPath: serialized.urlPath,
-      filePath: serialized.filePath,
-      paramNames: serialized.paramNames,
-      isDynamic: serialized.isDynamic,
-      isCatchAll: serialized.isCatchAll,
-      middlewares: bundle?.middlewares,
-      injectors: bundle?.injectors
-    };
-  };
-  const hydrateWsRoute = async (serialized) => {
-    const bundle = await loadMiddlewarePaths(serialized.middlewarePaths);
-    return {
-      urlPath: serialized.urlPath,
-      filePath: serialized.filePath,
-      paramNames: serialized.paramNames,
-      isDynamic: serialized.isDynamic,
-      isCatchAll: serialized.isCatchAll,
-      middlewares: bundle?.middlewares,
-      injectors: bundle?.injectors
-    };
-  };
-  const routes = await Promise.all(manifest.routes.map(hydrateRoute));
-  const wsRoutes = await Promise.all(manifest.wsRoutes.map(hydrateWsRoute));
+  const hydrateRoute = (serialized) => ({
+    method: serialized.method,
+    urlPath: serialized.urlPath,
+    filePath: serialized.filePath,
+    paramNames: serialized.paramNames,
+    isDynamic: serialized.isDynamic,
+    isCatchAll: serialized.isCatchAll,
+    middlewarePaths: serialized.middlewarePaths
+  });
+  const hydrateWsRoute = (serialized) => ({
+    urlPath: serialized.urlPath,
+    filePath: serialized.filePath,
+    paramNames: serialized.paramNames,
+    isDynamic: serialized.isDynamic,
+    isCatchAll: serialized.isCatchAll,
+    middlewarePaths: serialized.middlewarePaths
+  });
+  const routes = manifest.routes.map(hydrateRoute);
+  const wsRoutes = manifest.wsRoutes.map(hydrateWsRoute);
   return { routes, wsRoutes };
 }
-async function loadMiddlewarePaths(middlewarePaths) {
-  if (middlewarePaths.length === 0) return void 0;
-  const mergedMiddlewares = [];
-  const mergedInjectors = {};
-  for (const absMwPath of middlewarePaths) {
-    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 { middlewares: mergedMiddlewares, injectors: mergedInjectors };
-}
 
 // src/cli/loadPlugins.ts
 async function loadPlugins(declarations, ctx) {
@@ -3433,8 +3908,8 @@ function isFaapiConfigKey(key) {
 async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
-  const routesPath = path10.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs7.existsSync(routesPath)) {
+  const routesPath = path14.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs13.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -3607,6 +4082,10 @@ async function createAppBase(options) {
       if (config?.lifecycle?.onClose) {
         await config.lifecycle.onClose({ rootDir, routes: sorted, server });
       }
+      if (!server.listening) {
+        app.server = null;
+        return;
+      }
       return new Promise((resolve) => {
         server.close((err) => {
           if (err) console.error("Error closing server:", err);
@@ -3636,6 +4115,7 @@ async function createAppBase(options) {
 }
 
 // src/cli/createDevApp.ts
+init_createProgram();
 async function createDevApp(options) {
   const { app, ctx } = await createAppBase(options);
   const devApp = app;
@@ -3644,9 +4124,16 @@ async function createDevApp(options) {
     invalidateMiddlewareCache();
     invalidateProgramCache();
     invalidateSchemaCache();
+    clearCompiledFiles();
     const reScanned = await scanRoutes(ctx.rootDir, ctx.patterns, ctx.dist);
     const sorted = sortRoutes(reScanned.routes);
-    await generateSchemaFiles(sorted, ctx.rootDir, ctx.dist);
+    if (isDevOnDemandEnabled()) {
+      await deleteSchemaFiles(sorted, ctx.rootDir, ctx.dist);
+      clearGeneratedSchemas();
+    } else {
+      const { generateSchemaFiles: generateSchemaFiles2 } = await Promise.resolve().then(() => (init_generateSchemaFiles(), generateSchemaFiles_exports));
+      await generateSchemaFiles2(sorted, ctx.rootDir, ctx.dist);
+    }
     ctx.updateRoutes(sorted, reScanned.wsRoutes);
   };
   return devApp;