@faapi/faapi 1.1.1-canary.0 → 1.2.0

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,1468 +894,1510 @@ 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 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 getVitestImportActual() {
-  const vi = globalThis.vi;
-  if (typeof vi?.importActual !== "function") return void 0;
-  return vi.importActual.bind(vi);
+function applyConstraints(baseExpr, constraints, typeKind) {
+  const suffix = constraints.map((c) => constraintToZodChain(c, typeKind)).join("");
+  return `${baseExpr}${suffix}`;
 }
-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 constraintToZodChain(constraint, _typeKind) {
+  switch (constraint.kind) {
+    case "max":
+      return `.max(${constraint.value})`;
+    case "min":
+      return `.min(${constraint.value})`;
+    case "int":
+      return ".int()";
+    case "positive":
+      return ".positive()";
+    case "negative":
+      return ".negative()";
+    case "nonnegative":
+      return ".nonnegative()";
+    case "nonpositive":
+      return ".nonpositive()";
+    case "maxLength":
+      return `.max(${constraint.value})`;
+    case "minLength":
+      return `.min(${constraint.value})`;
+    case "length":
+      return `.length(${constraint.value})`;
+    case "regex": {
+      const flags = constraint.flags ?? "";
+      return `.regex(new RegExp(${JSON.stringify(constraint.pattern)}${flags ? `, ${JSON.stringify(flags)}` : ""}))`;
+    }
+    case "email":
+      return ".email()";
+    case "url":
+      return ".url()";
+    case "uuid":
+      return ".uuid()";
   }
-  return await import(url);
 }
-
-// src/config/loadConfig.ts
-var CONFIG_PRODUCT_FILE = "faapi-config.js";
-async function loadConfig(rootDir, dist) {
-  const configProductPath = path2.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
-  if (fs.existsSync(configProductPath)) {
-    const module = await importWithCacheBust(configProductPath);
-    return module.default ?? {};
-  }
-  const hasSourceConfig = fs.existsSync(path2.join(rootDir, "faapi.config.ts")) || fs.existsSync(path2.join(rootDir, "faapi.config.js"));
-  if (hasSourceConfig) {
-    throw new Error(
-      `[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`
-    );
+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`;
   }
-  return null;
 }
-
-// src/cli/loadEnv.ts
-import fs2 from "fs";
-import path3 from "path";
-function resolveEnv() {
-  return process.env.NODE_ENV || "development";
+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 getEnvFiles(env) {
-  return [".env", ".env.local", `.env.${env}`, `.env.${env}.local`];
+function usesCoerceHelpers(code) {
+  return code.includes("coerceNumber") || code.includes("coerceBoolean") || code.includes("coerceMap") || code.includes("coerceSet");
 }
-function parseEnvFile(content, fileVars) {
-  const result = {};
-  const lines = content.replace(/\r\n/g, "\n").split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(trimmed);
-    if (!match) continue;
-    const [, key, rawValue] = match;
-    const value = parseValue(rawValue, { ...fileVars, ...result });
-    result[key] = value;
+function wrapCoercePreprocess(kind, inner) {
+  if (kind === "number") {
+    return `z.preprocess(coerceNumber, ${inner})`;
   }
-  return result;
+  return `z.preprocess(coerceBoolean, ${inner})`;
 }
-function parseValue(raw, env) {
-  if (raw === "") return "";
-  if (raw[0] === "'") {
-    const end = raw.indexOf("'", 1);
-    return end === -1 ? raw.slice(1) : raw.slice(1, end);
+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 (raw[0] === '"') {
-    const match = /^"((?:\\.|[^"\\])*)"/.exec(raw);
-    const inner = match ? match[1] : raw.slice(1);
-    return expandEscapesAndVars(inner, env);
+  if (restExpression) {
+    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
   }
-  const commentMatch = /^(.*?)(\s+#.*)$/.exec(raw);
-  const value = commentMatch ? commentMatch[1] : raw;
-  return value.trim();
-}
-function expandEscapesAndVars(str, env) {
-  const escaped = str.replace(/\\(.)/g, (_, ch) => {
-    switch (ch) {
-      case "n":
-        return "\n";
-      case "r":
-        return "\r";
-      case "t":
-        return "	";
-      case "\\":
-        return "\\";
-      case '"':
-        return '"';
-      default:
-        return ch;
+  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 escaped.replace(
-    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g,
-    (_, braced, plain) => {
-      const varName = braced || plain;
-      return env[varName] ?? process.env[varName] ?? "";
-    }
-  );
+  return `z.object({ ${fields.join(", ")} })`;
 }
-function loadEnv(rootDir) {
-  const env = resolveEnv();
-  const files = getEnvFiles(env);
-  const merged = {};
-  for (const file of files) {
-    const filePath = path3.join(rootDir, file);
-    if (!fs2.existsSync(filePath)) continue;
-    const content = fs2.readFileSync(filePath, "utf-8");
-    const parsed = parseEnvFile(content, merged);
-    Object.assign(merged, parsed);
+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()`;
   }
-  for (const [key, value] of Object.entries(merged)) {
-    if (process.env[key] === void 0) {
-      process.env[key] = value;
-    }
+  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}])`;
 }
-
-// src/errors/FaapiError.ts
-var FaapiError = class extends Error {
-  constructor(code, message, statusCode) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.name = "FaapiError";
+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});`;
   }
-  code;
-  statusCode;
-};
-
-// src/errors/httpErrors.ts
-function deriveStatusCode(issues) {
-  const has400 = issues.some((i) => i.code === "INVALID_FORMAT" || i.code === "MISSING_FIELD");
-  return has400 ? 400 : 422;
+  return `const ${name}Schema = ${expr};`;
 }
-var ValidationError = class extends FaapiError {
-  constructor(message, issues) {
-    super("VALIDATION_ERROR", message, deriveStatusCode(issues));
-    this.issues = issues;
-    this.name = "ValidationError";
-  }
-  issues;
-};
-var RouteNotFoundError = class extends FaapiError {
-  constructor(path11) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path11}`, 404);
-    this.name = "RouteNotFoundError";
-  }
-};
-var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path11, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path11}`, 405);
-    this.allowedMethods = allowedMethods;
-    this.name = "MethodNotAllowedError";
+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;
   }
-  allowedMethods;
-};
-var InternalError = class extends FaapiError {
-  constructor(message) {
-    super("INTERNAL_ERROR", message, 500);
-    this.name = "InternalError";
+}
+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));
   }
