@faapi/faapi 0.0.0-canary.4ab8d97 → 0.0.0-canary.a3f7014

package/dist/index.js

@@ -1,6 +1,9 @@
 // src/ast/createProgram.ts
 import ts from "typescript";
 var programCache = /* @__PURE__ */ new Map();
+function invalidateProgramCache() {
+  programCache.clear();
+}
 function createProgram(filePath) {
   const cached = programCache.get(filePath);
   if (cached) {
@@ -143,6 +146,9 @@ function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set())
   if (ts2.isTypeOperatorNode(typeNode) && typeNode.operator === ts2.SyntaxKind.KeyOfKeyword) {
     return resolveKeyOf(typeNode, checker);
   }
+  if (ts2.isTypeOperatorNode(typeNode) && typeNode.operator === ts2.SyntaxKind.ReadonlyKeyword) {
+    return resolveTypeNode(typeNode.type, checker, visited);
+  }
   if (ts2.isTypeReferenceNode(typeNode)) {
     return resolveTypeReference(typeNode, checker, visited);
   }
@@ -155,7 +161,11 @@ function resolveTypeLiteral(typeNode, checker, visited = /* @__PURE__ */ new Set
       const name = member.name.getText();
       const optional = !!member.questionToken;
       const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
-      properties.push({ name, type, optional });
+      const constraints = extractConstraintsFromJsDoc(member, name);
+      validateConstraints(constraints, type, name);
+      properties.push(
+        constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
+      );
     }
     if (ts2.isIndexSignatureDeclaration(member)) {
       const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
@@ -237,7 +247,7 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
   if (typeName === "Date") {
     return { kind: "date" };
   }
-  if (typeName === "Array" && typeNode.typeArguments?.length === 1) {
+  if ((typeName === "Array" || typeName === "ReadonlyArray") && typeNode.typeArguments?.length === 1) {
     return {
       kind: "array",
       element: resolveTypeNode(typeNode.typeArguments[0], checker, visited)
@@ -362,7 +372,12 @@ function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ ne
       const name = member.name.getText();
       const optional = !!member.questionToken;
       const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
-      propMap.set(name, { name, type, optional });
+      const constraints = extractConstraintsFromJsDoc(member, name);
+      validateConstraints(constraints, type, name);
+      propMap.set(
+        name,
+        constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
+      );
     }
     if (ts2.isIndexSignatureDeclaration(member)) {
       const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
@@ -375,6 +390,142 @@ 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 [];
+  const constraints = [];
+  for (const jsDoc of jsDocs) {
+    if (!jsDoc.tags) continue;
+    for (const tag of jsDoc.tags) {
+      const constraint = parseJsDocTag(tag, fieldName);
+      if (constraint) constraints.push(constraint);
+    }
+  }
+  return constraints;
+}
+function getTagCommentText(tag) {
+  const comment = tag.comment;
+  if (typeof comment === "string") return comment;
+  return void 0;
+}
+function parseJsDocTag(tag, fieldName) {
+  const tagName = tag.tagName.text;
+  switch (tagName) {
+    // 数值约束（带值）
+    case "max":
+    case "min": {
+      const value = parseNumberValue(tag, fieldName, tagName);
+      return { kind: tagName, value };
+    }
+    // 长度约束（带值）
+    case "maxLength":
+    case "minLength":
+    case "length": {
+      const value = parseNumberValue(tag, fieldName, tagName);
+      return { kind: tagName, value };
+    }
+    // 正则约束（带 /pattern/flags 值）
+    case "regex":
+    case "pattern": {
+      const text = getTagCommentText(tag);
+      if (!text) {
+        throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u9700\u8981 /pattern/flags \u5F62\u5F0F\u7684\u503C`);
+      }
+      const regex = parseRegexLiteral(text.trim(), fieldName);
+      return { kind: "regex", pattern: regex.pattern, flags: regex.flags };
+    }
+    // 数值约束（无值）
+    case "int":
+    case "positive":
+    case "negative":
+    case "nonnegative":
+    case "nonpositive":
+      return { kind: tagName };
+    // 字符串格式约束（无值）
+    case "email":
+    case "url":
+    case "uuid":
+      return { kind: tagName };
+    default:
+      return null;
+  }
+}
+function parseNumberValue(tag, fieldName, tagName) {
+  const text = getTagCommentText(tag);
+  if (!text) {
+    throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u9700\u8981\u4E00\u4E2A\u6570\u5B57\u503C`);
+  }
+  const trimmed = text.trim();
+  const num = Number(trimmed);
+  if (!Number.isFinite(num)) {
+    throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u7684\u503C "${trimmed}" \u4E0D\u662F\u6709\u6548\u6570\u5B57`);
+  }
+  return num;
+}
+function parseRegexLiteral(text, fieldName) {
+  const match = /^\/(.+)\/([gimsuy]*)$/.exec(text);
+  if (!match) {
+    throw new SchemaExtractionError(fieldName, `\u6B63\u5219\u503C "${text}" \u4E0D\u662F /pattern/flags \u5F62\u5F0F`);
+  }
+  const [, pattern, flags] = match;
+  if (!pattern) {
+    throw new SchemaExtractionError(fieldName, `\u6B63\u5219\u503C "${text}" \u7684 pattern \u90E8\u5206\u4E3A\u7A7A`);
+  }
+  return flags ? { pattern, flags } : { pattern };
+}
+function validateConstraints(constraints, type, fieldName) {
+  if (constraints.length === 0) return;
+  for (const constraint of constraints) {
+    const kind = constraint.kind;
+    if (NUMBER_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "number") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E number \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+    if (LENGTH_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "string" && type.kind !== "array") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E string \u6216 array \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+    if (STRING_FORMAT_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "string") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E string \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+  }
+}
 
 // src/ast/extractHandlerTypes.ts
 function extractTypeInfo(program, filePath, typeName) {
@@ -417,6 +568,45 @@ function extractTypeInfo(program, filePath, typeName) {
   });
   return result;
 }
+function extractAllTypes(program, filePath) {
+  const sourceFile = program.getSourceFile(filePath);
+  if (!sourceFile) return /* @__PURE__ */ new Map();
+  const checker = program.getTypeChecker();
+  const result = /* @__PURE__ */ new Map();
+  ts3.forEachChild(sourceFile, (node) => {
+    if (ts3.isInterfaceDeclaration(node)) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(node.name.text);
+      const runtimeType = withFileContext(
+        filePath,
+        node.name.text,
+        () => resolveInterfaceDeclaration(node, checker, visited)
+      );
+      result.set(node.name.text, {
+        name: node.name.text,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      });
+      return;
+    }
+    if (ts3.isTypeAliasDeclaration(node)) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(node.name.text);
+      const runtimeType = withFileContext(
+        filePath,
+        node.name.text,
+        () => resolveTypeNode(node.type, checker, visited)
+      );
+      result.set(node.name.text, {
+        name: node.name.text,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      });
+      return;
+    }
+  });
+  return result;
+}
 function withFileContext(filePath, typeName, fn) {
   try {
     return fn();
@@ -442,122 +632,187 @@ function getInputTypeForMethod(method) {
   }
   return "body";
 }
+function hasBody(method) {
+  const upper = method.toUpperCase();
+  return upper === "POST" || upper === "PUT" || upper === "PATCH" || upper === "DELETE";
+}
 
-// src/validator/schemaRegistry.ts
-var SchemaRegistry = class {
-  manifest = /* @__PURE__ */ new Map();
-  /**
-   * 批量加载 manifest
-   * 覆盖已有数据
-   */
-  loadManifest(manifest) {
-    this.manifest.clear();
-    for (const [filePath, fileSchemas] of manifest) {
-      const copy = /* @__PURE__ */ new Map();
-      fileSchemas.forEach((value, key) => copy.set(key, value));
-      this.manifest.set(filePath, copy);
+// 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";
+
+// src/injection/resolveInjection.ts
+import ts4 from "typescript";
+var PARAM_TYPE_MAP = {
+  query: "query",
+  body: "body",
+  headers: "headers",
+  params: "params",
+  context: "context",
+  ctx: "context",
+  // 别名
+  cookies: "cookies",
+  ip: "ip",
+  files: "files",
+  fields: "fields"
+};
+function resolveInjection(fn) {
+  const fnStr = fn.toString();
+  const params = extractParamsWithAst(fnStr);
+  return params.map((param) => {
+    const type = PARAM_TYPE_MAP[param.name] || "unknown";
+    return {
+      name: param.name,
+      type,
+      hasType: false
+      // 运行时类型已擦除
+    };
+  });
+}
+function extractParamsWithAst(fnStr) {
+  const sourceFile = ts4.createSourceFile(
+    "__faapi_injection__.ts",
+    fnStr,
+    ts4.ScriptTarget.Latest,
+    true
+  );
+  const paramNames = [];
+  function visit(node) {
+    if (ts4.isFunctionDeclaration(node) && node.parameters.length > 0) {
+      for (const param of node.parameters) {
+        extractParamName(param, paramNames);
+      }
+      return;
     }
+    if ((ts4.isArrowFunction(node) || ts4.isFunctionExpression(node)) && node.parameters.length > 0) {
+      for (const param of node.parameters) {
+        extractParamName(param, paramNames);
+      }
+      return;
+    }
+    ts4.forEachChild(node, visit);
   }
-  /**
-   * 查询单条 schema
-   * @returns SchemaEntry | null | undefined
-   *          - SchemaEntry：有类型声明
-   *          - null：无类型声明（跳过校验）
-   *          - undefined：manifest 不完整（抛错）
-   */
-  get(filePath, schemaName) {
-    const fileSchemas = this.manifest.get(filePath);
-    if (!fileSchemas) return void 0;
-    return fileSchemas.get(schemaName);
-  }
-  /**
-   * 设置单个文件的所有 schema
-   * 覆盖该文件的已有数据
-   */
-  set(filePath, schemas) {
-    const copy = /* @__PURE__ */ new Map();
-    schemas.forEach((value, key) => copy.set(key, value));
-    this.manifest.set(filePath, copy);
+  visit(sourceFile);
+  return paramNames.map((name) => ({ name }));
+}
+function extractParamName(param, names) {
+  const name = param.name;
+  if (ts4.isIdentifier(name)) {
+    names.push(name.text);
+    return;
   }
-  /**
-   * 删除单个文件（文件被删除时）
-   */
-  delete(filePath) {
-    this.manifest.delete(filePath);
+  if (ts4.isObjectBindingPattern(name)) {
+    for (const element of name.elements) {
+      if (ts4.isBindingElement(element)) {
+        const elemName = element.name;
+        if (ts4.isIdentifier(elemName)) {
+          names.push(elemName.text);
+        }
+      }
+    }
+    return;
   }
-  /**
-   * 判断文件是否已注册
-   */
-  hasFile(filePath) {
-    return this.manifest.has(filePath);
+  if (ts4.isArrayBindingPattern(name)) {
+    for (const element of name.elements) {
+      if (element && ts4.isBindingElement(element)) {
+        const elemName = element.name;
+        if (ts4.isIdentifier(elemName)) {
+          names.push(elemName.text);
+        }
+      }
+    }
+    return;
   }
-  /**
-   * 清空（测试用 / watch 全量重建前）
-   */
-  clear() {
-    this.manifest.clear();
+}
+
+// src/injection/analyzeInjection.ts
+function analyzeInjection(code, functionName) {
+  const sourceFile = ts5.createSourceFile("temp.ts", code, ts5.ScriptTarget.Latest, true);
+  const params = [];
+  ts5.forEachChild(sourceFile, (node) => {
+    if (ts5.isFunctionDeclaration(node) && node.name?.text === functionName) {
+      for (const param of node.parameters) {
+        const paramMeta = analyzeParam(param, sourceFile);
+        params.push(paramMeta);
+      }
+    }
+  });
+  return { params };
+}
+function analyzeParam(param, sourceFile) {
+  const name = param.name.getText(sourceFile);
+  const type = PARAM_TYPE_MAP[name] || "unknown";
+  const result = { name, type };
+  if (param.type) {
+    if (ts5.isTypeReferenceNode(param.type)) {
+      result.typeName = param.type.typeName.getText(sourceFile);
+    } else if (ts5.isTypeLiteralNode(param.type)) {
+      result.schema = extractSchema(param.type, sourceFile);
+    }
   }
-  /**
-   * 已注册的文件数量
-   */
-  get size() {
-    return this.manifest.size;
+  return result;
+}
+function extractSchema(typeNode, sourceFile) {
+  const schema = [];
+  for (const member of typeNode.members) {
+    if (ts5.isPropertySignature(member) && member.name && ts5.isIdentifier(member.name)) {
+      const propName = member.name.text;
+      const optional = !!member.questionToken;
+      const propType = member.type?.getText(sourceFile) || "unknown";
+      schema.push({
+        name: propName,
+        type: propType,
+        optional
+      });
+    }
   }
-};
-var schemaRegistry = new SchemaRegistry();
-
-// src/validator/schemaName.ts
-function getSchemaName(method, inputType) {
-  return `${method.toUpperCase()}${inputType.charAt(0).toUpperCase() + inputType.slice(1)}`;
+  return schema;
 }
 
-// src/validator/getSchemaProperties.ts
-function getSchemaProperties(filePath, method, inputType) {
-  const schemaName = getSchemaName(method, inputType);
-  const entry = schemaRegistry.get(filePath, schemaName);
-  if (entry === void 0) return void 0;
-  if (entry === null) {
-    return { schemaName: null, properties: [] };
+// src/cli/collectRouteSchemaSources.ts
+import path from "path";
+function collectRouteSchemaSources(routes, rootDir) {
+  const methodsByFile = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const filePath = rootDir ? path.resolve(rootDir, route.filePath) : route.filePath;
+    let entry = methodsByFile.get(filePath);
+    if (!entry) {
+      entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
+      methodsByFile.set(filePath, entry);
+    }
+    entry.methods.add(route.method);
   }
-  return {
-    schemaName,
-    properties: entry.properties.map((prop) => ({
-      name: prop.name,
-      type: runtimeTypeToString(prop.type),
-      required: !prop.optional
-    }))
-  };
-}
-function runtimeTypeToString(type) {
-  switch (type.kind) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "null":
-    case "undefined":
-    case "date":
-      return type.kind;
-    case "literal":
-      return JSON.stringify(type.value);
-    case "array":
-      return `${runtimeTypeToString(type.element)}[]`;
-    case "tuple":
-      return `[${type.elements.map((e) => (e.rest ? "..." : "") + runtimeTypeToString(e.type) + (e.optional ? "?" : "")).join(", ")}]`;
-    case "object":
-      return "object";
-    case "union":
-      return type.members.map(runtimeTypeToString).join(" | ");
-    case "record":
-      return `Record<${runtimeTypeToString(type.key)}, ${runtimeTypeToString(type.value)}>`;
-    case "ref":
-      return type.name;
-    case "any":
-    case "unknown":
-      return "unknown";
-    default:
-      return "unknown";
+  const programByFile = /* @__PURE__ */ new Map();
+  const allTypesByFile = /* @__PURE__ */ new Map();
+  const mergedAllTypes = /* @__PURE__ */ new Map();
+  for (const filePath of methodsByFile.keys()) {
+    const program = createProgram(filePath);
+    programByFile.set(filePath, program);
+    const allTypes = extractAllTypes(program, filePath);
+    allTypesByFile.set(filePath, allTypes);
+    for (const [name, info] of allTypes) {
+      mergedAllTypes.set(name, info);
+    }
   }
+  const sources = [];
+  for (const [filePath, entry] of methodsByFile) {
+    const program = programByFile.get(filePath);
+    const sourceFile = program.getSourceFile(filePath);
+    const code = sourceFile?.text ?? "";
+    for (const method of entry.methods) {
+      const inputType = getInputTypeForMethod(method);
+      const schemaName = getSchemaName(method, inputType);
+      const meta = analyzeInjection(code, method);
+      const param = meta.params.find((p) => p.type === inputType);
+      const typeInfo = param?.typeName ? extractTypeInfo(program, filePath, param.typeName) : null;
+      sources.push({ urlPath: entry.urlPath, filePath, schemaName, typeInfo });
+    }
+  }
+  return { sources, allTypesByFile, mergedAllTypes };
 }
 
 // src/middleware/cors.ts
@@ -633,97 +888,2444 @@ function logger(options = {}) {
     try {
       const response = await next();
       const duration = Date.now() - start;
-      log(`${ctx.method} ${ctx.path} ${response.status} ${duration}ms`);
+      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;
-      log(`${ctx.method} ${ctx.path} ${status} ${duration}ms - ${message}`);
+      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 path from "path";
+import path2 from "path";
 import fs from "fs";
+
+// src/utils/importWithCacheBust.ts
 import { pathToFileURL } from "url";
-var BASE_CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
-function getEnv() {
-  return process.env.NODE_ENV || process.env.FAAPI_ENV || "development";
-}
-function deepMerge(base, override) {
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    const baseVal = base[key];
-    const overVal = override[key];
-    if (baseVal instanceof Date || overVal instanceof Date || baseVal instanceof RegExp || overVal instanceof RegExp || baseVal instanceof Map || overVal instanceof Map || baseVal instanceof Set || overVal instanceof Set) {
-      result[key] = overVal;
-      continue;
+var loadTs;
+function setLoadTimestamp(ts6) {
+  loadTs = ts6;
+}
+async function importWithCacheBust(filePath) {
+  let url = pathToFileURL(filePath).href;
+  if (loadTs !== void 0) {
+    url += `?t=${loadTs}`;
+  }
+  return await import(url);
+}
+
+// src/config/loadConfig.ts
+var CONFIG_PRODUCT_FILE = "faapi-config.js";
+async function loadConfig(rootDir, outDir) {
+  const configProductPath = path2.resolve(rootDir, outDir, 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] ${outDir}/${CONFIG_PRODUCT_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
+    );
+  }
+  return null;
+}
+
+// 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;
+}
+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(path9) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path9}`, 404);
+    this.name = "RouteNotFoundError";
+  }
+};
+var MethodNotAllowedError = class extends FaapiError {
+  constructor(method, path9, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path9}`, 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/cli/createAppCore.ts
+import fs4 from "fs";
+import path7 from "path";
+import { PassThrough } from "stream";
+
+// src/router/sortRoutes.ts
+function sortRoutes(routes) {
+  return [...routes].sort((a, b) => {
+    if (a.isDynamic !== b.isDynamic) {
+      return a.isDynamic ? 1 : -1;
     }
-    if (baseVal !== null && overVal !== null && typeof baseVal === "object" && typeof overVal === "object" && !Array.isArray(baseVal) && !Array.isArray(overVal) && !(baseVal instanceof Function) && !(overVal instanceof Function)) {
-      result[key] = deepMerge(
-        baseVal,
-        overVal
-      );
+    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/router/detectRouteConflicts.ts
+function detectRouteConflicts(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method} ${route.urlPath}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.files.push(route.filePath);
     } else {
-      result[key] = overVal;
+      map.set(key, {
+        method: route.method,
+        urlPath: route.urlPath,
+        files: [route.filePath]
+      });
     }
   }
-  return result;
+  const conflicts = [];
+  for (const conflict of map.values()) {
+    if (conflict.files.length > 1) {
+      conflicts.push(conflict);
+    }
+  }
+  return conflicts;
 }
-async function loadConfigFile(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return null;
+
+// src/server/createServer.ts
+import {
+  createServer as createHttpServer
+} from "http";
+import { createSecureServer as createHttp2SecureServer } from "http2";
+import { readFileSync } from "fs";
+import { Readable as Readable2 } from "stream";
+import path5 from "path";
+
+// src/router/matchRoute.ts
+function matchRoute(routes, method, path9) {
+  for (const route of routes) {
+    if (route.method !== method) {
+      continue;
+    }
+    if (!route.isDynamic) {
+      if (route.urlPath === path9) {
+        return { route, params: {} };
+      }
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path9, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
   }
-  try {
-    const url = pathToFileURL(filePath).href;
-    const module = await import(url);
-    return module.default ?? {};
-  } catch (err) {
-    throw new Error(
-      `Failed to load config file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
-      { cause: err }
-    );
+  return null;
+}
+function matchWsRoute(wsRoutes, path9) {
+  for (const route of wsRoutes) {
+    if (!route.isDynamic) {
+      if (route.urlPath === path9) {
+        return { route, params: {} };
+      }
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path9, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
   }
+  return null;
 }
-async function loadConfig(rootDir, configPath) {
-  if (configPath) {
-    const resolvedPath = path.resolve(rootDir, configPath);
-    if (!fs.existsSync(resolvedPath)) {
-      throw new Error(`Config file not found: ${configPath}`);
+function matchDynamicPath(pattern, path9, paramNames, isCatchAll) {
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = path9.split("/").filter(Boolean);
+  if (isCatchAll) {
+    const nonCatchAllCount = patternSegments.length - 1;
+    if (pathSegments.length <= nonCatchAllCount) {
+      return null;
+    }
+    const params2 = {};
+    for (let i = 0; i < nonCatchAllCount; i++) {
+      const patternSeg = patternSegments[i];
+      const pathSeg = pathSegments[i];
+      if (patternSeg.startsWith(":")) {
+        const paramName = patternSeg.slice(1);
+        params2[paramName] = pathSeg;
+      } else if (patternSeg !== pathSeg) {
+        return null;
+      }
+    }
+    const catchAllValue = pathSegments.slice(nonCatchAllCount).join("/");
+    const catchAllParamName = patternSegments[nonCatchAllCount].slice(4);
+    params2[catchAllParamName] = catchAllValue;
+    if (Object.keys(params2).length !== paramNames.length) {
+      return null;
     }
-    return loadConfigFile(resolvedPath);
+    return params2;
   }
-  let baseConfig = null;
-  for (const fileName of BASE_CONFIG_FILES) {
-    const filePath = path.join(rootDir, fileName);
-    baseConfig = await loadConfigFile(filePath);
-    if (baseConfig) break;
+  if (patternSegments.length !== pathSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSeg = patternSegments[i];
+    const pathSeg = pathSegments[i];
+    if (patternSeg.startsWith(":")) {
+      const paramName = patternSeg.slice(1);
+      params[paramName] = pathSeg;
+    } else if (patternSeg !== pathSeg) {
+      return null;
+    }
   }
-  if (!baseConfig) {
+  if (Object.keys(params).length !== paramNames.length) {
     return null;
   }
-  const env = getEnv();
-  const envFiles = [`faapi.config.${env}.ts`, `faapi.config.${env}.js`];
-  for (const envFile of envFiles) {
-    const envConfig = await loadConfigFile(path.join(rootDir, envFile));
-    if (envConfig) {
-      baseConfig = deepMerge(baseConfig, envConfig);
-      break;
+  return params;
+}
+
+// src/loader/resolveExports.ts
+function resolveExport(module, exportName) {
+  if (exportName in module && typeof module[exportName] !== "undefined") {
+    return module[exportName];
+  }
+  const defaultExport = module.default;
+  if (defaultExport !== null && typeof defaultExport === "object") {
+    const value = defaultExport[exportName];
+    if (value !== void 0) {
+      return value;
     }
   }
-  return baseConfig;
+  return void 0;
+}
+
+// src/loader/validateRouteModule.ts
+function validateRouteModule(value, method, filePath) {
+  if (typeof value !== "function") {
+    throw new Error(
+      `Route module "${filePath}" does not export a valid handler for method "${method}". Expected a function, got ${typeof value}.`
+    );
+  }
+}
+
+// src/loader/loadRouteModule.ts
+async function loadRouteModule(filePath, method) {
+  let module;
+  try {
+    module = await importWithCacheBust(filePath);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load route module "${filePath}": ${reason}`, { cause: err });
+  }
+  const handler = resolveExport(module, method);
+  validateRouteModule(handler, method, filePath);
+  return { handler, method };
+}
+
+// src/runtime/sse.ts
+function encodeSseEvent(event) {
+  let out = "";
+  if (event.comment !== void 0) {
+    out += `: ${event.comment}
+`;
+  }
+  if (event.event !== void 0) {
+    out += `event: ${event.event}
+`;
+  }
+  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);
+    }
+    const lines = dataStr.split("\n");
+    for (const line of lines) {
+      out += `data: ${line}
+`;
+    }
+  }
+  out += "\n";
+  return out;
+}
+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));
+    },
+    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;
+}
+
+// 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 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,
+    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;
+    }
+  };
+  const extend = config?.extendContext;
+  if (typeof extend === "function") {
+    extend(ctx);
+  }
+  return ctx;
+}
+
+// src/utils/queryToObject.ts
+function queryToObject(params) {
+  const result = {};
+  for (const [key, value] of params) {
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/utils/parseJsonBody.ts
+function parseJsonBody(text) {
+  try {
+    const data = JSON.parse(text);
+    return { success: true, data };
+  } catch {
+    return { success: false, error: "Invalid JSON body" };
+  }
+}
+
+// src/utils/parseMultipart.ts
+async function parseMultipart(request) {
+  const formData = await request.formData();
+  const fields = {};
+  const files = [];
+  for (const [key, value] of formData.entries()) {
+    if (value instanceof File) {
+      files.push({
+        name: key,
+        filename: value.name,
+        type: value.type,
+        size: value.size,
+        arrayBuffer: () => value.arrayBuffer()
+      });
+    } else {
+      if (key in fields) {
+        const existing = fields[key];
+        if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          fields[key] = [existing, value];
+        }
+      } else {
+        fields[key] = value;
+      }
+    }
+  }
+  return { fields, files };
+}
+
+// src/runtime/resolveInput.ts
+async function resolveInput(method, request) {
+  const inputType = getInputTypeForMethod(method);
+  if (inputType === "body") {
+    const contentType = request.headers.get("content-type") ?? "";
+    if (contentType.includes("multipart/form-data")) {
+      return parseMultipart(request);
+    }
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      const text2 = await request.text();
+      if (text2.trim() === "") return null;
+      const params = new URLSearchParams(text2);
+      const obj = {};
+      for (const [key, value] of params) {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    const text = await request.text();
+    if (text.trim() === "") {
+      return null;
+    }
+    const result = parseJsonBody(text);
+    if (!result.success) {
+      throw new ValidationError("\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON", [
+        {
+          path: "body",
+          code: "INVALID_FORMAT",
+          expected: "JSON",
+          received: "text",
+          message: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON"
+        }
+      ]);
+    }
+    return result.data;
+  }
+  const url = new URL(request.url);
+  return queryToObject(url.searchParams);
+}
+
+// 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/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);
+    }
+    for (const cookie of meta.setCookies ?? []) {
+      headers2.append("set-cookie", cookie);
+    }
+  };
+  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 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 (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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
+  });
+}
+
+// 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 "body":
+      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;
+  }
+}
+async function injectParamsAsync(handler, ctx, body, injectors) {
+  const injections = resolveInjection(handler);
+  if (injections.length === 0) {
+    return await handler();
+  }
+  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);
+}
+
+// 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);
+  }
+  for (const cookie of meta.setCookies) {
+    headers.append("set-cookie", cookie);
+  }
+  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");
+  }
+  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 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);
+}
+
+// src/response/sendNodeResponse.ts
+import { Readable } from "stream";
+async function sendNodeResponse(response, res) {
+  res.statusCode = response.status;
+  for (const [key, value] of response.headers) {
+    if (key.toLowerCase() === "set-cookie") {
+      res.appendHeader(key, value);
+    } else {
+      res.setHeader(key, value);
+    }
+  }
+  if (response.body) {
+    const nodeStream = Readable.fromWeb(response.body);
+    await new Promise((resolve, reject) => {
+      nodeStream.on("error", reject);
+      res.on("error", reject);
+      res.on("finish", resolve);
+      nodeStream.pipe(res);
+    });
+    return;
+  }
+  res.end();
+}
+
+// src/validator/validateInput.ts
+var moduleCache = /* @__PURE__ */ new Map();
+function invalidateSchemaCache() {
+  moduleCache.clear();
+}
+async function loadSchemaModule(schemaPath) {
+  let mod = moduleCache.get(schemaPath);
+  if (!mod) {
+    mod = await importWithCacheBust(schemaPath);
+    moduleCache.set(schemaPath, mod);
+  }
+  return mod;
+}
+async function validateInput(schemaPath, method, inputType, input) {
+  const schemaName = getSchemaName(method, inputType);
+  const schemaKey = `${schemaName}Schema`;
+  let mod;
+  try {
+    mod = await loadSchemaModule(schemaPath);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new InternalError(`Schema \u6A21\u5757\u52A0\u8F7D\u5931\u8D25: ${schemaPath}: ${reason}`);
+  }
+  const schema = mod[schemaKey];
+  if (schema === void 0 || schema === null) {
+    const data = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+    return { valid: true, issues: [], data };
+  }
+  if (typeof schema !== "object" || typeof schema.safeParse !== "function") {
+    throw new InternalError(`Schema \u4E0D\u662F\u6709\u6548\u7684 zod schema: ${schemaPath}#${schemaName}`);
+  }
+  const inputObj = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+  const zodSchema = schema;
+  const result = zodSchema.safeParse(inputObj);
+  if (result.success) {
+    const data = typeof result.data === "object" && result.data !== null && !Array.isArray(result.data) ? result.data : {};
+    return { valid: true, issues: [], data };
+  }
+  const issues = mapZodIssues(result.error);
+  return { valid: false, issues, data: inputObj };
+}
+function mapZodIssues(error) {
+  return error.issues.map((issue) => {
+    const code = mapZodCode(issue.code, issue.message);
+    const path9 = issue.path.map(String).join(".") || "";
+    return {
+      path: path9,
+      code,
+      expected: issue.expected ?? mapExpectedFromMessage(issue.message),
+      received: issue.received ?? mapReceivedFromMessage(issue.message),
+      message: issue.message
+    };
+  });
+}
+function mapZodCode(zodCode, message) {
+  switch (zodCode) {
+    case "invalid_type":
+    case "invalid_union":
+    case "invalid_union_discriminator":
+      return "TYPE_MISMATCH";
+    case "unrecognized_keys":
+      return "INVALID_FORMAT";
+    case "invalid_value":
+    case "invalid_string":
+    case "too_small":
+    case "too_big":
+    case "invalid_intersection_types":
+    case "not_multiple_of":
+      return "INVALID_VALUE";
+    case "custom":
+      return "INVALID_VALUE";
+    default:
+      if (message.includes("Required") || message.includes("required")) {
+        return "MISSING_FIELD";
+      }
+      return "INVALID_VALUE";
+  }
+}
+function mapExpectedFromMessage(message) {
+  const match = message.match(/Expected\s+(\w+)/i);
+  return match ? match[1].toLowerCase() : "unknown";
+}
+function mapReceivedFromMessage(message) {
+  const match = message.match(/received\s+(\w+)/i);
+  return match ? match[1].toLowerCase() : "unknown";
+}
+
+// src/utils/getClientIp.ts
+function getClientIp(req) {
+  const xff = req.headers["x-forwarded-for"];
+  if (typeof xff === "string" && xff.length > 0) {
+    const first = xff.split(",")[0]?.trim();
+    if (first) return first;
+  }
+  const remote = req.socket?.remoteAddress;
+  if (remote) {
+    if (remote.startsWith("::ffff:")) {
+      return remote.slice(7);
+    }
+    return remote;
+  }
+  return "";
+}
+
+// src/server/handleWsUpgrade.ts
+import { WebSocketServer, WebSocket } from "ws";
+import path3 from "path";
+
+// src/errors/formatErrorResponse.ts
+function formatErrorResponse(error) {
+  if (error instanceof ValidationError) {
+    const body2 = {
+      code: error.code,
+      message: error.message,
+      issues: error.issues
+    };
+    return new Response(JSON.stringify({ error: body2 }), {
+      status: error.statusCode,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  if (error instanceof MethodNotAllowedError) {
+    const body2 = {
+      code: error.code,
+      message: error.message
+    };
+    return new Response(JSON.stringify({ error: body2 }), {
+      status: error.statusCode,
+      headers: {
+        "Content-Type": "application/json",
+        Allow: error.allowedMethods.join(", ")
+      }
+    });
+  }
+  if (error instanceof FaapiError) {
+    const body2 = {
+      code: error.code,
+      message: error.message
+    };
+    return new Response(JSON.stringify({ error: body2 }), {
+      status: error.statusCode,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const body = {
+    code: "INTERNAL_ERROR",
+    message: error instanceof Error ? error.message : "An unknown error occurred"
+  };
+  return new Response(JSON.stringify({ error: body }), {
+    status: 500,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+// src/server/serverUtils.ts
+function nodeHttpToWebHeaders(req) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, v);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+function buildErrorResponse(err) {
+  try {
+    return formatErrorResponse(err);
+  } catch {
+    return new Response(
+      JSON.stringify({ error: { code: "INTERNAL_ERROR", message: "Internal Server Error" } }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+
+// src/runtime/wsHandler.ts
+function wrapWsSocket(rawSocket) {
+  return {
+    send(data) {
+      const payload = typeof data === "string" || Buffer.isBuffer(data) ? data : JSON.stringify(data);
+      rawSocket.send(payload);
+    },
+    close(code, reason) {
+      rawSocket.close(code, reason);
+    },
+    get readyState() {
+      return rawSocket.readyState;
+    }
+  };
+}
+
+// src/server/handleWsUpgrade.ts
+function getPathname(req) {
+  const url = req.url ?? "/";
+  const idx = url.indexOf("?");
+  return idx >= 0 ? url.slice(0, idx) : url;
+}
+async function loadWsHandler(filePath, ctx) {
+  const module = await importWithCacheBust(filePath);
+  const handler = module["WS"];
+  if (typeof handler !== "function") {
+    throw new Error(`WS export not found in ${filePath}`);
+  }
+  return handler(ctx);
+}
+function bindEvents(rawSocket, handlers) {
+  if (!handlers) return;
+  const ws = wrapWsSocket(rawSocket);
+  if (handlers.onOpen) {
+    if (rawSocket.readyState === WebSocket.OPEN) {
+      handlers.onOpen(ws);
+    } else {
+      rawSocket.once("open", () => handlers.onOpen(ws));
+    }
+  }
+  if (handlers.onMessage) {
+    rawSocket.on("message", (data) => {
+      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      handlers.onMessage(ws, buf.toString("utf8"));
+    });
+  }
+  if (handlers.onClose) {
+    rawSocket.on("close", (code, reason) => {
+      handlers.onClose(ws, code, reason.toString("utf8"));
+    });
+  }
+  if (handlers.onError) {
+    rawSocket.on("error", (err) => {
+      handlers.onError(ws, err);
+    });
+  }
+}
+async function sendResponseToSocket(socket, response) {
+  const body = await response.text().catch(() => "");
+  const statusLine = `HTTP/1.1 ${response.status} ${response.statusText || ""}\r
+`;
+  const headerLines = [];
+  let hasContentLength = false;
+  for (const [key, value] of response.headers) {
+    if (key.toLowerCase() === "content-length") {
+      hasContentLength = true;
+    }
+    headerLines.push(`${key}: ${value}`);
+  }
+  if (!hasContentLength) {
+    headerLines.push(`Content-Length: ${Buffer.byteLength(body)}`);
+  }
+  socket.write(statusLine + headerLines.join("\r\n") + "\r\n\r\n" + body);
+  socket.destroy();
+}
+function attachWebSocket(options) {
+  const { server, routesRef, rootDir, config, globalMiddlewares } = options;
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", async (req, socket, head) => {
+    const currentWsRoutes = routesRef.wsCurrent;
+    const pathname = getPathname(req);
+    const match = matchWsRoute(currentWsRoutes, pathname);
+    if (!match) {
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const { route, params } = match;
+    const headers = nodeHttpToWebHeaders(req);
+    const host = req.headers.host ?? "localhost";
+    const url = `http://${host}${req.url ?? "/"}`;
+    const request = new Request(url, { method: "GET", headers });
+    const ctx = createContext(request, params, config, getClientIp(req));
+    const meta = ctx.meta;
+    let upgraded = false;
+    const finalHandler = async () => {
+      let handlers;
+      try {
+        const absoluteFilePath = path3.resolve(rootDir, route.filePath);
+        handlers = await loadWsHandler(absoluteFilePath, ctx);
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        console.error(`[faapi] WS handler \u52A0\u8F7D\u5931\u8D25 ${route.filePath}: ${reason}`);
+        return new Response("Internal Server Error", { status: 500 });
+      }
+      await new Promise((resolve, reject) => {
+        wss.handleUpgrade(req, socket, head, (rawSocket) => {
+          try {
+            bindEvents(rawSocket, handlers);
+            wss.emit("connection", rawSocket, req);
+            upgraded = true;
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        });
+      });
+      return new Response(null, { status: 200 });
+    };
+    let response;
+    try {
+      const dirMiddlewares = route.middlewares ?? [];
+      const allMiddlewares = globalMiddlewares && globalMiddlewares.length > 0 ? [...globalMiddlewares, ...dirMiddlewares] : dirMiddlewares;
+      if (allMiddlewares.length > 0) {
+        response = await compose(allMiddlewares, ctx, finalHandler);
+      } else {
+        response = await finalHandler();
+      }
+    } catch (err) {
+      if (upgraded) {
+        console.error("[faapi] WS \u63E1\u624B\u540E\u4E2D\u95F4\u4EF6\u629B\u9519:", err);
+        return;
+      }
+      response = buildErrorResponse(err);
+    }
+    if (upgraded) {
+      return;
+    }
+    await sendResponseToSocket(socket, mergeMeta(response, meta));
+  });
+  return wss;
+}
+
+// src/cli/generateSchemaFiles.ts
+import path4 from "path";
+import fs2 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;
+  }
+};
+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 "ref": {
+      if (ctx.namedTypes.has(type.name)) return;
+      ctx.namedTypes.set(type.name, { kind: "any" });
+      const resolved = ctx.resolveType(type.name);
+      if (resolved) {
+        ctx.namedTypes.set(type.name, resolved);
+        collectNamedTypes(resolved, ctx);
+      }
+      return;
+    }
+  }
+}
+function runtimeTypeToZodExpression(type, ctx, constraints) {
+  const expr = baseExpression(type, ctx);
+  const withConstraints = constraints && constraints.length > 0 ? applyConstraints(expr, constraints, type.kind) : expr;
+  if (ctx.coerce && (type.kind === "number" || type.kind === "boolean")) {
+    return wrapCoercePreprocess(type.kind, withConstraints);
+  }
+  return withConstraints;
+}
+function applyConstraints(baseExpr, constraints, typeKind) {
+  const suffix = constraints.map((c) => constraintToZodChain(c, typeKind)).join("");
+  return `${baseExpr}${suffix}`;
+}
+function constraintToZodChain(constraint, _typeKind) {
+  switch (constraint.kind) {
+    case "max":
+      return `.max(${constraint.value})`;
+    case "min":
+      return `.min(${constraint.value})`;
+    case "int":
+      return ".int()";
+    case "positive":
+      return ".positive()";
+    case "negative":
+      return ".negative()";
+    case "nonnegative":
+      return ".nonnegative()";
+    case "nonpositive":
+      return ".nonpositive()";
+    case "maxLength":
+      return `.max(${constraint.value})`;
+    case "minLength":
+      return `.min(${constraint.value})`;
+    case "length":
+      return `.length(${constraint.value})`;
+    case "regex": {
+      const flags = constraint.flags ?? "";
+      return `.regex(new RegExp(${JSON.stringify(constraint.pattern)}${flags ? `, ${JSON.stringify(flags)}` : ""}))`;
+    }
+    case "email":
+      return ".email()";
+    case "url":
+      return ".url()";
+    case "uuid":
+      return ".uuid()";
+  }
+}
+function baseExpression(type, ctx) {
+  switch (type.kind) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "bigint":
+      return "z.never()";
+    case "null":
+      return "z.null()";
+    case "undefined":
+      return "z.undefined()";
+    case "any":
+    case "unknown":
+      return "z.unknown()";
+    case "literal":
+      return `z.literal(${JSON.stringify(type.value)})`;
+    case "array":
+      return `z.array(${runtimeTypeToZodExpression(type.element, ctx)})`;
+    case "tuple":
+      return generateTupleExpression(type.elements, ctx);
+    case "object":
+      return generateObjectExpression(type.properties, ctx);
+    case "union":
+      return generateUnionExpression(type.members, ctx);
+    case "date":
+      return 'z.preprocess((v) => (typeof v === "string" ? new Date(v) : v), z.date())';
+    case "record":
+      return `z.record(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)})`;
+    case "ref":
+      if (type.name === ctx.entryTypeName) {
+        return `${ctx.entryExportName}Schema`;
+      }
+      return `${type.name}Schema`;
+  }
+}
+var COERCE_NUMBER_HELPER = 'export const coerceNumber = (v) => typeof v === "string" && v.trim() !== "" && !isNaN(Number(v)) ? Number(v) : v;';
+var COERCE_BOOLEAN_HELPER = 'export const coerceBoolean = (v) => v === "true" || v === "1" ? true : v === "false" || v === "0" ? false : v;';
+var 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,
+    ""
+  ].join("\n");
+}
+function usesCoerceHelpers(code) {
+  return code.includes("coerceNumber") || code.includes("coerceBoolean");
+}
+function wrapCoercePreprocess(kind, inner) {
+  if (kind === "number") {
+    return `z.preprocess(coerceNumber, ${inner})`;
+  }
+  return `z.preprocess(coerceBoolean, ${inner})`;
+}
+function generateTupleExpression(elements, ctx) {
+  const fixedExprs = [];
+  const fixedOptional = [];
+  let restExpression = "";
+  let restStarted = false;
+  for (const el of elements) {
+    if (el.rest) {
+      restExpression = runtimeTypeToZodExpression(el.type, ctx);
+      restStarted = true;
+    } else if (!restStarted) {
+      fixedExprs.push(runtimeTypeToZodExpression(el.type, ctx));
+      fixedOptional.push(el.optional);
+    }
+  }
+  if (restExpression) {
+    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
+  }
+  const hasOptional = fixedOptional.some((o) => o);
+  if (!hasOptional) {
+    return `z.tuple([${fixedExprs.join(", ")}])`;
+  }
+  const variants = [];
+  for (let len = fixedExprs.length; len >= 0; len--) {
+    const removed = fixedOptional.slice(len);
+    if (removed.length > 0 && removed.some((o) => !o)) {
+      break;
+    }
+    const subset = fixedExprs.slice(0, len);
+    variants.push(`z.tuple([${subset.join(", ")}])`);
+  }
+  variants.reverse();
+  if (variants.length === 1) {
+    return variants[0];
+  }
+  return `z.union([${variants.join(", ")}])`;
+}
+function generateObjectExpression(properties, ctx) {
+  const fields = properties.map((prop) => {
+    const expr = runtimeTypeToZodExpression(prop.type, ctx, prop.constraints);
+    const finalExpr = prop.optional ? `${expr}.optional()` : expr;
+    return `${JSON.stringify(prop.name)}: ${finalExpr}`;
+  });
+  return `z.object({ ${fields.join(", ")} })`;
+}
+function generateUnionExpression(members, ctx) {
+  const hasNull = members.some((m) => m.kind === "null");
+  const nonNull = members.filter((m) => m.kind !== "null");
+  if (hasNull && nonNull.length === 1) {
+    return `${runtimeTypeToZodExpression(nonNull[0], ctx)}.nullable()`;
+  }
+  if (hasNull) {
+    const unionInner2 = nonNull.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
+    return `z.union([${unionInner2}]).nullable()`;
+  }
+  const unionInner = members.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
+  return `z.union([${unionInner}])`;
+}
+function generateNamedTypeDeclaration(name, type, ctx) {
+  const expr = runtimeTypeToZodExpression(type, ctx);
+  const hasRef = containsRef(type, /* @__PURE__ */ new Set([name]));
+  if (hasRef) {
+    return `const ${name}Schema = z.lazy(() => ${expr});`;
+  }
+  return `const ${name}Schema = ${expr};`;
+}
+function containsRef(type, visited) {
+  switch (type.kind) {
+    case "ref":
+      return visited.has(type.name);
+    case "array":
+      return containsRef(type.element, visited);
+    case "tuple":
+      return type.elements.some((el) => containsRef(el.type, visited));
+    case "object":
+      return type.properties.some((prop) => containsRef(prop.type, visited));
+    case "union":
+      return type.members.some((m) => containsRef(m, visited));
+    case "record":
+      return containsRef(type.key, visited) || containsRef(type.value, visited);
+    default:
+      return false;
+  }
+}
+function generateZodSchemaSource(typeInfo, resolveType, exportName, coerce = false) {
+  const ctx = new CodeGenContext(resolveType);
+  const name = exportName ?? typeInfo.name;
+  ctx.entryTypeName = typeInfo.name;
+  ctx.entryExportName = name;
+  ctx.coerce = coerce;
+  collectNamedTypes(typeInfo.runtimeType, ctx);
+  ctx.namedTypes.delete(typeInfo.name);
+  const lines = [];
+  lines.push("import { z } from 'zod';");
+  lines.push("");
+  for (const [n, type] of ctx.namedTypes) {
+    lines.push(generateNamedTypeDeclaration(n, type, ctx));
+  }
+  if (ctx.namedTypes.size > 0) lines.push("");
+  const entryExpr = runtimeTypeToZodExpression(typeInfo.runtimeType, ctx);
+  const hasSelfRef = containsRef(typeInfo.runtimeType, /* @__PURE__ */ new Set([typeInfo.name]));
+  if (hasSelfRef) {
+    lines.push(`export const ${name}Schema = z.lazy(() => ${entryExpr});`);
+  } else {
+    lines.push(`export const ${name}Schema = ${entryExpr};`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/generateSchemaFiles.ts
+function getSchemaOutputPath(sourceFile, appDir, outDir, rootDir) {
+  let rel = sourceFile.replace(/\\/g, "/");
+  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
+    rel = rel.slice(appDir.length + 1);
+  }
+  const idx = rel.lastIndexOf("/");
+  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
+  return path4.resolve(rootDir, outDir, relDir, "zod.js");
+}
+function getRuntimeSchemaPath(filePath, appDir, outDir, rootDir) {
+  let rel = filePath.replace(/\\/g, "/");
+  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
+    rel = rel.slice(appDir.length + 1);
+  } else if (rel.startsWith(`${outDir}/`)) {
+    rel = rel.slice(outDir.length + 1);
+  }
+  const idx = rel.lastIndexOf("/");
+  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
+  return path4.resolve(rootDir, outDir, 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 = /(?:Query|Params)$/.test(schemaName);
+    const block = [`// ${schemaName}`];
+    const schemaCode = generateZodSchemaSource(typeInfo, resolveType, schemaName, coerce).replace(
+      /^import \{ z \} from 'zod';\s*\n\s*\n/,
+      ""
+    );
+    block.push(schemaCode);
+    block.push("");
+    schemaBlocks.push(block.join("\n"));
+  }
+  const allSchemaCode = schemaBlocks.join("\n");
+  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
+    lines.push(`import { coerceNumber, coerceBoolean } from '${helpersImportPath}';`);
+  }
+  lines.push("");
+  lines.push(...schemaBlocks);
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+async function generateSchemaFiles(routes, rootDir, appDir, outDir) {
+  if (routes.length === 0) return;
+  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
+  const sourcesByFile = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    let list = sourcesByFile.get(source.filePath);
+    if (!list) {
+      list = [];
+      sourcesByFile.set(source.filePath, list);
+    }
+    list.push(source);
+  }
+  const fileEntries = [];
+  for (const [filePath, fileSources] of sourcesByFile) {
+    const relFile = path4.relative(rootDir, filePath).replace(/\\/g, "/");
+    const outputPath = getSchemaOutputPath(relFile, appDir, outDir, rootDir);
+    const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
+    let relForDir = relFile;
+    if (appDir !== "." && relForDir.startsWith(`${appDir}/`)) {
+      relForDir = relForDir.slice(appDir.length + 1);
+    }
+    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 = path4.resolve(rootDir, outDir, HELPERS_FILENAME);
+    await writeSchemaFile(helpersPath, generateHelpersFileSource());
+  }
+  await Promise.all(
+    fileEntries.map(({ outputPath, source }) => writeSchemaFile(outputPath, source))
+  );
+}
+async function writeSchemaFile(outputPath, source) {
+  await fs2.mkdir(path4.dirname(outputPath), { recursive: true });
+  await fs2.writeFile(outputPath, source, "utf-8");
+}
+
+// src/server/createServer.ts
+var DEFAULT_BODY_LIMIT = 10 * 1024 * 1024;
+function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
+  const forwardedProto = req.headers["x-forwarded-proto"];
+  const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+  const headers = nodeHttpToWebHeaders(req);
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return new Request(url.toString(), { method, headers });
+  }
+  const stream = Readable2.toWeb(req);
+  const limitedStream = limitStreamSize(stream, bodyLimit);
+  return new Request(url.toString(), {
+    method,
+    headers,
+    body: limitedStream,
+    duplex: "half"
+  });
+}
+function limitStreamSize(stream, maxSize) {
+  let totalSize = 0;
+  const reader = stream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await reader.read();
+      if (done) {
+        controller.close();
+        reader.releaseLock();
+        return;
+      }
+      totalSize += value.byteLength;
+      if (totalSize > maxSize) {
+        controller.error(new Error(`\u8BF7\u6C42\u4F53\u8D85\u8FC7\u5927\u5C0F\u9650\u5236 ${maxSize} \u5B57\u8282`));
+        reader.releaseLock();
+        return;
+      }
+      controller.enqueue(value);
+    },
+    cancel(reason) {
+      reader.cancel(reason);
+    }
+  });
+}
+function findAllowedMethods(routes, path9) {
+  const methods = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (route.urlPath === path9) {
+      methods.add(route.method);
+      continue;
+    }
+    if (route.isDynamic) {
+      const params = matchDynamicPath(route.urlPath, path9, route.paramNames, route.isCatchAll);
+      if (params !== null) {
+        methods.add(route.method);
+      }
+    }
+  }
+  return Array.from(methods);
+}
+function createServer(options) {
+  const {
+    routes,
+    rootDir,
+    appDir,
+    outDir,
+    cors: corsOption,
+    onError,
+    config,
+    wsRoutes,
+    middlewares: globalMiddlewares,
+    injectors: globalInjectors,
+    helmet: helmetOption,
+    bodyLimit = DEFAULT_BODY_LIMIT,
+    http2: http2Option
+  } = options;
+  const routesRef = { current: routes, wsCurrent: wsRoutes ?? [] };
+  const configMiddlewares = [];
+  const corsMiddleware = corsOption === false ? null : corsOption === true || corsOption === void 0 ? cors() : cors(corsOption);
+  if (corsMiddleware) configMiddlewares.push(corsMiddleware);
+  if (helmetOption) {
+    const helmOpts = typeof helmetOption === "object" ? helmetOption : {};
+    configMiddlewares.push(helmet(helmOpts));
+  }
+  const server = (() => {
+    if (http2Option) {
+      const h2Opts = typeof http2Option === "object" ? http2Option : {};
+      return createHttp2SecureServer({
+        key: h2Opts.key ? readFileSync(h2Opts.key) : void 0,
+        cert: h2Opts.cert ? readFileSync(h2Opts.cert) : void 0,
+        allowHTTP1: true
+      });
+    }
+    return createHttpServer();
+  })();
+  server.on("request", (req, res) => {
+    const currentRoutes = routesRef.current;
+    handleRequest(
+      currentRoutes,
+      rootDir,
+      appDir,
+      outDir,
+      req,
+      res,
+      configMiddlewares,
+      onError,
+      config,
+      globalMiddlewares,
+      globalInjectors,
+      bodyLimit
+    ).catch(() => {
+      res.statusCode = 500;
+      res.end();
+    });
+  });
+  if (routesRef.wsCurrent.length > 0) {
+    attachWebSocket({ server, routesRef, rootDir, config, globalMiddlewares });
+  }
+  return { server, routesRef };
+}
+async function handleRequest(routes, rootDir, appDir, outDir, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+  const request = toWebRequest(req, bodyLimit);
+  const method = request.method.toUpperCase();
+  const urlPath = new URL(request.url).pathname;
+  const ctx = createContext(request, {}, config, getClientIp(req));
+  const meta = ctx.meta;
+  const routePipeline = async () => {
+    const match = matchRoute(routes, method, urlPath);
+    if (!match) {
+      const allowedMethods = findAllowedMethods(routes, urlPath);
+      if (allowedMethods.length > 0) {
+        throw new MethodNotAllowedError(method, urlPath, allowedMethods);
+      }
+      throw new RouteNotFoundError(urlPath);
+    }
+    ctx.params = match.params;
+    const { route } = match;
+    const absoluteFilePath = path5.resolve(rootDir, route.filePath);
+    const routeModule = await loadRouteModule(absoluteFilePath, route.method);
+    const input = await resolveInput(route.method, request);
+    const inputType = getInputTypeForMethod(route.method);
+    const schemaPath = getRuntimeSchemaPath(route.filePath, appDir, outDir, rootDir);
+    const 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;
+    const mergedInjectors = globalInjectors ? { ...globalInjectors, ...route.injectors } : route.injectors;
+    const response = await invokeHandler(
+      routeModule.handler,
+      ctx,
+      body,
+      route.middlewares,
+      mergedInjectors
+    );
+    return response;
+  };
+  try {
+    let response;
+    const outerMiddlewares = [];
+    if (configMiddlewares.length > 0) outerMiddlewares.push(...configMiddlewares);
+    if (globalMiddlewares && globalMiddlewares.length > 0) {
+      outerMiddlewares.push(...globalMiddlewares);
+    }
+    if (outerMiddlewares.length > 0) {
+      response = await compose(outerMiddlewares, ctx, routePipeline);
+    } else {
+      response = await routePipeline();
+    }
+    await sendNodeResponse(response, res);
+  } catch (err) {
+    const errorResponse = buildErrorResponse(err);
+    await sendNodeResponse(mergeMeta(errorResponse, meta), res);
+    if (onError) {
+      try {
+        await onError(err, ctx);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/server/startServer.ts
+function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
+  if (handlerWrappers.length > 0) {
+    const listeners = server.listeners("request");
+    const original = listeners[0];
+    if (original) {
+      server.removeAllListeners("request");
+      let handler = original;
+      for (const wrap of handlerWrappers) {
+        handler = wrap(handler);
+      }
+      server.on("request", handler);
+    }
+  }
+  if (upgradeWrappers.length > 0) {
+    const listeners = server.listeners("upgrade");
+    const original = listeners[0];
+    server.removeAllListeners("upgrade");
+    let upgrade = original;
+    for (const wrap of upgradeWrappers) {
+      upgrade = wrap(upgrade);
+    }
+    if (upgrade) {
+      server.on("upgrade", upgrade);
+    }
+  }
+}
+
+// src/cli/generateRoutes.ts
+import fs3 from "fs";
+import path6 from "path";
+
+// 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;
+    }
+    return { middlewares: validMiddlewares, injectors: validInjectors };
+  } catch {
+    return { middlewares: [], injectors: {} };
+  }
+}
+
+// src/cli/generateRoutes.ts
+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));
+  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) {
+  const handlerWrappers = [];
+  const upgradeWrappers = [];
+  if (!declarations || declarations.length === 0) {
+    return { handlerWrappers, upgradeWrappers };
+  }
+  const fullCtx = {
+    ...ctx,
+    wrapHandler: (fn) => {
+      handlerWrappers.push(fn);
+    },
+    wrapUpgradeHandler: (fn) => {
+      upgradeWrappers.push(fn);
+    }
+  };
+  const loaded = /* @__PURE__ */ new Set();
+  for (const decl of declarations) {
+    const { specifier, options, enable } = resolveDeclaration(decl);
+    if (enable === false) continue;
+    if (loaded.has(specifier)) {
+      console.warn(`! Plugin already loaded: ${specifier}, skipping`);
+      continue;
+    }
+    loaded.add(specifier);
+    try {
+      const mod = await import(specifier);
+      const plugin = mod.default ?? mod;
+      if (typeof plugin.setup !== "function") {
+        console.warn(`! Plugin ${specifier} has no setup function, skipping`);
+        continue;
+      }
+      await plugin.setup({ ...fullCtx, options });
+      console.log(`- Plugin loaded: ${plugin.name ?? specifier}`);
+    } catch (err) {
+      console.warn(
+        `! Failed to load plugin ${specifier}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { handlerWrappers, upgradeWrappers };
+}
+function resolveDeclaration(decl) {
+  if (typeof decl === "string") {
+    return { specifier: decl };
+  }
+  if (Array.isArray(decl)) {
+    const [specifier, options] = decl;
+    return { specifier, options };
+  }
+  if ("package" in decl) {
+    return { specifier: decl.package, options: decl.options, enable: decl.enable };
+  }
+  if ("path" in decl) {
+    return { specifier: decl.path, options: decl.options, enable: decl.enable };
+  }
+  throw new Error(`Invalid plugin declaration: ${JSON.stringify(decl)}`);
+}
+
+// src/cli/createAppCore.ts
+var DEFAULT_OUT_DIR = "dist";
+var DEFAULT_APP_DIR = "src";
+var DEFAULT_PORT = 3e3;
+var ROUTES_FILE = "faapi-routes.js";
+var FAAPI_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "cors",
+  "lifecycle",
+  "middlewares",
+  "injectors",
+  "extendContext",
+  "plugins",
+  "helmet",
+  "bodyLimit",
+  "logger",
+  "http2"
+]);
+function isFaapiConfigKey(key) {
+  return FAAPI_CONFIG_KEYS.has(key);
+}
+async function createAppBase(options) {
+  const rootDir = options?.rootDir ?? process.cwd();
+  const outDir = process.env.FAAPI_OUT_DIR ?? DEFAULT_OUT_DIR;
+  const routesPath = path7.resolve(rootDir, outDir, ROUTES_FILE);
+  if (!fs4.existsSync(routesPath)) {
+    throw new Error(
+      `[faapi] ${outDir}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
+    );
+  }
+  const config = await loadConfig(rootDir, outDir);
+  const appDir = options?.appDir ?? process.env.FAAPI_APP_DIR ?? DEFAULT_APP_DIR;
+  const patterns = appDir === "." ? ["api/**/*.ts"] : [`${appDir}/api/**/*.ts`];
+  const serialized = await importWithCacheBust(routesPath);
+  const hydrated = await hydrateRoutes(serialized);
+  let sorted = sortRoutes(hydrated.routes);
+  let wsRoutes = hydrated.wsRoutes;
+  const conflicts = detectRouteConflicts(sorted);
+  if (conflicts.length > 0) {
+    for (const conflict of conflicts) {
+      console.warn(`! \u8DEF\u7531\u51B2\u7A81: ${conflict.method} ${conflict.urlPath}`);
+      for (const file of conflict.files) {
+        console.warn(`  - ${file}`);
+      }
+    }
+  }
+  const pluginConfig = config ? Object.fromEntries(Object.entries(config).filter(([k]) => !isFaapiConfigKey(k))) : {};
+  const { server, routesRef } = createServer({
+    routes: sorted,
+    rootDir,
+    appDir,
+    outDir,
+    cors: config?.cors ?? true,
+    onError: config?.lifecycle?.onError,
+    config: config ?? void 0,
+    wsRoutes,
+    middlewares: config?.middlewares,
+    injectors: config?.injectors,
+    helmet: config?.helmet,
+    bodyLimit: config?.bodyLimit,
+    http2: config?.http2
+  });
+  const { handlerWrappers, upgradeWrappers } = await loadPlugins(config?.plugins, {
+    rootDir,
+    routes: sorted,
+    getRoutes: () => sorted,
+    server,
+    config: pluginConfig
+  });
+  applyPluginWrappers(server, handlerWrappers, upgradeWrappers);
+  let closed = false;
+  const app = {
+    server: null,
+    routes: sorted,
+    wsRoutes,
+    rootDir,
+    async listen(listenPort) {
+      const envPort = process.env.PORT ? Number(process.env.PORT) : void 0;
+      const actualPort = listenPort ?? options?.port ?? envPort ?? DEFAULT_PORT;
+      return new Promise((resolve) => {
+        server.listen(actualPort, async () => {
+          const address = server.address();
+          const p = typeof address === "object" && address !== null ? address.port : actualPort;
+          console.log("faapi server started");
+          console.log(`- Local: http://localhost:${p}`);
+          console.log("- Loaded routes:");
+          for (const route of sorted) {
+            console.log(`  ${route.method.padEnd(6)}${route.urlPath}  ${route.filePath}`);
+          }
+          if (wsRoutes.length > 0) {
+            console.log("- WebSocket routes:");
+            for (const route of wsRoutes) {
+              console.log(`  WS     ${route.urlPath}  ${route.filePath}`);
+            }
+          }
+          if (config?.lifecycle?.onClose) {
+            const graceful = async (signal) => {
+              console.log(`
+- Received ${signal}, shutting down...`);
+              await app.close();
+              process.exit(0);
+            };
+            process.on("SIGTERM", () => void graceful("SIGTERM"));
+            process.on("SIGINT", () => void graceful("SIGINT"));
+          }
+          if (config?.lifecycle?.onReady) {
+            await config.lifecycle.onReady({ rootDir, routes: sorted, server });
+            console.log("- onReady hook executed");
+          }
+          app.server = server;
+          resolve(server);
+        });
+      });
+    },
+    async inject(injectOpts) {
+      const {
+        method = "GET",
+        path: reqPath = "/",
+        headers: reqHeaders = {},
+        query,
+        body
+      } = injectOpts ?? {};
+      const queryStr = query ? "?" + new URLSearchParams(Object.entries(query).map(([k, v]) => [k, String(v)])).toString() : "";
+      return new Promise((resolve, reject) => {
+        const mockRes = {
+          statusCode: 200,
+          _headers: {},
+          _body: Buffer.alloc(0),
+          setHeader(name, value) {
+            this._headers[name.toLowerCase()] = value;
+          },
+          appendHeader(name, value) {
+            const key = name.toLowerCase();
+            const existing = this._headers[key];
+            this._headers[key] = existing ? `${existing}, ${value}` : value;
+          },
+          writeHead(status, headers) {
+            this.statusCode = status;
+            if (headers) {
+              Object.assign(this._headers, headers);
+            }
+          },
+          end(data) {
+            const buf = Buffer.isBuffer(data) ? data : Buffer.from(data ?? "");
+            this._body = buf;
+            resolve({
+              status: this.statusCode,
+              headers: new Headers(this._headers),
+              body: this.parseBody()
+            });
+          },
+          parseBody() {
+            try {
+              return JSON.parse(this._body.toString());
+            } catch {
+              return this._body.toString();
+            }
+          }
+        };
+        const listeners = server.listeners("request");
+        const handler = listeners[listeners.length - 1];
+        if (typeof handler !== "function") {
+          reject(new Error("No request handler found"));
+          return;
+        }
+        const mockReq = new PassThrough({
+          read() {
+            this.push(null);
+          }
+        });
+        mockReq.method = method;
+        mockReq.url = `${reqPath}${queryStr}`;
+        mockReq.headers = {
+          ...reqHeaders,
+          host: "localhost",
+          "content-type": body !== void 0 ? "application/json" : void 0
+        };
+        mockReq.socket = { remoteAddress: "127.0.0.1" };
+        if (body !== void 0) {
+          mockReq.push(JSON.stringify(body));
+        }
+        handler(
+          mockReq,
+          mockRes
+        );
+      });
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      const s = server;
+      if (typeof s.closeIdleConnections === "function") {
+        s.closeIdleConnections();
+      }
+      if (typeof s.closeAllConnections === "function") {
+        s.closeAllConnections();
+      }
+      if (config?.lifecycle?.onClose) {
+        await config.lifecycle.onClose({ rootDir, routes: sorted, server });
+      }
+      return new Promise((resolve) => {
+        server.close((err) => {
+          if (err) console.error("Error closing server:", err);
+          app.server = null;
+          resolve();
+        });
+      });
+    }
+  };
+  const ctx = {
+    rootDir,
+    appDir,
+    outDir,
+    patterns,
+    server,
+    routesRef,
+    config,
+    updateRoutes(newRoutes, newWsRoutes) {
+      sorted = newRoutes;
+      wsRoutes = newWsRoutes;
+      app.routes = newRoutes;
+      app.wsRoutes = newWsRoutes;
+      routesRef.current = newRoutes;
+      routesRef.wsCurrent = newWsRoutes;
+    }
+  };
+  return { app, ctx };
+}
+
+// src/router/scanRoutes.ts
+import fg from "fast-glob";
+import path8 from "path";
+import fs5 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(path9) {
+  if (!path9) return "";
+  let result = path9.replace(/\\/g, "/");
+  result = result.replace(/\/+/g, "/");
+  result = result.replace(/\/+$/, "");
+  if (result && !result.startsWith("/")) {
+    result = "/" + result;
+  }
+  return result;
+}
+
+// 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));
+    }
+  }
+  return params;
+}
+function isCatchAllSegment(segment) {
+  return /^\[\.\.\..+\]$/.test(segment);
+}
+function isRouteGroup(segment) {
+  return /^\(.+\)$/.test(segment);
+}
+function filePathToUrlPath(filePath, appDir = ".") {
+  const withoutPrefix = filePath.startsWith(appDir + "/") ? filePath.slice(appDir.length + 1) : filePath;
+  const lastSlashIndex = withoutPrefix.lastIndexOf("/");
+  const dirPath = lastSlashIndex === -1 ? "" : withoutPrefix.slice(0, lastSlashIndex);
+  if (!dirPath) {
+    return "";
+  }
+  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
+  return normalizePath(segments.join("/"));
+}
+
+// src/router/scanRoutes.ts
+function toProdAbsPath(sourceAbsPath, rootDir, appDir, prodDir) {
+  let rel = path8.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  if (appDir !== "." && rel.startsWith(`${appDir}/`)) {
+    rel = rel.slice(appDir.length + 1);
+  }
+  const prodRel = `${prodDir}/${rel.replace(/\.ts$/, ".js")}`;
+  return path8.resolve(rootDir, prodRel);
+}
+async function findMergedMiddlewares(routeFilePath, rootDir, appDir, prodDir) {
+  const routeDir = path8.dirname(routeFilePath);
+  const resolvedRoot = path8.resolve(rootDir);
+  const mwPaths = [];
+  let currentDir = path8.resolve(rootDir, routeDir);
+  while (true) {
+    if (prodDir) {
+      const mwPath = path8.join(currentDir, "middlewares.js");
+      const absMwPath = path8.resolve(rootDir, mwPath);
+      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, appDir, prodDir);
+      if (fs5.existsSync(prodAbsMwPath)) {
+        mwPaths.push(prodAbsMwPath);
+      }
+    } else {
+      for (const ext of [".ts", ".js"]) {
+        const mwPath = path8.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path8.resolve(rootDir, mwPath);
+        if (fs5.existsSync(absMwPath)) {
+          mwPaths.push(absMwPath);
+          break;
+        }
+      }
+    }
+    if (currentDir === resolvedRoot) break;
+    const parentDir = path8.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  if (mwPaths.length === 0) return void 0;
+  mwPaths.reverse();
+  const mergedMiddlewares = [];
+  const mergedInjectors = {};
+  for (const absMwPath of mwPaths) {
+    let bundle = getCachedMiddlewares(absMwPath);
+    if (bundle === void 0) {
+      bundle = await loadMiddlewaresFile(absMwPath);
+      setCachedMiddlewares(absMwPath, bundle);
+    }
+    mergedMiddlewares.push(...bundle.middlewares);
+    for (const [name, injector] of Object.entries(bundle.injectors)) {
+      mergedInjectors[name] = injector;
+    }
+  }
+  if (mergedMiddlewares.length === 0 && Object.keys(mergedInjectors).length === 0) {
+    return void 0;
+  }
+  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
+}
+async function extractMethodsFromHandler(absPath) {
+  try {
+    const module = await importWithCacheBust(absPath);
+    const methods = [];
+    for (const key of Object.keys(module)) {
+      if (isHttpMethod(key) && typeof module[key] === "function") {
+        methods.push(key);
+      }
+    }
+    return methods;
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    console.warn(`[faapi] \u52A0\u8F7D\u8DEF\u7531\u6587\u4EF6\u5931\u8D25 ${absPath}: ${reason}`);
+    return [];
+  }
+}
+async function hasWsExport(absPath) {
+  try {
+    const module = await importWithCacheBust(absPath);
+    return typeof module["WS"] === "function";
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    console.warn(`[faapi] \u52A0\u8F7D\u8DEF\u7531\u6587\u4EF6\u5931\u8D25\uFF08WS \u68C0\u6D4B\uFF09${absPath}: ${reason}`);
+    return false;
+  }
+}
+async function scanRoutes(rootDir, patterns, appDir, prodDir) {
+  const dir = appDir ?? ".";
+  const files = await fg(patterns, {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: false
+  });
+  const routes = [];
+  const wsRoutes = [];
+  for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
+    const fileName = normalizedFile.split("/").pop();
+    if (fileName === "handler.ts" || fileName === "handler.js") {
+      const absPath = path8.resolve(rootDir, normalizedFile);
+      const importPath = prodDir ? toProdAbsPath(absPath, rootDir, dir, prodDir) : absPath;
+      const urlPath = filePathToUrlPath(normalizedFile, dir);
+      const paramNames = extractParamNames(urlPath);
+      const isDynamic = paramNames.length > 0;
+      const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
+      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, dir, prodDir);
+      const methods = await extractMethodsFromHandler(importPath);
+      for (const method of methods) {
+        routes.push({
+          method,
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      const hasWs = await hasWsExport(importPath);
+      if (hasWs) {
+        wsRoutes.push({
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      continue;
+    }
+  }
+  return { routes, wsRoutes };
+}
+
+// src/cli/createDevApp.ts
+async function createDevApp(options) {
+  const { app, ctx } = await createAppBase(options);
+  const devApp = app;
+  devApp.reloadRoutes = async () => {
+    setLoadTimestamp(Date.now());
+    invalidateMiddlewareCache();
+    invalidateProgramCache();
+    invalidateSchemaCache();
+    const reScanned = await scanRoutes(ctx.rootDir, ctx.patterns, ctx.appDir, ctx.outDir);
+    const sorted = sortRoutes(reScanned.routes);
+    await generateSchemaFiles(sorted, ctx.rootDir, ctx.appDir, ctx.outDir);
+    ctx.updateRoutes(sorted, reScanned.wsRoutes);
+  };
+  return devApp;
+}
+
+// src/cli/createProdApp.ts
+async function createProdApp(options) {
+  const { app } = await createAppBase(options);
+  return app;
 }
 export {
+  FaapiError,
+  InternalError,
+  MethodNotAllowedError,
+  ModuleLoadError,
+  RouteNotFoundError,
   SchemaExtractionError,
+  ValidationError,
+  collectRouteSchemaSources,
   cors,
+  createProdApp as createApp,
+  createDevApp,
+  createProdApp,
   createProgram,
   extractTypeInfo,
   getInputTypeForMethod,
-  getSchemaProperties,
+  helmet,
+  invalidateProgramCache,
   loadConfig,
-  logger
+  logger,
+  resolveTypeNode
 };
 //# sourceMappingURL=index.js.map