-};
-var ModuleLoadError = class extends FaapiError {
-  constructor(filePath, reason) {
-    super("MODULE_LOAD_ERROR", `Failed to load module ${filePath}: ${reason}`, 500);
-    this.name = "ModuleLoadError";
+  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/runtime/sse.ts
-function encodeSseEvent(event) {
-  let out = "";
-  if (event.comment !== void 0) {
-    out += `: ${event.comment}
-`;
+// 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);
   }
-  if (event.event !== void 0) {
-    out += `event: ${event.event}
-`;
+  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);
   }
-  if (event.id !== void 0) {
-    out += `id: ${event.id}
-`;
+  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"));
   }
-  if (event.retry !== void 0) {
-    out += `retry: ${event.retry}
-`;
+  const allSchemaCode = schemaBlocks.join("\n");
+  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
+    lines.push(
+      `import { coerceNumber, coerceBoolean, coerceMap, coerceSet } from '${helpersImportPath}';`
+    );
   }
-  if (event.data !== void 0) {
-    let dataStr;
-    if (typeof event.data === "string") {
-      dataStr = event.data;
-    } else if (event.data === null) {
-      dataStr = "null";
-    } else {
-      dataStr = JSON.stringify(event.data);
+  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);
     }
-    const lines = dataStr.split("\n");
-    for (const line of lines) {
-      out += `data: ${line}
-`;
+    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 });
   }
-  out += "\n";
-  return out;
+  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))
+  );
 }
-function createSseWriter() {
-  const encoder = new TextEncoder();
-  let controller = null;
-  let closed = false;
-  let aborted = false;
-  const stream = new ReadableStream({
-    start(c) {
-      controller = c;
-    },
-    cancel() {
-      aborted = true;
-      closed = true;
-      controller = null;
-    }
-  });
-  const response = new Response(stream, {
-    status: 200,
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    }
-  });
-  const writer = {
-    send(event) {
-      if (closed || !controller) return;
-      const text = encodeSseEvent(event);
-      controller.enqueue(encoder.encode(text));
-    },
-    sendRaw(chunk) {
-      if (closed || !controller) return;
-      const bytes = typeof chunk === "string" ? encoder.encode(chunk) : chunk;
-      controller.enqueue(bytes);
-    },
-    sendError(error) {
-      if (closed || !controller) return;
-      const message = error instanceof Error ? error.message : String(error);
-      const text = encodeSseEvent({ event: "error", data: message });
-      try {
-        controller.enqueue(encoder.encode(text));
-      } finally {
-        writer.close();
-      }
-    },
-    close() {
-      if (closed) return;
-      closed = true;
-      if (controller) {
-        try {
-          controller.close();
-        } catch {
-        }
-        controller = null;
-      }
-    },
-    get closed() {
-      return closed;
-    },
-    get aborted() {
-      return aborted;
-    },
-    get response() {
-      return response;
-    }
-  };
-  return writer;
+async function writeSchemaFile(outputPath, source) {
+  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
+  await fs4.writeFile(outputPath, source, "utf-8");
 }
-
-// src/runtime/createContext.ts
-function parseCookies(cookieHeader) {
-  const cookies = /* @__PURE__ */ new Map();
-  if (!cookieHeader) return cookies;
-  for (const pair of cookieHeader.split(";")) {
-    const [name, ...rest] = pair.split("=");
-    const trimmed = name?.trim();
-    if (trimmed) {
-      cookies.set(trimmed, rest.join("=").trim());
-    }
+var init_generateSchemaFiles = __esm({
+  "src/cli/generateSchemaFiles.ts"() {
+    "use strict";
+    init_collectRouteSchemaSources();
+    init_generateZodSchema();
   }
-  return cookies;
-}
-function formatSetCookie(name, value, options) {
-  let cookie = `${name}=${value}`;
-  if (options?.domain) cookie += `; Domain=${options.domain}`;
-  if (options?.path) cookie += `; Path=${options.path}`;
-  if (options?.maxAge !== void 0) cookie += `; Max-Age=${options.maxAge}`;
-  if (options?.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
-  if (options?.httpOnly) cookie += `; HttpOnly`;
-  if (options?.secure) cookie += `; Secure`;
-  if (options?.sameSite) cookie += `; SameSite=${options.sameSite}`;
-  return cookie;
-}
-function createContext(request, params, config = {}, ip = "") {
-  const url = new URL(request.url);
-  const meta = { headers: {}, setCookies: [] };
-  const parsedCookies = parseCookies(request.headers.get("cookie") ?? "");
-  const cookiesObj = {};
-  for (const [key, val] of parsedCookies) {
-    cookiesObj[key] = val;
-  }
-  const ctx = {
-    request,
-    params,
-    query: url.searchParams,
-    headers: request.headers,
-    method: request.method,
-    path: url.pathname,
-    ip,
-    ua: request.headers.get("user-agent") ?? "",
-    cookies: cookiesObj,
-    config,
-    meta,
-    setStatus(status) {
-      meta.status = status;
-    },
-    setHeader(key, value) {
-      meta.headers[key] = value;
-    },
-    setETag(value) {
-      meta.headers["etag"] = value;
-    },
-    redirect(url2, status = 302) {
-      return new Response(null, {
-        status,
-        headers: { Location: url2 }
-      });
-    },
-    json(data, status) {
-      const headers = { "Content-Type": "application/json" };
-      return new Response(JSON.stringify(data), {
-        status: status ?? 200,
-        headers
-      });
-    },
-    html(html, status) {
-      const headers = { "Content-Type": "text/html; charset=utf-8" };
-      return new Response(html, {
-        status: status ?? 200,
-        headers
-      });
-    },
-    getCookie(name) {
-      return parsedCookies.get(name);
-    },
-    setCookie(name, value, options) {
-      meta.setCookies.push(formatSetCookie(name, value, options));
-    },
-    deleteCookie(name) {
-      meta.setCookies.push(formatSetCookie(name, "", { maxAge: 0 }));
-    },
-    /**
-     * 创建 SSE writer，用于流式推送事件
-     *
-     * handler 调用此方法后，通过返回的 writer 推送事件，框架自动把 writer.response
-     * 作为 HTTP 响应（Content-Type: text/event-stream）。
-     *
-     * 与 ctx.json / ctx.html 互斥：一个 handler 只能用一种响应方式。
-     */
-    sse() {
-      const writer = createSseWriter();
-      const ctxWithSse = ctx;
-      ctxWithSse.__sseResponse = writer.response;
-      ctxWithSse.__sseWriter = writer;
-      return writer;
+});
+
+// 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();
   };
-  const extend = config?.extendContext;
-  if (typeof extend === "function") {
-    extend(ctx);
-  }
-  return ctx;
 }
 
-// src/utils/isPlainObject.ts
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === null || proto === Object.prototype;
+// 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/response/toResponse.ts
-async function toResponse(value, meta) {
-  if (value instanceof Promise) {
-    return toResponse(await value, meta);
-  }
-  const applyMeta = (headers2) => {
-    if (!meta) return;
-    for (const [key, val] of Object.entries(meta.headers)) {
-      headers2.set(key, val);
+// 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);
     }
-    for (const cookie of meta.setCookies ?? []) {
-      headers2.append("set-cookie", cookie);
+    if (opts.xFrameOptions !== false) {
+      ctx.setHeader("X-Frame-Options", opts.xFrameOptions);
     }
-  };
-  if (value instanceof Response) {
-    if (meta && (meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0)) {
-      const headers2 = new Headers(value.headers);
-      applyMeta(headers2);
-      return new Response(value.body, {
-        status: meta.status ?? value.status,
-        headers: headers2
-      });
+    if (opts.xContentTypeOptions) {
+      ctx.setHeader("X-Content-Type-Options", "nosniff");
     }
-    return value;
-  }
-  if (value === null || value === void 0) {
-    const status = meta?.status ?? 204;
-    const headers2 = new Headers();
-    applyMeta(headers2);
-    return new Response(null, { status, headers: headers2 });
+    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) {
+  const importActual = getVitestImportActual();
+  if (importActual) {
+    return await importActual(filePath);
   }
-  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
-    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
-    applyMeta(headers2);
-    return new Response(value, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+  let url = pathToFileURL(filePath).href;
+  if (loadTs !== void 0) {
+    url += `?t=${loadTs}`;
   }
-  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
-    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
-    applyMeta(headers2);
-    return new Response(value, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+  return await import(url);
+}
+
+// src/config/loadConfig.ts
+var CONFIG_PRODUCT_FILE = "faapi-config.js";
+async function loadConfig(rootDir, dist) {
+  const configProductPath = path2.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
+  if (fs.existsSync(configProductPath)) {
+    const module = await importWithCacheBust(configProductPath);
+    return module.default ?? {};
   }
-  if (value instanceof Uint8Array) {
-    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
-    applyMeta(headers2);
-    return new Response(value, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+  const hasSourceConfig = fs.existsSync(path2.join(rootDir, "faapi.config.ts")) || fs.existsSync(path2.join(rootDir, "faapi.config.js"));
+  if (hasSourceConfig) {
+    throw new Error(
+      `[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`
+    );
   }
-  if (isPlainObject(value) || Array.isArray(value)) {
-    const body2 = JSON.stringify(value);
-    const headers2 = new Headers({ "Content-Type": "application/json" });
-    applyMeta(headers2);
-    return new Response(body2, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+  return null;
+}
+
+// src/cli/loadEnv.ts
+import fs2 from "fs";
+import path3 from "path";
+function resolveEnv() {
+  return process.env.NODE_ENV || "development";
+}
+function getEnvFiles(env) {
+  return [".env", ".env.local", `.env.${env}`, `.env.${env}.local`];
+}
+function parseEnvFile(content, fileVars) {
+  const result = {};
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(trimmed);
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    const value = parseValue(rawValue, { ...fileVars, ...result });
+    result[key] = value;
   }
-  if (typeof value === "string") {
-    const headers2 = new Headers({ "Content-Type": "text/plain" });
-    applyMeta(headers2);
-    return new Response(value, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+  return result;
+}
+function parseValue(raw, env) {
+  if (raw === "") return "";
+  if (raw[0] === "'") {
+    const end = raw.indexOf("'", 1);
+    return end === -1 ? raw.slice(1) : raw.slice(1, end);
   }
-  if (typeof value === "number" || typeof value === "boolean") {
-    const headers2 = new Headers({ "Content-Type": "text/plain" });
-    applyMeta(headers2);
-    return new Response(String(value), {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+  if (raw[0] === '"') {
+    const match = /^"((?:\\.|[^"\\])*)"/.exec(raw);
+    const inner = match ? match[1] : raw.slice(1);
+    return expandEscapesAndVars(inner, env);
   }
-  const body = JSON.stringify(value);
-  const headers = new Headers({ "Content-Type": "application/json" });
-  applyMeta(headers);
-  return new Response(body, {
-    status: meta?.status ?? 200,
-    headers
+  const commentMatch = /^(.*?)(\s+#.*)$/.exec(raw);
+  const value = commentMatch ? commentMatch[1] : raw;
+  return value.trim();
+}
+function expandEscapesAndVars(str, env) {
+  const escaped = str.replace(/\\(.)/g, (_, ch) => {
+    switch (ch) {
+      case "n":
+        return "\n";
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      case "\\":
+        return "\\";
+      case '"':
+        return '"';
+      default:
+        return ch;
+    }
   });
+  return escaped.replace(
+    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g,
+    (_, braced, plain) => {
+      const varName = braced || plain;
+      return env[varName] ?? process.env[varName] ?? "";
+    }
+  );
 }
-
-// src/utils/queryToObject.ts
-function queryToObject(params) {
-  const result = {};
-  for (const [key, value] of params) {
-    result[key] = value;
+function loadEnv(rootDir) {
+  const env = resolveEnv();
+  const files = getEnvFiles(env);
+  const merged = {};
+  for (const file of files) {
+    const filePath = path3.join(rootDir, file);
+    if (!fs2.existsSync(filePath)) continue;
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const parsed = parseEnvFile(content, merged);
+    Object.assign(merged, parsed);
+  }
+  for (const [key, value] of Object.entries(merged)) {
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
   }
-  return result;
 }
 
-// src/injection/injectParams.ts
-function getBuiltinInjectionValue(type, ctx, body) {
-  switch (type) {
-    case "query":
-      return queryToObject(ctx.query);
-    case "params":
-      return ctx.params;
-    case "headers":
-      return ctx.headers;
-    case "context":
-      return ctx;
-    case "cookies":
-      return ctx.cookies;
-    case "ip":
-      return ctx.ip;
-    case "ua":
-      return ctx.ua;
-    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;
-      }
-      return [];
-    case "fields":
-      if (body && typeof body === "object" && "fields" in body) {
-        return body.fields;
-      }
-      return {};
-    default:
-      return void 0;
+// src/errors/FaapiError.ts
+var FaapiError = class extends Error {
+  constructor(code, message, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "FaapiError";
   }
+  code;
+  statusCode;
+};
+
+// src/errors/httpErrors.ts
+function deriveStatusCode(issues) {
+  const has400 = issues.some((i) => i.code === "INVALID_FORMAT" || i.code === "MISSING_FIELD");
+  return has400 ? 400 : 422;
 }
-async function injectParamsAsync(handler, ctx, body, injectors) {
-  const injections = resolveInjection(handler);
-  if (injections.length === 0) {
-    return await handler();
+var ValidationError = class extends FaapiError {
+  constructor(message, issues) {
+    super("VALIDATION_ERROR", message, deriveStatusCode(issues));
+    this.issues = issues;
+    this.name = "ValidationError";
   }
-  const args = await Promise.all(
-    injections.map(async (injection) => {
-      if (injection.type !== "unknown") {
-        return getBuiltinInjectionValue(injection.type, ctx, body);
-      }
-      if (injectors && injection.name in injectors) {
-        return await injectors[injection.name](ctx);
-      }
-      return void 0;
-    })
-  );
-  return await handler(...args);
-}
+  issues;
+};
+var RouteNotFoundError = class extends FaapiError {
+  constructor(path15) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path15}`, 404);
+    this.name = "RouteNotFoundError";
+  }
+};
+var MethodNotAllowedError = class extends FaapiError {
+  constructor(method, path15, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path15}`, 405);
+    this.allowedMethods = allowedMethods;
+    this.name = "MethodNotAllowedError";
+  }
+  allowedMethods;
+};
+var InternalError = class extends FaapiError {
+  constructor(message) {
+    super("INTERNAL_ERROR", message, 500);
+    this.name = "InternalError";
+  }
+};
+var ModuleLoadError = class extends FaapiError {
+  constructor(filePath, reason) {
+    super("MODULE_LOAD_ERROR", `Failed to load module ${filePath}: ${reason}`, 500);
+    this.name = "ModuleLoadError";
+  }
+};
 
-// src/runtime/invokeHandler.ts
-function mergeMeta(response, meta) {
-  const hasMeta = meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0;
-  if (!hasMeta) return response;
-  const headers = new Headers(response.headers);
-  for (const [key, value] of Object.entries(meta.headers)) {
-    headers.set(key, value);
+// src/runtime/sse.ts
+function encodeSseEvent(event) {
+  let out = "";
+  if (event.comment !== void 0) {
+    out += `: ${event.comment}
+`;
   }
-  for (const cookie of meta.setCookies) {
-    headers.append("set-cookie", cookie);
+  if (event.event !== void 0) {
+    out += `event: ${event.event}
+`;
   }
-  return new Response(response.body, {
-    status: meta.status ?? response.status,
-    headers
-  });
-}
-async function compose(middlewares, ctx, finalHandler) {
-  const meta = ctx.meta;
-  let index = -1;
-  async function dispatch(i) {
-    if (i <= index) {
-      throw new Error("next() called multiple times");
-    }
-    index = i;
-    if (i >= middlewares.length) {
-      return await finalHandler();
-    }
-    const mw = middlewares[i];
-    let innerResponse;
-    const next = async () => {
-      innerResponse = await dispatch(i + 1);
-      return innerResponse;
-    };
-    const result = await mw(ctx, next);
-    if (result instanceof Response) {
-      return mergeMeta(result, meta);
+  if (event.id !== void 0) {
+    out += `id: ${event.id}
+`;
+  }
+  if (event.retry !== void 0) {
+    out += `retry: ${event.retry}
+`;
+  }
+  if (event.data !== void 0) {
+    let dataStr;
+    if (typeof event.data === "string") {
+      dataStr = event.data;
+    } else if (event.data === null) {
+      dataStr = "null";
+    } else {
+      dataStr = JSON.stringify(event.data);
     }
-    if (innerResponse !== void 0) {
-      return innerResponse;
+    const lines = dataStr.split("\n");
+    for (const line of lines) {
+      out += `data: ${line}
+`;
     }
-    throw new Error("\u4E2D\u95F4\u4EF6\u5FC5\u987B await next() \u6216\u8FD4\u56DE Response");
   }
-  return await dispatch(0);
+  out += "\n";
+  return out;
 }
-async function invokeHandler(handler, ctx, body, middlewares, injectors) {
-  const meta = ctx.meta;
-  const pickSseAndAutoClose = () => {
-    const sseWriter = ctx.__sseWriter;
-    if (!sseWriter) return null;
-    if (!sseWriter.closed && !sseWriter.aborted) {
-      sseWriter.close();
-    }
-    return mergeMeta(sseWriter.response, meta);
-  };
-  const autoCloseSseOnError = () => {
-    const sseWriter = ctx.__sseWriter;
-    if (sseWriter && !sseWriter.closed && !sseWriter.aborted) {
-      sseWriter.close();
+function createSseWriter() {
+  const encoder = new TextEncoder();
+  let controller = null;
+  let closed = false;
+  let aborted = false;
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    },
+    cancel() {
+      aborted = true;
+      closed = true;
+      controller = null;
     }
-  };
-  if (!middlewares || middlewares.length === 0) {
-    try {
-      const result = await injectParamsAsync(handler, ctx, body, injectors);
-      const sseResponse = pickSseAndAutoClose();
-      if (sseResponse) return sseResponse;
-      return toResponse(result, meta);
-    } catch (err) {
-      autoCloseSseOnError();
-      throw err;
+  });
+  const response = new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
     }
-  }
-  const finalHandler = async () => {
-    try {
-      const result = await injectParamsAsync(handler, ctx, body, injectors);
-      const sseResponse = pickSseAndAutoClose();
-      if (sseResponse) return sseResponse;
-      return toResponse(result, meta);
-    } catch (err) {
-      autoCloseSseOnError();
-      throw err;
+  });
+  const writer = {
+    send(event) {
+      if (closed || !controller) return;
+      const text = encodeSseEvent(event);
+      controller.enqueue(encoder.encode(text));
+    },
+    sendRaw(chunk) {
+      if (closed || !controller) return;
+      const bytes = typeof chunk === "string" ? encoder.encode(chunk) : chunk;
+      controller.enqueue(bytes);
+    },
+    sendError(error) {
+      if (closed || !controller) return;
+      const message = error instanceof Error ? error.message : String(error);
+      const text = encodeSseEvent({ event: "error", data: message });
+      try {
+        controller.enqueue(encoder.encode(text));
+      } finally {
+        writer.close();
+      }
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      if (controller) {
+        try {
+          controller.close();
+        } catch {
+        }
+        controller = null;
+      }
+    },
+    get closed() {
+      return closed;
+    },
+    get aborted() {
+      return aborted;
+    },
+    get response() {
+      return response;
     }
   };
-  return await compose(middlewares, ctx, finalHandler);
-}
-
-// src/testServer.ts
-import path8 from "path";
-import os from "os";
-import fs5 from "fs/promises";
-
-// src/router/scanRoutes.ts
-import fg from "fast-glob";
-import path4 from "path";
-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, "/");
-  result = result.replace(/\/+/g, "/");
-  result = result.replace(/\/+$/, "");
-  if (result && !result.startsWith("/")) {
-    result = "/" + result;
-  }
-  return result;
+  return writer;
 }
 
-// src/router/parseRouteFile.ts
-function dynamicSegmentToParam(segment) {
-  const match = segment.match(/^\[(.+)\]$/);
-  if (match) {
-    return ":" + match[1];
-  }
-  return segment;
-}
-function extractParamNames(urlPath) {
-  const params = [];
-  const segments = urlPath.split("/");
-  for (const segment of segments) {
-    if (segment.startsWith(":...")) {
-      params.push(segment.slice(4));
-    } else if (segment.startsWith(":")) {
-      params.push(segment.slice(1));
+// src/runtime/createContext.ts
+function parseCookies(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader) return cookies;
+  for (const pair of cookieHeader.split(";")) {
+    const [name, ...rest] = pair.split("=");
+    const trimmed = name?.trim();
+    if (trimmed) {
+      cookies.set(trimmed, rest.join("=").trim());
     }
   }
-  return params;
-}
-function isCatchAllSegment(segment) {
-  return /^\[\.\.\..+\]$/.test(segment);
+  return cookies;
 }
-function isRouteGroup(segment) {
-  return /^\(.+\)$/.test(segment);
+function formatSetCookie(name, value, options) {
+  let cookie = `${name}=${value}`;
+  if (options?.domain) cookie += `; Domain=${options.domain}`;
+  if (options?.path) cookie += `; Path=${options.path}`;
+  if (options?.maxAge !== void 0) cookie += `; Max-Age=${options.maxAge}`;
+  if (options?.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options?.httpOnly) cookie += `; HttpOnly`;
+  if (options?.secure) cookie += `; Secure`;
+  if (options?.sameSite) cookie += `; SameSite=${options.sameSite}`;
+  return cookie;
 }
-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) {
-    return "";
+function createContext(request, params, config = {}, ip = "") {
+  const url = new URL(request.url);
+  const meta = { headers: {}, setCookies: [] };
+  const parsedCookies = parseCookies(request.headers.get("cookie") ?? "");
+  const cookiesObj = {};
+  for (const [key, val] of parsedCookies) {
+    cookiesObj[key] = val;
   }
-  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
-  return normalizePath(segments.join("/"));
-}
-
-// src/middleware/loadMiddlewares.ts
-var middlewareCache = /* @__PURE__ */ new Map();
-function invalidateMiddlewareCache() {
-  middlewareCache.clear();
-}
-function getCachedMiddlewares(absPath) {
-  return middlewareCache.get(absPath);
-}
-function setCachedMiddlewares(absPath, bundle) {
-  middlewareCache.set(absPath, bundle);
-}
-async function loadMiddlewaresFile(filePath) {
-  try {
-    const module = await importWithCacheBust(filePath);
-    const middlewares = module.default ?? module.middlewares ?? [];
-    if (!Array.isArray(middlewares)) {
-      console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: [], injectors: {} };
-    }
-    const validMiddlewares = middlewares.filter((m) => {
-      if (typeof m !== "function") {
-        console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
-        return false;
-      }
-      return true;
-    });
-    const injectors = module.injectors ?? {};
-    if (typeof injectors !== "object" || injectors === null) {
-      console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
-      return { middlewares: validMiddlewares, injectors: {} };
-    }
-    const validInjectors = {};
-    for (const [name, injector] of Object.entries(injectors)) {
-      if (typeof injector !== "function") {
-        console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
-        continue;
-      }
-      validInjectors[name] = injector;
+  const ctx = {
+    request,
+    params,
+    query: url.searchParams,
+    headers: request.headers,
+    method: request.method,
+    path: url.pathname,
+    ip,
+    ua: request.headers.get("user-agent") ?? "",
+    cookies: cookiesObj,
+    config,
+    meta,
+    setStatus(status) {
+      meta.status = status;
+    },
+    setHeader(key, value) {
+      meta.headers[key] = value;
+    },
+    setETag(value) {
+      meta.headers["etag"] = value;
+    },
+    redirect(url2, status = 302) {
+      return new Response(null, {
+        status,
+        headers: { Location: url2 }
+      });
+    },
+    json(data, status) {
+      const headers = { "Content-Type": "application/json" };
+      return new Response(JSON.stringify(data), {
+        status: status ?? 200,
+        headers
+      });
+    },
+    html(html, status) {
+      const headers = { "Content-Type": "text/html; charset=utf-8" };
+      return new Response(html, {
+        status: status ?? 200,
+        headers
+      });
+    },
+    getCookie(name) {
+      return parsedCookies.get(name);
+    },
+    setCookie(name, value, options) {
+      meta.setCookies.push(formatSetCookie(name, value, options));
+    },
+    deleteCookie(name) {
+      meta.setCookies.push(formatSetCookie(name, "", { maxAge: 0 }));
+    },
+    /**
+     * 创建 SSE writer，用于流式推送事件
+     *
+     * handler 调用此方法后，通过返回的 writer 推送事件，框架自动把 writer.response
+     * 作为 HTTP 响应（Content-Type: text/event-stream）。
+     *
+     * 与 ctx.json / ctx.html 互斥：一个 handler 只能用一种响应方式。
+     */
+    sse() {
+      const writer = createSseWriter();
+      const ctxWithSse = ctx;
+      ctxWithSse.__sseResponse = writer.response;
+      ctxWithSse.__sseWriter = writer;
+      return writer;
     }
-    return { middlewares: validMiddlewares, injectors: validInjectors };
-  } catch {
-    return { middlewares: [], injectors: {} };
+  };
+  const extend = config?.extendContext;
+  if (typeof extend === "function") {
+    extend(ctx);
   }
+  return ctx;
 }
 
-// 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);
+// src/utils/isPlainObject.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
   }
-  const prodRel = `${dist}/${rel.replace(/\.ts$/, ".js")}`;
-  return path4.resolve(rootDir, prodRel);
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
 }
-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;
+
+// src/response/toResponse.ts
+async function toResponse(value, meta) {
+  if (value instanceof Promise) {
+    return toResponse(await value, meta);
   }
-  if (mwPaths.length === 0) return void 0;
-  mwPaths.reverse();
-  const mergedMiddlewares = [];
-  const mergedInjectors = {};
-  for (const absMwPath of mwPaths) {
-    let bundle = getCachedMiddlewares(absMwPath);
-    if (bundle === void 0) {
-      bundle = await loadMiddlewaresFile(absMwPath);
-      setCachedMiddlewares(absMwPath, bundle);
+  const applyMeta = (headers2) => {
+    if (!meta) return;
+    for (const [key, val] of Object.entries(meta.headers)) {
+      headers2.set(key, val);
     }
-    mergedMiddlewares.push(...bundle.middlewares);
-    for (const [name, injector] of Object.entries(bundle.injectors)) {
-      mergedInjectors[name] = injector;
+    for (const cookie of meta.setCookies ?? []) {
+      headers2.append("set-cookie", cookie);
     }
-  }
-  if (mergedMiddlewares.length === 0 && Object.keys(mergedInjectors).length === 0) {
-    return void 0;
-  }
-  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
-}
-async function extractMethodsFromHandler(absPath) {
-  try {
-    const module = await importWithCacheBust(absPath);
-    const methods = [];
-    for (const key of Object.keys(module)) {
-      if (isHttpMethod(key) && typeof module[key] === "function") {
-        methods.push(key);
-      }
+  };
+  if (value instanceof Response) {
+    if (meta && (meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0)) {
+      const headers2 = new Headers(value.headers);
+      applyMeta(headers2);
+      return new Response(value.body, {
+        status: meta.status ?? value.status,
+        headers: headers2
+      });
     }
-    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 [];
+    return value;
   }
-}
-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;
+  if (value === null || value === void 0) {
+    const status = meta?.status ?? 204;
+    const headers2 = new Headers();
+    applyMeta(headers2);
+    return new Response(null, { status, headers: headers2 });
   }
-}
-async function scanRoutes(rootDir, patterns, dist) {
-  const files = await fg(patterns, {
-    cwd: rootDir,
-    onlyFiles: true,
-    absolute: false
-  });
-  const routes = [];
-  const wsRoutes = [];
-  for (const file of files) {
-    const normalizedFile = file.replace(/\\/g, "/");
-    const fileName = normalizedFile.split("/").pop();
-    if (fileName === "handler.ts" || fileName === "handler.js") {
-      const absPath = 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);
-      for (const method of methods) {
-        routes.push({
-          method,
-          urlPath,
-          filePath: normalizedFile,
-          paramNames,
-          isDynamic,
-          isCatchAll: isCatchAll || void 0,
-          middlewares: middlewareBundle?.middlewares,
-          injectors: middlewareBundle?.injectors
-        });
-      }
-      const hasWs = await hasWsExport(importPath);
-      if (hasWs) {
-        wsRoutes.push({
-          urlPath,
-          filePath: normalizedFile,
-          paramNames,
-          isDynamic,
-          isCatchAll: isCatchAll || void 0,
-          middlewares: middlewareBundle?.middlewares,
-          injectors: middlewareBundle?.injectors
-        });
-      }
-      continue;
-    }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
   }
-  return { routes, wsRoutes };
-}
-
-// src/router/sortRoutes.ts
-function sortRoutes(routes) {
-  return [...routes].sort((a, b) => {
-    if (a.isDynamic !== b.isDynamic) {
-      return a.isDynamic ? 1 : -1;
-    }
-    if (a.isCatchAll !== b.isCatchAll) {
-      return a.isCatchAll ? 1 : -1;
-    }
-    const aSegments = a.urlPath.split("/").filter(Boolean).length;
-    const bSegments = b.urlPath.split("/").filter(Boolean).length;
-    if (aSegments !== bSegments) {
-      return aSegments - bSegments;
-    }
-    return a.urlPath.localeCompare(b.urlPath);
-  });
-}
-
-// src/cli/generateSchemaFiles.ts
-import path5 from "path";
-import fs4 from "fs/promises";
-
-// 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;
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
   }
-};
-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;
-    }
+  if (value instanceof Uint8Array) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
   }
-}
-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);
+  if (isPlainObject(value) || Array.isArray(value)) {
+    const body2 = JSON.stringify(value);
+    const headers2 = new Headers({ "Content-Type": "application/json" });
+    applyMeta(headers2);
+    return new Response(body2, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (typeof value === "string") {
+    const headers2 = new Headers({ "Content-Type": "text/plain" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
   }
-  return withConstraints;
-}
-function applyConstraints(baseExpr, constraints, typeKind) {
-  const suffix = constraints.map((c) => constraintToZodChain(c, typeKind)).join("");
-  return `${baseExpr}${suffix}`;
+  if (typeof value === "number" || typeof value === "boolean") {
+    const headers2 = new Headers({ "Content-Type": "text/plain" });
+    applyMeta(headers2);
+    return new Response(String(value), {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  const body = JSON.stringify(value);
+  const headers = new Headers({ "Content-Type": "application/json" });
+  applyMeta(headers);
+  return new Response(body, {
+    status: meta?.status ?? 200,
+    headers
+  });
 }
-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()";
+
+// src/injection/injectParams.ts
+init_resolveInjection();
+
+// src/utils/queryToObject.ts
+function queryToObject(params) {
+  const result = {};
+  for (const [key, value] of params) {
+    result[key] = value;
   }
+  return result;
 }
-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`;
+
+// src/injection/injectParams.ts
+function getBuiltinInjectionValue(type, ctx, body) {
+  switch (type) {
+    case "query":
+      return queryToObject(ctx.query);
+    case "params":
+      return ctx.params;
+    case "headers":
+      return ctx.headers;
+    case "context":
+      return ctx;
+    case "cookies":
+      return ctx.cookies;
+    case "ip":
+      return ctx.ip;
+    case "ua":
+      return ctx.ua;
+    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;
       }
-      return `${type.name}Schema`;
+      return [];
+    case "fields":
+      if (body && typeof body === "object" && "fields" in body) {
+        return body.fields;
+      }
+      return {};
+    default:
+      return void 0;
   }
 }
-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})`;
+async function injectParamsAsync(handler, ctx, body, injectors) {
+  const injections = resolveInjection(handler);
+  if (injections.length === 0) {
+    return await handler();
   }
-  return `z.preprocess(coerceBoolean, ${inner})`;
+  const args = await Promise.all(
+    injections.map(async (injection) => {
+      if (injection.type !== "unknown") {
+        return getBuiltinInjectionValue(injection.type, ctx, body);
+      }
+      if (injectors && injection.name in injectors) {
+        return await injectors[injection.name](ctx);
+      }
+      return void 0;
+    })
+  );
+  return await handler(...args);
 }
-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);
-    }
+
+// src/runtime/invokeHandler.ts
+function mergeMeta(response, meta) {
+  const hasMeta = meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0;
+  if (!hasMeta) return response;
+  const headers = new Headers(response.headers);
+  for (const [key, value] of Object.entries(meta.headers)) {
+    headers.set(key, value);
   }
-  if (restExpression) {
-    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
+  for (const cookie of meta.setCookies) {
+    headers.append("set-cookie", cookie);
   }
-  const hasOptional = fixedOptional.some((o) => o);
-  if (!hasOptional) {
-    return `z.tuple([${fixedExprs.join(", ")}])`;
+  return new Response(response.body, {
+    status: meta.status ?? response.status,
+    headers
+  });
+}
+async function compose(middlewares, ctx, finalHandler) {
+  const meta = ctx.meta;
+  let index = -1;
+  async function dispatch(i) {
+    if (i <= index) {
+      throw new Error("next() called multiple times");
+    }
+    index = i;
+    if (i >= middlewares.length) {
+      return await finalHandler();
+    }
+    const mw = middlewares[i];
+    let innerResponse;
+    const next = async () => {
+      innerResponse = await dispatch(i + 1);
+      return innerResponse;
+    };
+    const result = await mw(ctx, next);
+    if (result instanceof Response) {
+      return mergeMeta(result, meta);
+    }
+    if (innerResponse !== void 0) {
+      return innerResponse;
+    }
+    throw new Error("\u4E2D\u95F4\u4EF6\u5FC5\u987B await next() \u6216\u8FD4\u56DE Response");
   }
-  const variants = [];
-  for (let len = fixedExprs.length; len >= 0; len--) {
-    const removed = fixedOptional.slice(len);
-    if (removed.length > 0 && removed.some((o) => !o)) {
-      break;
+  return await dispatch(0);
+}
+async function invokeHandler(handler, ctx, body, middlewares, injectors) {
+  const meta = ctx.meta;
+  const pickSseAndAutoClose = () => {
+    const sseWriter = ctx.__sseWriter;
+    if (!sseWriter) return null;
+    if (!sseWriter.closed && !sseWriter.aborted) {
+      sseWriter.close();
+    }
+    return mergeMeta(sseWriter.response, meta);
+  };
+  const autoCloseSseOnError = () => {
+    const sseWriter = ctx.__sseWriter;
+    if (sseWriter && !sseWriter.closed && !sseWriter.aborted) {
+      sseWriter.close();
+    }
+  };
+  if (!middlewares || middlewares.length === 0) {
+    try {
+      const result = await injectParamsAsync(handler, ctx, body, injectors);
+      const sseResponse = pickSseAndAutoClose();
+      if (sseResponse) return sseResponse;
+      return toResponse(result, meta);
+    } catch (err) {
+      autoCloseSseOnError();
+      throw err;
     }
-    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(", ")} })`;
+  const finalHandler = async () => {
+    try {
+      const result = await injectParamsAsync(handler, ctx, body, injectors);
+      const sseResponse = pickSseAndAutoClose();
+      if (sseResponse) return sseResponse;
+      return toResponse(result, meta);
+    } catch (err) {
+      autoCloseSseOnError();
+      throw err;
+    }
+  };
+  return await compose(middlewares, ctx, finalHandler);
 }
-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/testServer.ts
+import path12 from "path";
+import os from "os";
+import fs9 from "fs/promises";
+
+// src/router/scanRoutes.ts
+import fg from "fast-glob";
+import path4 from "path";
+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);
+
+// src/utils/normalizePath.ts
+function normalizePath(path15) {
+  if (!path15) return "";
+  let result = path15.replace(/\\/g, "/");
+  result = result.replace(/\/+/g, "/");
+  result = result.replace(/\/+$/, "");
+  if (result && !result.startsWith("/")) {
+    result = "/" + result;
   }
-  const unionInner = members.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
-  return `z.union([${unionInner}])`;
+  return result;
 }
-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});`;
+
+// src/router/parseRouteFile.ts
+function dynamicSegmentToParam(segment) {
+  const match = segment.match(/^\[(.+)\]$/);
+  if (match) {
+    return ":" + match[1];
   }
-  return `const ${name}Schema = ${expr};`;
+  return segment;
 }
-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 extractParamNames(urlPath) {
+  const params = [];
+  const segments = urlPath.split("/");
+  for (const segment of segments) {
+    if (segment.startsWith(":...")) {
+      params.push(segment.slice(4));
+    } else if (segment.startsWith(":")) {
+      params.push(segment.slice(1));
+    }
   }
+  return params;
 }
-function 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 isCatchAllSegment(segment) {
+  return /^\[\.\.\..+\]$/.test(segment);
+}
+function isRouteGroup(segment) {
+  return /^\(.+\)$/.test(segment);
+}
+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) {
+    return "";
   }
-  return lines.join("\n");
+  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
+  return normalizePath(segments.join("/"));
 }
 
-// src/cli/generateSchemaFiles.ts
-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");
+// src/middleware/loadMiddlewares.ts
+var middlewareCache = /* @__PURE__ */ new Map();
+function invalidateMiddlewareCache() {
+  middlewareCache.clear();
 }
-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 getCachedMiddlewares(absPath) {
+  return middlewareCache.get(absPath);
 }
-function getHelpersImportPath(relDir) {
-  if (!relDir) return `./${HELPERS_FILENAME}`;
-  const depth = relDir.split("/").filter(Boolean).length;
-  return `${"../".repeat(depth)}${HELPERS_FILENAME}`;
+function setCachedMiddlewares(absPath, bundle) {
+  middlewareCache.set(absPath, bundle);
 }
-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;
+async function loadMiddlewaresFile(filePath) {
+  try {
+    const module = await importWithCacheBust(filePath);
+    const middlewares = module.default ?? module.middlewares ?? [];
+    if (!Array.isArray(middlewares)) {
+      console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+      return { middlewares: [], injectors: {} };
     }
-    const 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 validMiddlewares = middlewares.filter((m) => {
+      if (typeof m !== "function") {
+        console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
+        return false;
+      }
+      return true;
+    });
+    const injectors = module.injectors ?? {};
+    if (typeof injectors !== "object" || injectors === null) {
+      console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+      return { middlewares: validMiddlewares, injectors: {} };
+    }
+    const validInjectors = {};
+    for (const [name, injector] of Object.entries(injectors)) {
+      if (typeof injector !== "function") {
+        console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
+        continue;
+      }
+      validInjectors[name] = injector;
+    }
+    return { middlewares: validMiddlewares, injectors: validInjectors };
+  } catch {
+    return { middlewares: [], injectors: {} };
   }
-  const allSchemaCode = schemaBlocks.join("\n");
-  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
-    lines.push(
-      `import { coerceNumber, coerceBoolean, coerceMap, coerceSet } from '${helpersImportPath}';`
-    );
+}
+async function loadMergedMiddlewares(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;
+    }
+  }
+  if (mergedMiddlewares.length === 0 && Object.keys(mergedInjectors).length === 0) {
+    return void 0;
+  }
+  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
+}
+
+// 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;
+        }
+      }
+    }
+    if (currentDir === resolvedRoot) break;
+    const parentDir = path4.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
   }
-  lines.push("");
-  lines.push(...schemaBlocks);
-  return lines.join("\n").replace(/\n+$/, "\n");
+  paths.reverse();
+  return paths;
 }
-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);
+function toProdFilePath(filePath, dist) {
+  let rel = filePath.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
   }
-  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 jsPath = rel.replace(/\.ts$/, ".js");
+  return jsPath.startsWith(`${dist}/`) ? jsPath : `${dist}/${jsPath}`;
+}
+async function scanRoutes(rootDir, patterns, dist) {
+  const files = await fg(patterns, {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: false
+  });
+  const routes = [];
+  const wsRoutes = [];
+  for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
+    const fileName = normalizedFile.split("/").pop();
+    if (fileName === "handler.ts" || fileName === "handler.js") {
+      const absPath = path4.resolve(rootDir, normalizedFile);
+      const urlPath = filePathToUrlPath(normalizedFile);
+      const paramNames = extractParamNames(urlPath);
+      const isDynamic = paramNames.length > 0;
+      const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
+      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,
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewarePaths,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      if (exportNames.has("WS")) {
+        wsRoutes.push({
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewarePaths,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      continue;
     }
-    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))
-  );
+  return { routes, wsRoutes };
 }
-async function writeSchemaFile(outputPath, source) {
-  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
-  await fs4.writeFile(outputPath, source, "utf-8");
+
+// src/router/sortRoutes.ts
+function sortRoutes(routes) {
+  return [...routes].sort((a, b) => {
+    if (a.isDynamic !== b.isDynamic) {
+      return a.isDynamic ? 1 : -1;
+    }
+    if (a.isCatchAll !== b.isCatchAll) {
+      return a.isCatchAll ? 1 : -1;
+    }
+    const aSegments = a.urlPath.split("/").filter(Boolean).length;
+    const bSegments = b.urlPath.split("/").filter(Boolean).length;
+    if (aSegments !== bSegments) {
+      return aSegments - bSegments;
+    }
+    return a.urlPath.localeCompare(b.urlPath);
+  });
 }
 
+// src/testServer.ts
+init_generateSchemaFiles();
+
 // src/validator/validateInput.ts
+init_schemaName();
 var moduleCache = /* @__PURE__ */ new Map();
 function invalidateSchemaCache() {
   moduleCache.clear();
@@ -2353,9 +2441,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 +2491,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) {
@@ -2510,12 +2598,379 @@ function validateRouteModule(value, method, filePath) {
   }
 }
 
+// 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));
+      }
+    }
+  }
+  return candidates;
+}
+
+// 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 };
+}
+
+// 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 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 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/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);
+      })
+    );
+  }
+  return { compiledFiles: entryPoints };
+}
+
+// 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;
+  }
+}
+var compiledFiles = /* @__PURE__ */ new Set();
+function clearCompiledFiles() {
+  compiledFiles.clear();
+}
+async function ensureCompiled(sourceAbsPath, rootDir, dist) {
+  if (compiledFiles.has(sourceAbsPath)) {
+    return false;
+  }
+  if (!fs8.existsSync(sourceAbsPath)) {
+    return false;
+  }
+  const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
+  if (productPath && isProductFresh(sourceAbsPath, productPath)) {
+    compiledFiles.add(sourceAbsPath);
+    return false;
+  }
+  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 {
+    }
+  }
+}
+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);
+  }
+  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);
+}
+var devOnDemandEnabled = false;
+function isDevOnDemandEnabled() {
+  return devOnDemandEnabled;
+}
+var devDistDir;
+function getDevDist() {
+  return devDistDir;
+}
+
 // src/loader/loadRouteModule.ts
-async function loadRouteModule(filePath, method) {
+async function loadRouteModule(filePath, method, rootDir) {
   let module;
   try {
     module = await importWithCacheBust(filePath);
   } catch (err) {
+    if (isDevOnDemandEnabled() && rootDir) {
+      const dist = getDevDist();
+      if (dist) {
+        const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+        try {
+          const compiled = await ensureCompiled(sourcePath, rootDir, dist);
+          if (compiled) {
+            module = await importWithCacheBust(filePath);
+            const handler2 = resolveExport(module, method);
+            validateRouteModule(handler2, method, filePath);
+            return { handler: handler2, method };
+          }
+        } catch (compileErr) {
+          const compileReason = compileErr instanceof Error ? compileErr.message : String(compileErr);
+          throw new Error(`Failed to compile route module "${sourcePath}": ${compileReason}`, {
+            cause: compileErr
+          });
+        }
+      }
+    }
     const reason = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to load route module "${filePath}": ${reason}`, { cause: err });
   }
@@ -2565,6 +3020,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 +3084,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"];
@@ -2647,7 +3106,7 @@ function getClientIp(req) {
 
 // src/server/handleWsUpgrade.ts
 import { WebSocketServer, WebSocket } from "ws";
-import path6 from "path";
+import path10 from "path";
 
 // src/errors/formatErrorResponse.ts
 function formatErrorResponse(error) {
@@ -2744,8 +3203,25 @@ 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) {
+  let module;
+  try {
+    module = await importWithCacheBust(filePath);
+  } catch (err) {
+    if (isDevOnDemandEnabled() && rootDir) {
+      const dist = getDevDist();
+      if (dist) {
+        const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+        const compiled = await ensureCompiled(sourcePath, rootDir, dist);
+        if (compiled) {
+          module = await importWithCacheBust(filePath);
+        }
+      }
+    }
+    if (!module) {
+      throw err;
+    }
+  }
   const handler = module["WS"];
   if (typeof handler !== "function") {
     throw new Error(`WS export not found in ${filePath}`);
@@ -2820,8 +3296,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 +3319,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 +3350,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 +3395,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 +3489,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 +3569,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 fs9.mkdtemp(path12.join(os.tmpdir(), "faapi-test-schema-"));
   await generateSchemaFiles(sorted, rootDir, schemaDist);
   const { server } = createServer({
     routes: sorted,
@@ -3101,7 +3602,7 @@ async function createTestServer(options) {
       await new Promise((resolve) => {
         server.close(() => resolve());
       });
-      await fs5.rm(schemaDist, { recursive: true, force: true }).catch(() => {
+      await fs9.rm(schemaDist, { recursive: true, force: true }).catch(() => {
       });
       invalidateSchemaCache();
     }
@@ -3243,8 +3744,8 @@ async function connectWs(baseUrl, pathname, options = {}) {
 }
 
 // src/cli/createAppCore.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path14 from "path";
 import { PassThrough } from "stream";
 
 // src/router/detectRouteConflicts.ts
@@ -3301,55 +3802,30 @@ function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
 }
 
 // src/cli/generateRoutes.ts
-import fs6 from "fs";
-import path9 from "path";
+import fs10 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 +3909,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 (!fs11.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`
     );
@@ -3636,6 +4112,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 +4121,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;