@faapi/faapi 1.0.0-canary.d7438c8 → 1.0.1-canary.218585b

package/dist/index.js

@@ -1150,14 +1150,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path10) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path10}`, 404);
+  constructor(path11) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path11}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path10, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path10}`, 405);
+  constructor(method, path11, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path11}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -1634,1007 +1634,1222 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
   return await compose(middlewares, ctx, finalHandler);
 }
 
-// src/cli/createAppCore.ts
-import fs5 from "fs";
+// src/testServer.ts
 import path8 from "path";
-import { PassThrough } from "stream";
+import os from "os";
+import fs5 from "fs/promises";
 
-// src/router/sortRoutes.ts
-function sortRoutes(routes) {
-  return [...routes].sort((a, b) => {
-    if (a.isDynamic !== b.isDynamic) {
-      return a.isDynamic ? 1 : -1;
-    }
-    if (a.isCatchAll !== b.isCatchAll) {
-      return a.isCatchAll ? 1 : -1;
-    }
-    const aSegments = a.urlPath.split("/").filter(Boolean).length;
-    const bSegments = b.urlPath.split("/").filter(Boolean).length;
-    if (aSegments !== bSegments) {
-      return aSegments - bSegments;
-    }
-    return a.urlPath.localeCompare(b.urlPath);
-  });
+// src/router/scanRoutes.ts
+import fg from "fast-glob";
+import path4 from "path";
+import fs3 from "fs";
+
+// src/router/constants.ts
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var HTTP_METHOD_SET = new Set(HTTP_METHODS);
+function isHttpMethod(value) {
+  return HTTP_METHOD_SET.has(value);
 }
 
-// src/router/detectRouteConflicts.ts
-function detectRouteConflicts(routes) {
-  const map = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    const key = `${route.method} ${route.urlPath}`;
-    const existing = map.get(key);
-    if (existing) {
-      existing.files.push(route.filePath);
-    } else {
-      map.set(key, {
-        method: route.method,
-        urlPath: route.urlPath,
-        files: [route.filePath]
-      });
-    }
+// src/utils/normalizePath.ts
+function normalizePath(path11) {
+  if (!path11) return "";
+  let result = path11.replace(/\\/g, "/");
+  result = result.replace(/\/+/g, "/");
+  result = result.replace(/\/+$/, "");
+  if (result && !result.startsWith("/")) {
+    result = "/" + result;
   }
-  const conflicts = [];
-  for (const conflict of map.values()) {
-    if (conflict.files.length > 1) {
-      conflicts.push(conflict);
+  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 conflicts;
+  return params;
+}
+function isCatchAllSegment(segment) {
+  return /^\[\.\.\..+\]$/.test(segment);
+}
+function isRouteGroup(segment) {
+  return /^\(.+\)$/.test(segment);
+}
+function filePathToUrlPath(filePath) {
+  const withoutPrefix = filePath.startsWith("src/") ? filePath.slice(4) : filePath;
+  const lastSlashIndex = withoutPrefix.lastIndexOf("/");
+  const dirPath = lastSlashIndex === -1 ? "" : withoutPrefix.slice(0, lastSlashIndex);
+  if (!dirPath) {
+    return "";
+  }
+  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
+  return normalizePath(segments.join("/"));
 }
 
-// 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 path6 from "path";
-
-// src/router/matchRoute.ts
-function matchRoute(routes, method, path10) {
-  for (const route of routes) {
-    if (route.method !== method) {
-      continue;
+// 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: {} };
     }
-    if (!route.isDynamic) {
-      if (route.urlPath === path10) {
-        return { route, params: {} };
+    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;
       }
-      continue;
+      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 params = matchDynamicPath(route.urlPath, path10, route.paramNames, route.isCatchAll);
-    if (params !== null) {
-      return { route, params };
+    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: {} };
   }
-  return null;
 }
-function matchWsRoute(wsRoutes, path10) {
-  for (const route of wsRoutes) {
-    if (!route.isDynamic) {
-      if (route.urlPath === path10) {
-        return { route, params: {} };
-      }
-      continue;
-    }
-    const params = matchDynamicPath(route.urlPath, path10, route.paramNames, route.isCatchAll);
-    if (params !== null) {
-      return { route, params };
-    }
+
+// src/router/scanRoutes.ts
+var APP_DIR = "src";
+function toProdAbsPath(sourceAbsPath, rootDir, dist) {
+  let rel = path4.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  if (rel.startsWith(`${APP_DIR}/`)) {
+    rel = rel.slice(APP_DIR.length + 1);
   }
-  return null;
+  const prodRel = `${dist}/${rel.replace(/\.ts$/, ".js")}`;
+  return path4.resolve(rootDir, prodRel);
 }
-function matchDynamicPath(pattern, path10, paramNames, isCatchAll) {
-  const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path10.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;
+async function findMergedMiddlewares(routeFilePath, rootDir, dist) {
+  const routeDir = path4.dirname(routeFilePath);
+  const resolvedRoot = path4.resolve(rootDir);
+  const mwPaths = [];
+  let currentDir = path4.resolve(rootDir, routeDir);
+  while (true) {
+    if (dist) {
+      const mwPath = path4.join(currentDir, "middlewares.js");
+      const absMwPath = path4.resolve(rootDir, mwPath);
+      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, dist);
+      if (fs3.existsSync(prodAbsMwPath)) {
+        mwPaths.push(prodAbsMwPath);
+      }
+    } else {
+      for (const ext of [".ts", ".js"]) {
+        const mwPath = path4.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path4.resolve(rootDir, mwPath);
+        if (fs3.existsSync(absMwPath)) {
+          mwPaths.push(absMwPath);
+          break;
+        }
       }
     }
-    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 params2;
-  }
-  if (patternSegments.length !== pathSegments.length) {
-    return null;
+    if (currentDir === resolvedRoot) break;
+    const parentDir = path4.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
   }
-  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 (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 (Object.keys(params).length !== paramNames.length) {
-    return null;
+  if (mergedMiddlewares.length === 0 && Object.keys(mergedInjectors).length === 0) {
+    return void 0;
   }
-  return params;
+  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
 }
-
-// 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;
+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 [];
   }
-  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;
+async function hasWsExport(absPath) {
   try {
-    module = await importWithCacheBust(filePath);
+    const module = await importWithCacheBust(absPath);
+    return typeof module["WS"] === "function";
   } 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/utils/parseJsonBody.ts
-function parseJsonBody(text) {
-  try {
-    const data = JSON.parse(text);
-    return { success: true, data };
-  } catch {
-    return { success: false, error: "Invalid JSON body" };
+    console.warn(`[faapi] \u52A0\u8F7D\u8DEF\u7531\u6587\u4EF6\u5931\u8D25\uFF08WS \u68C0\u6D4B\uFF09${absPath}: ${reason}`);
+    return false;
   }
 }
-
-// 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;
+async function scanRoutes(rootDir, patterns, dist) {
+  const files = await fg(patterns, {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: false
+  });
+  const routes = [];
+  const wsRoutes = [];
+  for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
+    const fileName = normalizedFile.split("/").pop();
+    if (fileName === "handler.ts" || fileName === "handler.js") {
+      const absPath = path4.resolve(rootDir, normalizedFile);
+      const importPath = dist ? toProdAbsPath(absPath, rootDir, dist) : absPath;
+      const urlPath = filePathToUrlPath(normalizedFile);
+      const paramNames = extractParamNames(urlPath);
+      const isDynamic = paramNames.length > 0;
+      const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
+      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, dist);
+      const methods = await extractMethodsFromHandler(importPath);
+      for (const method of methods) {
+        routes.push({
+          method,
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      const hasWs = await hasWsExport(importPath);
+      if (hasWs) {
+        wsRoutes.push({
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
       }
+      continue;
     }
   }
-  return { fields, files };
+  return { routes, wsRoutes };
 }
 
-// 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;
+// src/router/sortRoutes.ts
+function sortRoutes(routes) {
+  return [...routes].sort((a, b) => {
+    if (a.isDynamic !== b.isDynamic) {
+      return a.isDynamic ? 1 : -1;
     }
-    const text = await request.text();
-    if (text.trim() === "") {
-      return null;
+    if (a.isCatchAll !== b.isCatchAll) {
+      return a.isCatchAll ? 1 : -1;
     }
-    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"
-        }
-      ]);
+    const aSegments = a.urlPath.split("/").filter(Boolean).length;
+    const bSegments = b.urlPath.split("/").filter(Boolean).length;
+    if (aSegments !== bSegments) {
+      return aSegments - bSegments;
     }
-    return result.data;
-  }
-  const url = new URL(request.url);
-  return queryToObject(url.searchParams);
+    return a.urlPath.localeCompare(b.urlPath);
+  });
 }
 
-// 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);
+// src/cli/generateSchemaFiles.ts
+import path5 from "path";
+import fs4 from "fs/promises";
+
+// src/ast/generateZodSchema.ts
+var CodeGenContext = class {
+  /** 命名类型集合：name → RuntimeType */
+  namedTypes = /* @__PURE__ */ new Map();
+  /** 类型解析器（用于解析 ref 的实际类型） */
+  resolveType;
+  /** 入口类型原始名（typeInfo.name，用于识别入口类型的自引用） */
+  entryTypeName = "";
+  /** 入口类型导出名（exportName，自引用时用此名生成变量名） */
+  entryExportName = "";
+  /**
+   * 是否生成 coerce 逻辑（query/params 场景，URL 来源均为 string）
+   *
+   * true 时为 number/boolean 字段包 z.preprocess，把合法的字符串转成对应类型。
+   * 嵌套类型（array/object/tuple/union 等）的元素递归处理。
+   */
+  coerce = false;
+  constructor(resolveType) {
+    this.resolveType = resolveType;
+  }
+};
+function collectNamedTypes(type, ctx) {
+  switch (type.kind) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "null":
+    case "undefined":
+    case "any":
+    case "unknown":
+    case "literal":
+    case "date":
+      return;
+    case "array":
+      collectNamedTypes(type.element, ctx);
+      return;
+    case "tuple":
+      for (const el of type.elements) {
+        collectNamedTypes(el.type, ctx);
+      }
+      return;
+    case "object":
+      for (const prop of type.properties) {
+        collectNamedTypes(prop.type, ctx);
+      }
+      return;
+    case "union":
+      for (const member of type.members) {
+        collectNamedTypes(member, ctx);
+      }
+      return;
+    case "record":
+      collectNamedTypes(type.key, ctx);
+      collectNamedTypes(type.value, ctx);
+      return;
+    case "map":
+      collectNamedTypes(type.key, ctx);
+      collectNamedTypes(type.value, ctx);
+      return;
+    case "set":
+      collectNamedTypes(type.element, ctx);
+      return;
+    case "ref": {
+      if (ctx.namedTypes.has(type.name)) return;
+      ctx.namedTypes.set(type.name, { kind: "any" });
+      const resolved = ctx.resolveType(type.name);
+      if (resolved) {
+        ctx.namedTypes.set(type.name, resolved);
+        collectNamedTypes(resolved, ctx);
+      }
+      return;
     }
   }
-  if (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;
+}
+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);
   }
-  res.end();
+  return withConstraints;
 }
-
-// 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;
+function applyConstraints(baseExpr, constraints, typeKind) {
+  const suffix = constraints.map((c) => constraintToZodChain(c, typeKind)).join("");
+  return `${baseExpr}${suffix}`;
 }
-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 };
+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()";
   }
-  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 path10 = issue.path.map(String).join(".") || "";
-    return {
-      path: path10,
-      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";
+function baseExpression(type, ctx) {
+  switch (type.kind) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "bigint":
+      return "z.never()";
+    case "null":
+      return "z.null()";
+    case "undefined":
+      return "z.undefined()";
+    case "any":
+    case "unknown":
+      return "z.unknown()";
+    case "literal":
+      return `z.literal(${JSON.stringify(type.value)})`;
+    case "array":
+      return `z.array(${runtimeTypeToZodExpression(type.element, ctx)})`;
+    case "tuple":
+      return generateTupleExpression(type.elements, ctx);
+    case "object":
+      return generateObjectExpression(type.properties, ctx);
+    case "union":
+      return generateUnionExpression(type.members, ctx);
+    case "date":
+      return 'z.preprocess((v) => (typeof v === "string" ? new Date(v) : v), z.date())';
+    case "record":
+      return `z.record(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)})`;
+    case "map":
+      return `z.preprocess(coerceMap, z.map(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)}))`;
+    case "set":
+      return `z.preprocess(coerceSet, z.set(${runtimeTypeToZodExpression(type.element, ctx)}))`;
+    case "ref":
+      if (type.name === ctx.entryTypeName) {
+        return `${ctx.entryExportName}Schema`;
       }
-      return "INVALID_VALUE";
+      return `${type.name}Schema`;
   }
 }
-function mapExpectedFromMessage(message) {
-  const match = message.match(/Expected\s+(\w+)/i);
-  return match ? match[1].toLowerCase() : "unknown";
+var COERCE_NUMBER_HELPER = 'export const coerceNumber = (v) => typeof v === "string" && v.trim() !== "" && !isNaN(Number(v)) ? Number(v) : v;';
+var COERCE_BOOLEAN_HELPER = 'export const coerceBoolean = (v) => v === "true" || v === "1" ? true : v === "false" || v === "0" ? false : v;';
+var COERCE_MAP_HELPER = 'export const coerceMap = (v) => Array.isArray(v) ? new Map(v) : v instanceof Map ? v : (v && typeof v === "object" ? new Map(Object.entries(v)) : v);';
+var COERCE_SET_HELPER = "export const coerceSet = (v) => v instanceof Set ? v : (Array.isArray(v) ? new Set(v) : v);";
+var HELPERS_FILENAME = "faapi-helpers.js";
+function generateHelpersFileSource() {
+  return [
+    "// faapi-helpers.js \u2014 faapi \u81EA\u52A8\u751F\u6210\u7684\u516C\u7528\u51FD\u6570\uFF08\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91\uFF09",
+    COERCE_NUMBER_HELPER,
+    COERCE_BOOLEAN_HELPER,
+    COERCE_MAP_HELPER,
+    COERCE_SET_HELPER,
+    ""
+  ].join("\n");
 }
-function mapReceivedFromMessage(message) {
-  const match = message.match(/received\s+(\w+)/i);
-  return match ? match[1].toLowerCase() : "unknown";
+function usesCoerceHelpers(code) {
+  return code.includes("coerceNumber") || code.includes("coerceBoolean") || code.includes("coerceMap") || code.includes("coerceSet");
 }
-
-// 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;
+function wrapCoercePreprocess(kind, inner) {
+  if (kind === "number") {
+    return `z.preprocess(coerceNumber, ${inner})`;
   }
-  const remote = req.socket?.remoteAddress;
-  if (remote) {
-    if (remote.startsWith("::ffff:")) {
-      return remote.slice(7);
+  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);
     }
-    return remote;
   }
-  return "";
-}
-
-// src/server/handleWsUpgrade.ts
-import { WebSocketServer, WebSocket } from "ws";
-import path4 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 (restExpression) {
+    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
   }
-  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(", ")
-      }
-    });
+  const hasOptional = fixedOptional.some((o) => o);
+  if (!hasOptional) {
+    return `z.tuple([${fixedExprs.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 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(", ")}])`);
   }
-  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);
-    }
+  variants.reverse();
+  if (variants.length === 1) {
+    return variants[0];
   }
-  return headers;
+  return `z.union([${variants.join(", ")}])`;
 }
-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" }
-      }
-    );
+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}])`;
 }
-
-// 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;
-    }
-  };
+function generateNamedTypeDeclaration(name, type, ctx) {
+  const expr = runtimeTypeToZodExpression(type, ctx);
+  const hasRef = containsRef(type, /* @__PURE__ */ new Set([name]));
+  if (hasRef) {
+    return `const ${name}Schema = z.lazy(() => ${expr});`;
+  }
+  return `const ${name}Schema = ${expr};`;
+}
+function containsRef(type, visited) {
+  switch (type.kind) {
+    case "ref":
+      return visited.has(type.name);
+    case "array":
+      return containsRef(type.element, visited);
+    case "tuple":
+      return type.elements.some((el) => containsRef(el.type, visited));
+    case "object":
+      return type.properties.some((prop) => containsRef(prop.type, visited));
+    case "union":
+      return type.members.some((m) => containsRef(m, visited));
+    case "record":
+      return containsRef(type.key, visited) || containsRef(type.value, visited);
+    case "map":
+      return containsRef(type.key, visited) || containsRef(type.value, visited);
+    case "set":
+      return containsRef(type.element, visited);
+    default:
+      return false;
+  }
+}
+function generateZodSchemaSource(typeInfo, resolveType, exportName, coerce = false) {
+  const ctx = new CodeGenContext(resolveType);
+  const name = exportName ?? typeInfo.name;
+  ctx.entryTypeName = typeInfo.name;
+  ctx.entryExportName = name;
+  ctx.coerce = coerce;
+  collectNamedTypes(typeInfo.runtimeType, ctx);
+  ctx.namedTypes.delete(typeInfo.name);
+  const lines = [];
+  lines.push("import { z } from 'zod';");
+  lines.push("");
+  for (const [n, type] of ctx.namedTypes) {
+    lines.push(generateNamedTypeDeclaration(n, type, ctx));
+  }
+  if (ctx.namedTypes.size > 0) lines.push("");
+  const entryExpr = runtimeTypeToZodExpression(typeInfo.runtimeType, ctx);
+  const hasSelfRef = containsRef(typeInfo.runtimeType, /* @__PURE__ */ new Set([typeInfo.name]));
+  if (hasSelfRef) {
+    lines.push(`export const ${name}Schema = z.lazy(() => ${entryExpr});`);
+  } else {
+    lines.push(`export const ${name}Schema = ${entryExpr};`);
+  }
+  return lines.join("\n");
 }
 
-// src/server/handleWsUpgrade.ts
-function getPathname(req) {
-  const url = req.url ?? "/";
-  const idx = url.indexOf("?");
-  return idx >= 0 ? url.slice(0, idx) : url;
+// src/cli/generateSchemaFiles.ts
+function getSchemaOutputPath(sourceFile, dist, rootDir) {
+  let rel = sourceFile.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
+  }
+  const idx = rel.lastIndexOf("/");
+  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
+  return path5.resolve(rootDir, dist, relDir, "zod.js");
 }
-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}`);
+function getRuntimeSchemaPath(filePath, dist, rootDir) {
+  let rel = filePath.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
+  } else if (rel.startsWith(`${dist}/`)) {
+    rel = rel.slice(dist.length + 1);
   }
-  return handler(ctx);
+  const idx = rel.lastIndexOf("/");
+  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
+  return path5.resolve(rootDir, dist, relDir, "zod.js");
 }
-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));
+function getHelpersImportPath(relDir) {
+  if (!relDir) return `./${HELPERS_FILENAME}`;
+  const depth = relDir.split("/").filter(Boolean).length;
+  return `${"../".repeat(depth)}${HELPERS_FILENAME}`;
+}
+function generateSchemaFileSource(sources, allTypes, helpersImportPath) {
+  const resolveType = (name) => allTypes.get(name)?.runtimeType;
+  const lines = ["import { z } from 'zod';"];
+  const schemaBlocks = [];
+  for (const source of sources) {
+    const { schemaName, typeInfo } = source;
+    if (!typeInfo) {
+      continue;
     }
+    const coerce = source.coerce ?? /(?:Query|Params)$/.test(schemaName);
+    const block = [`// ${schemaName}`];
+    const schemaCode = generateZodSchemaSource(typeInfo, resolveType, schemaName, coerce).replace(
+      /^import \{ z \} from 'zod';\s*\n\s*\n/,
+      ""
+    );
+    block.push(schemaCode);
+    block.push("");
+    schemaBlocks.push(block.join("\n"));
   }
-  if (handlers.onMessage) {
-    rawSocket.on("message", (data) => {
-      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-      handlers.onMessage(ws, buf.toString("utf8"));
-    });
+  const allSchemaCode = schemaBlocks.join("\n");
+  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
+    lines.push(
+      `import { coerceNumber, coerceBoolean, coerceMap, coerceSet } from '${helpersImportPath}';`
+    );
   }
-  if (handlers.onClose) {
-    rawSocket.on("close", (code, reason) => {
-      handlers.onClose(ws, code, reason.toString("utf8"));
-    });
+  lines.push("");
+  lines.push(...schemaBlocks);
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+async function generateSchemaFiles(routes, rootDir, dist) {
+  if (routes.length === 0) return;
+  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
+  const sourcesByFile = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    let list = sourcesByFile.get(source.filePath);
+    if (!list) {
+      list = [];
+      sourcesByFile.set(source.filePath, list);
+    }
+    list.push(source);
   }
-  if (handlers.onError) {
-    rawSocket.on("error", (err) => {
-      handlers.onError(ws, err);
-    });
+  const fileEntries = [];
+  for (const [filePath, fileSources] of sourcesByFile) {
+    const relFile = path5.relative(rootDir, filePath).replace(/\\/g, "/");
+    const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
+    const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
+    let relForDir = relFile;
+    if (relForDir.startsWith("src/")) {
+      relForDir = relForDir.slice(4);
+    }
+    const dirIdx = relForDir.lastIndexOf("/");
+    const zodRelDir = dirIdx >= 0 ? relForDir.slice(0, dirIdx) : "";
+    const helpersImportPath = getHelpersImportPath(zodRelDir);
+    const source = generateSchemaFileSource(fileSources, allTypes, helpersImportPath);
+    fileEntries.push({ outputPath, source });
   }
+  const allSourceCode = fileEntries.map((e) => e.source).join("\n");
+  if (usesCoerceHelpers(allSourceCode)) {
+    const helpersPath = path5.resolve(rootDir, dist, HELPERS_FILENAME);
+    await writeSchemaFile(helpersPath, generateHelpersFileSource());
+  }
+  await Promise.all(
+    fileEntries.map(({ outputPath, source }) => writeSchemaFile(outputPath, source))
+  );
 }
-async function 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}`);
+async function writeSchemaFile(outputPath, source) {
+  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
+  await fs4.writeFile(outputPath, source, "utf-8");
+}
+
+// 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);
   }
-  if (!hasContentLength) {
-    headerLines.push(`Content-Length: ${Buffer.byteLength(body)}`);
+  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}`);
   }
-  socket.write(statusLine + headerLines.join("\r\n") + "\r\n\r\n" + body);
-  socket.destroy();
+  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 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 = path4.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 });
+function mapZodIssues(error) {
+  return error.issues.map((issue) => {
+    const code = mapZodCode(issue.code, issue.message);
+    const path11 = issue.path.map(String).join(".") || "";
+    return {
+      path: path11,
+      code,
+      expected: issue.expected ?? mapExpectedFromMessage(issue.message),
+      received: issue.received ?? mapReceivedFromMessage(issue.message),
+      message: issue.message
     };
-    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;
+}
+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/cli/generateSchemaFiles.ts
-import path5 from "path";
-import fs3 from "fs/promises";
+// 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 path7 from "path";
 
-// src/ast/generateZodSchema.ts
-var CodeGenContext = class {
-  /** 命名类型集合：name → RuntimeType */
-  namedTypes = /* @__PURE__ */ new Map();
-  /** 类型解析器（用于解析 ref 的实际类型） */
-  resolveType;
-  /** 入口类型原始名（typeInfo.name，用于识别入口类型的自引用） */
-  entryTypeName = "";
-  /** 入口类型导出名（exportName，自引用时用此名生成变量名） */
-  entryExportName = "";
-  /**
-   * 是否生成 coerce 逻辑（query/params 场景，URL 来源均为 string）
-   *
-   * true 时为 number/boolean 字段包 z.preprocess，把合法的字符串转成对应类型。
-   * 嵌套类型（array/object/tuple/union 等）的元素递归处理。
-   */
-  coerce = false;
-  constructor(resolveType) {
-    this.resolveType = resolveType;
-  }
-};
-function collectNamedTypes(type, ctx) {
-  switch (type.kind) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "bigint":
-    case "null":
-    case "undefined":
-    case "any":
-    case "unknown":
-    case "literal":
-    case "date":
-      return;
-    case "array":
-      collectNamedTypes(type.element, ctx);
-      return;
-    case "tuple":
-      for (const el of type.elements) {
-        collectNamedTypes(el.type, ctx);
-      }
-      return;
-    case "object":
-      for (const prop of type.properties) {
-        collectNamedTypes(prop.type, ctx);
-      }
-      return;
-    case "union":
-      for (const member of type.members) {
-        collectNamedTypes(member, ctx);
-      }
-      return;
-    case "record":
-      collectNamedTypes(type.key, ctx);
-      collectNamedTypes(type.value, ctx);
-      return;
-    case "map":
-      collectNamedTypes(type.key, ctx);
-      collectNamedTypes(type.value, ctx);
-      return;
-    case "set":
-      collectNamedTypes(type.element, ctx);
-      return;
-    case "ref": {
-      if (ctx.namedTypes.has(type.name)) return;
-      ctx.namedTypes.set(type.name, { kind: "any" });
-      const resolved = ctx.resolveType(type.name);
-      if (resolved) {
-        ctx.namedTypes.set(type.name, resolved);
-        collectNamedTypes(resolved, ctx);
+// src/router/matchRoute.ts
+function matchRoute(routes, method, path11) {
+  for (const route of routes) {
+    if (route.method !== method) {
+      continue;
+    }
+    if (!route.isDynamic) {
+      if (route.urlPath === path11) {
+        return { route, params: {} };
       }
-      return;
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
     }
   }
+  return null;
 }
-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);
+function matchWsRoute(wsRoutes, path11) {
+  for (const route of wsRoutes) {
+    if (!route.isDynamic) {
+      if (route.urlPath === path11) {
+        return { route, params: {} };
+      }
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
   }
-  return withConstraints;
+  return null;
 }
-function applyConstraints(baseExpr, constraints, typeKind) {
-  const suffix = constraints.map((c) => constraintToZodChain(c, typeKind)).join("");
-  return `${baseExpr}${suffix}`;
+function matchDynamicPath(pattern, path11, paramNames, isCatchAll) {
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = path11.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 params2;
+  }
+  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 (Object.keys(params).length !== paramNames.length) {
+    return null;
+  }
+  return params;
 }
-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)}` : ""}))`;
+
+// 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;
     }
-    case "email":
-      return ".email()";
-    case "url":
-      return ".url()";
-    case "uuid":
-      return ".uuid()";
   }
+  return void 0;
 }
-function baseExpression(type, ctx) {
-  switch (type.kind) {
-    case "string":
-      return "z.string()";
-    case "number":
-      return "z.number()";
-    case "boolean":
-      return "z.boolean()";
-    case "bigint":
-      return "z.never()";
-    case "null":
-      return "z.null()";
-    case "undefined":
-      return "z.undefined()";
-    case "any":
-    case "unknown":
-      return "z.unknown()";
-    case "literal":
-      return `z.literal(${JSON.stringify(type.value)})`;
-    case "array":
-      return `z.array(${runtimeTypeToZodExpression(type.element, ctx)})`;
-    case "tuple":
-      return generateTupleExpression(type.elements, ctx);
-    case "object":
-      return generateObjectExpression(type.properties, ctx);
-    case "union":
-      return generateUnionExpression(type.members, ctx);
-    case "date":
-      return 'z.preprocess((v) => (typeof v === "string" ? new Date(v) : v), z.date())';
-    case "record":
-      return `z.record(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)})`;
-    case "map":
-      return `z.preprocess(coerceMap, z.map(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)}))`;
-    case "set":
-      return `z.preprocess(coerceSet, z.set(${runtimeTypeToZodExpression(type.element, ctx)}))`;
-    case "ref":
-      if (type.name === ctx.entryTypeName) {
-        return `${ctx.entryExportName}Schema`;
-      }
-      return `${type.name}Schema`;
+
+// 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}.`
+    );
   }
 }
-var COERCE_NUMBER_HELPER = 'export const coerceNumber = (v) => typeof v === "string" && v.trim() !== "" && !isNaN(Number(v)) ? Number(v) : v;';
-var COERCE_BOOLEAN_HELPER = 'export const coerceBoolean = (v) => v === "true" || v === "1" ? true : v === "false" || v === "0" ? false : v;';
-var COERCE_MAP_HELPER = 'export const coerceMap = (v) => Array.isArray(v) ? new Map(v) : v instanceof Map ? v : (v && typeof v === "object" ? new Map(Object.entries(v)) : v);';
-var COERCE_SET_HELPER = "export const coerceSet = (v) => v instanceof Set ? v : (Array.isArray(v) ? new Set(v) : v);";
-var HELPERS_FILENAME = "faapi-helpers.js";
-function generateHelpersFileSource() {
-  return [
-    "// faapi-helpers.js \u2014 faapi \u81EA\u52A8\u751F\u6210\u7684\u516C\u7528\u51FD\u6570\uFF08\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91\uFF09",
-    COERCE_NUMBER_HELPER,
-    COERCE_BOOLEAN_HELPER,
-    COERCE_MAP_HELPER,
-    COERCE_SET_HELPER,
-    ""
-  ].join("\n");
+
+// 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 };
 }
-function usesCoerceHelpers(code) {
-  return code.includes("coerceNumber") || code.includes("coerceBoolean") || code.includes("coerceMap") || code.includes("coerceSet");
+
+// 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" };
+  }
 }
-function wrapCoercePreprocess(kind, inner) {
-  if (kind === "number") {
-    return `z.preprocess(coerceNumber, ${inner})`;
+
+// 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;
   }
-  return `z.preprocess(coerceBoolean, ${inner})`;
+  const url = new URL(request.url);
+  return queryToObject(url.searchParams);
 }
-function generateTupleExpression(elements, ctx) {
-  const fixedExprs = [];
-  const fixedOptional = [];
-  let restExpression = "";
-  let restStarted = false;
-  for (const el of elements) {
-    if (el.rest) {
-      restExpression = runtimeTypeToZodExpression(el.type, ctx);
-      restStarted = true;
-    } else if (!restStarted) {
-      fixedExprs.push(runtimeTypeToZodExpression(el.type, ctx));
-      fixedOptional.push(el.optional);
+
+// src/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 (restExpression) {
-    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
+  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;
   }
-  const hasOptional = fixedOptional.some((o) => o);
-  if (!hasOptional) {
-    return `z.tuple([${fixedExprs.join(", ")}])`;
+  res.end();
+}
+
+// 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 variants = [];
-  for (let len = fixedExprs.length; len >= 0; len--) {
-    const removed = fixedOptional.slice(len);
-    if (removed.length > 0 && removed.some((o) => !o)) {
-      break;
+  const remote = req.socket?.remoteAddress;
+  if (remote) {
+    if (remote.startsWith("::ffff:")) {
+      return remote.slice(7);
     }
-    const subset = fixedExprs.slice(0, len);
-    variants.push(`z.tuple([${subset.join(", ")}])`);
-  }
-  variants.reverse();
-  if (variants.length === 1) {
-    return variants[0];
+    return remote;
   }
-  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(", ")} })`;
+  return "";
 }
-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()`;
+
+// src/server/handleWsUpgrade.ts
+import { WebSocketServer, WebSocket } from "ws";
+import path6 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 (hasNull) {
-    const unionInner2 = nonNull.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
-    return `z.union([${unionInner2}]).nullable()`;
+  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(", ")
+      }
+    });
   }
-  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});`;
+  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" }
+    });
   }
-  return `const ${name}Schema = ${expr};`;
+  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" }
+  });
 }
-function containsRef(type, visited) {
-  switch (type.kind) {
-    case "ref":
-      return visited.has(type.name);
-    case "array":
-      return containsRef(type.element, visited);
-    case "tuple":
-      return type.elements.some((el) => containsRef(el.type, visited));
-    case "object":
-      return type.properties.some((prop) => containsRef(prop.type, visited));
-    case "union":
-      return type.members.some((m) => containsRef(m, visited));
-    case "record":
-      return containsRef(type.key, visited) || containsRef(type.value, visited);
-    case "map":
-      return containsRef(type.key, visited) || containsRef(type.value, visited);
-    case "set":
-      return containsRef(type.element, visited);
-    default:
-      return false;
+
+// src/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 generateZodSchemaSource(typeInfo, resolveType, exportName, coerce = false) {
-  const ctx = new CodeGenContext(resolveType);
-  const name = exportName ?? typeInfo.name;
-  ctx.entryTypeName = typeInfo.name;
-  ctx.entryExportName = name;
-  ctx.coerce = coerce;
-  collectNamedTypes(typeInfo.runtimeType, ctx);
-  ctx.namedTypes.delete(typeInfo.name);
-  const lines = [];
-  lines.push("import { z } from 'zod';");
-  lines.push("");
-  for (const [n, type] of ctx.namedTypes) {
-    lines.push(generateNamedTypeDeclaration(n, type, ctx));
-  }
-  if (ctx.namedTypes.size > 0) lines.push("");
-  const entryExpr = runtimeTypeToZodExpression(typeInfo.runtimeType, ctx);
-  const hasSelfRef = containsRef(typeInfo.runtimeType, /* @__PURE__ */ new Set([typeInfo.name]));
-  if (hasSelfRef) {
-    lines.push(`export const ${name}Schema = z.lazy(() => ${entryExpr});`);
-  } else {
-    lines.push(`export const ${name}Schema = ${entryExpr};`);
+function 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" }
+      }
+    );
   }
-  return lines.join("\n");
 }
 
-// src/cli/generateSchemaFiles.ts
-function getSchemaOutputPath(sourceFile, dist, rootDir) {
-  let rel = sourceFile.replace(/\\/g, "/");
-  if (rel.startsWith("src/")) {
-    rel = rel.slice(4);
-  }
-  const idx = rel.lastIndexOf("/");
-  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
+// src/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;
+    }
+  };
 }
-function getRuntimeSchemaPath(filePath, dist, rootDir) {
-  let rel = filePath.replace(/\\/g, "/");
-  if (rel.startsWith("src/")) {
-    rel = rel.slice(4);
-  } else if (rel.startsWith(`${dist}/`)) {
-    rel = rel.slice(dist.length + 1);
-  }
-  const idx = rel.lastIndexOf("/");
-  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
+
+// src/server/handleWsUpgrade.ts
+function getPathname(req) {
+  const url = req.url ?? "/";
+  const idx = url.indexOf("?");
+  return idx >= 0 ? url.slice(0, idx) : url;
 }
-function getHelpersImportPath(relDir) {
-  if (!relDir) return `./${HELPERS_FILENAME}`;
-  const depth = relDir.split("/").filter(Boolean).length;
-  return `${"../".repeat(depth)}${HELPERS_FILENAME}`;
+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 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;
+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));
     }
-    const coerce = source.coerce ?? /(?:Query|Params)$/.test(schemaName);
-    const block = [`// ${schemaName}`];
-    const schemaCode = generateZodSchemaSource(typeInfo, resolveType, schemaName, coerce).replace(
-      /^import \{ z \} from 'zod';\s*\n\s*\n/,
-      ""
-    );
-    block.push(schemaCode);
-    block.push("");
-    schemaBlocks.push(block.join("\n"));
   }
-  const allSchemaCode = schemaBlocks.join("\n");
-  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
-    lines.push(
-      `import { coerceNumber, coerceBoolean, coerceMap, coerceSet } from '${helpersImportPath}';`
-    );
+  if (handlers.onMessage) {
+    rawSocket.on("message", (data) => {
+      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      handlers.onMessage(ws, buf.toString("utf8"));
+    });
   }
-  lines.push("");
-  lines.push(...schemaBlocks);
-  return lines.join("\n").replace(/\n+$/, "\n");
-}
-async function generateSchemaFiles(routes, rootDir, dist) {
-  if (routes.length === 0) return;
-  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
-  const sourcesByFile = /* @__PURE__ */ new Map();
-  for (const source of sources) {
-    let list = sourcesByFile.get(source.filePath);
-    if (!list) {
-      list = [];
-      sourcesByFile.set(source.filePath, list);
-    }
-    list.push(source);
+  if (handlers.onClose) {
+    rawSocket.on("close", (code, reason) => {
+      handlers.onClose(ws, code, reason.toString("utf8"));
+    });
   }
-  const fileEntries = [];
-  for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path5.relative(rootDir, filePath).replace(/\\/g, "/");
-    const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
-    const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
-    let relForDir = relFile;
-    if (relForDir.startsWith("src/")) {
-      relForDir = relForDir.slice(4);
+  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;
     }
-    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 });
+    headerLines.push(`${key}: ${value}`);
   }
-  const allSourceCode = fileEntries.map((e) => e.source).join("\n");
-  if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path5.resolve(rootDir, dist, HELPERS_FILENAME);
-    await writeSchemaFile(helpersPath, generateHelpersFileSource());
+  if (!hasContentLength) {
+    headerLines.push(`Content-Length: ${Buffer.byteLength(body)}`);
   }
-  await Promise.all(
-    fileEntries.map(({ outputPath, source }) => writeSchemaFile(outputPath, source))
-  );
+  socket.write(statusLine + headerLines.join("\r\n") + "\r\n\r\n" + body);
+  socket.destroy();
 }
-async function writeSchemaFile(outputPath, source) {
-  await fs3.mkdir(path5.dirname(outputPath), { recursive: true });
-  await fs3.writeFile(outputPath, source, "utf-8");
+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 = path6.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/server/createServer.ts
@@ -2682,15 +2897,15 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path10) {
+function findAllowedMethods(routes, path11) {
   const methods = /* @__PURE__ */ new Set();
   for (const route of routes) {
-    if (route.urlPath === path10) {
+    if (route.urlPath === path11) {
       methods.add(route.method);
       continue;
     }
     if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path10, route.paramNames, route.isCatchAll);
+      const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
       if (params !== null) {
         methods.add(route.method);
       }
@@ -2776,7 +2991,7 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
     }
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path6.resolve(rootDir, route.filePath);
+    const absoluteFilePath = path7.resolve(rootDir, route.filePath);
     const routeModule = await loadRouteModule(absoluteFilePath, route.method);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
@@ -2806,19 +3021,242 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
     if (outerMiddlewares.length > 0) {
       response = await compose(outerMiddlewares, ctx, routePipeline);
     } else {
-      response = await routePipeline();
+      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/testServer.ts
+var DEFAULT_PATTERNS = ["src/api/**/*.ts"];
+var DEFAULT_BODY_LIMIT2 = 10 * 1024 * 1024;
+async function createTestServer(options) {
+  const {
+    rootDir,
+    patterns = DEFAULT_PATTERNS,
+    dist,
+    cors: cors2 = false,
+    helmet: helmet2 = false,
+    logger: logger2 = false,
+    middlewares,
+    injectors,
+    onError,
+    config,
+    bodyLimit = DEFAULT_BODY_LIMIT2
+  } = options;
+  const { routes, wsRoutes } = await scanRoutes(rootDir, patterns);
+  const sorted = sortRoutes(routes);
+  const schemaDist = dist ? path8.isAbsolute(dist) ? dist : path8.resolve(rootDir, dist) : await fs5.mkdtemp(path8.join(os.tmpdir(), "faapi-test-schema-"));
+  await generateSchemaFiles(sorted, rootDir, schemaDist);
+  const { server } = createServer({
+    routes: sorted,
+    rootDir,
+    dist: schemaDist,
+    cors: cors2,
+    helmet: helmet2,
+    logger: logger2,
+    middlewares,
+    injectors,
+    onError,
+    config,
+    wsRoutes,
+    bodyLimit
+  });
+  const baseUrl = await listenOnRandomPort(server);
+  let closed = false;
+  const testServer = {
+    server,
+    baseUrl,
+    routes: sorted,
+    wsRoutes,
+    schemaDist,
+    async close() {
+      if (closed) return;
+      closed = true;
+      const s = server;
+      s.closeAllConnections?.();
+      s.closeIdleConnections?.();
+      await new Promise((resolve) => {
+        server.close(() => resolve());
+      });
+      await fs5.rm(schemaDist, { recursive: true, force: true }).catch(() => {
+      });
+      invalidateSchemaCache();
+    }
+  };
+  return testServer;
+}
+function listenOnRandomPort(server) {
+  return new Promise((resolve, reject) => {
+    server.listen(0, () => {
+      const addr = server.address();
+      if (typeof addr === "object" && addr !== null) {
+        resolve(`http://localhost:${addr.port}`);
+      } else {
+        reject(new Error("Failed to get server address"));
+      }
+    });
+    server.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/wsTestClient.ts
+import { WebSocket as WebSocket2 } from "ws";
+var MessageQueue = class {
+  queue = [];
+  waiters = [];
+  listener;
+  constructor(ws) {
+    this.listener = (data) => {
+      const msg = normalizeRawData(data);
+      const waiter = this.waiters.shift();
+      if (waiter) {
+        waiter(msg);
+      } else {
+        this.queue.push(msg);
+      }
+    };
+    ws.on("message", this.listener);
+  }
+  /**
+   * 取下一条消息
+   *
+   * 队列有则立即 resolve，无则注册 waiter 等待下一条 'message' 事件。
+   * 超时未到 → reject('WebSocket message timeout')，waiter 被清理。
+   *
+   * @param timeout 超时毫秒，默认 2000
+   */
+  next(timeout = 2e3) {
+    return new Promise((resolve, reject) => {
+      const wrapped = (msg2) => {
+        clearTimeout(timer);
+        resolve(msg2);
+      };
+      const timer = setTimeout(() => {
+        const idx = this.waiters.indexOf(wrapped);
+        if (idx >= 0) this.waiters.splice(idx, 1);
+        reject(new Error("WebSocket message timeout"));
+      }, timeout);
+      const msg = this.queue.shift();
+      if (msg !== void 0) {
+        wrapped(msg);
+      } else {
+        this.waiters.push(wrapped);
+      }
+    });
+  }
+};
+function normalizeRawData(data) {
+  if (Buffer.isBuffer(data)) {
+    return data.toString("utf8");
+  }
+  if (Array.isArray(data)) {
+    return Buffer.concat(data).toString("utf8");
+  }
+  return Buffer.from(data).toString("utf8");
+}
+function waitForWsOpen(ws, timeout = 2e3) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("WebSocket open timeout"));
+    }, timeout);
+    const cleanup = () => {
+      clearTimeout(timer);
+      ws.removeListener("open", onOpen);
+      ws.removeListener("error", onError);
+      ws.removeListener("close", onClose);
+    };
+    const onOpen = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = (err) => {
+      cleanup();
+      reject(err);
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("WebSocket closed before open"));
+    };
+    ws.once("open", onOpen);
+    ws.once("error", onError);
+    ws.once("close", onClose);
+  });
+}
+async function connectWs(baseUrl, pathname, options = {}) {
+  const { timeout = 2e3, headers, protocols } = options;
+  const wsBaseUrl = baseUrl.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+  const url = `${wsBaseUrl}${pathname}`;
+  const ws = new WebSocket2(url, protocols, headers ? { headers } : void 0);
+  const queue = new MessageQueue(ws);
+  try {
+    await waitForWsOpen(ws, timeout);
+  } catch (err) {
+    if (ws.readyState === WebSocket2.OPEN || ws.readyState === WebSocket2.CONNECTING) {
+      ws.close();
+    }
+    throw err;
+  }
+  let closed = false;
+  return {
+    ws,
+    queue,
+    async close() {
+      if (closed) return;
+      closed = true;
+      if (ws.readyState === WebSocket2.OPEN || ws.readyState === WebSocket2.CONNECTING) {
+        ws.close();
+      }
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, 1e3);
+        ws.once("close", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+  };
+}
+
+// src/cli/createAppCore.ts
+import fs7 from "fs";
+import path10 from "path";
+import { PassThrough } from "stream";
+
+// src/router/detectRouteConflicts.ts
+function detectRouteConflicts(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method} ${route.urlPath}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.files.push(route.filePath);
+    } else {
+      map.set(key, {
+        method: route.method,
+        urlPath: route.urlPath,
+        files: [route.filePath]
+      });
     }
-    await sendNodeResponse(response, res);
-  } catch (err) {
-    const errorResponse = buildErrorResponse(err);
-    await sendNodeResponse(mergeMeta(errorResponse, meta), res);
-    if (onError) {
-      try {
-        await onError(err, ctx);
-      } catch {
-      }
+  }
+  const conflicts = [];
+  for (const conflict of map.values()) {
+    if (conflict.files.length > 1) {
+      conflicts.push(conflict);
     }
   }
+  return conflicts;
 }
 
 // src/server/startServer.ts
@@ -2850,55 +3288,8 @@ function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
 }
 
 // src/cli/generateRoutes.ts
-import fs4 from "fs";
-import path7 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
+import fs6 from "fs";
+import path9 from "path";
 async function hydrateRoutes(manifest) {
   const hydrateRoute = async (serialized) => {
     const bundle = await loadMiddlewarePaths(serialized.middlewarePaths);
@@ -3029,8 +3420,8 @@ function isFaapiConfigKey(key) {
 async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
-  const routesPath = path8.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs5.existsSync(routesPath)) {
+  const routesPath = path10.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs7.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -3231,201 +3622,6 @@ async function createAppBase(options) {
   return { app, ctx };
 }
 
-// src/router/scanRoutes.ts
-import fg from "fast-glob";
-import path9 from "path";
-import fs6 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(path10) {
-  if (!path10) return "";
-  let result = path10.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) {
-  const withoutPrefix = filePath.startsWith("src/") ? filePath.slice(4) : 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
-var APP_DIR = "src";
-function toProdAbsPath(sourceAbsPath, rootDir, dist) {
-  let rel = path9.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
-  if (rel.startsWith(`${APP_DIR}/`)) {
-    rel = rel.slice(APP_DIR.length + 1);
-  }
-  const prodRel = `${dist}/${rel.replace(/\.ts$/, ".js")}`;
-  return path9.resolve(rootDir, prodRel);
-}
-async function findMergedMiddlewares(routeFilePath, rootDir, dist) {
-  const routeDir = path9.dirname(routeFilePath);
-  const resolvedRoot = path9.resolve(rootDir);
-  const mwPaths = [];
-  let currentDir = path9.resolve(rootDir, routeDir);
-  while (true) {
-    if (dist) {
-      const mwPath = path9.join(currentDir, "middlewares.js");
-      const absMwPath = path9.resolve(rootDir, mwPath);
-      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, dist);
-      if (fs6.existsSync(prodAbsMwPath)) {
-        mwPaths.push(prodAbsMwPath);
-      }
-    } else {
-      for (const ext of [".ts", ".js"]) {
-        const mwPath = path9.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path9.resolve(rootDir, mwPath);
-        if (fs6.existsSync(absMwPath)) {
-          mwPaths.push(absMwPath);
-          break;
-        }
-      }
-    }
-    if (currentDir === resolvedRoot) break;
-    const parentDir = path9.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, dist) {
-  const files = await fg(patterns, {
-    cwd: rootDir,
-    onlyFiles: true,
-    absolute: false
-  });
-  const routes = [];
-  const wsRoutes = [];
-  for (const file of files) {
-    const normalizedFile = file.replace(/\\/g, "/");
-    const fileName = normalizedFile.split("/").pop();
-    if (fileName === "handler.ts" || fileName === "handler.js") {
-      const absPath = path9.resolve(rootDir, normalizedFile);
-      const importPath = dist ? toProdAbsPath(absPath, rootDir, dist) : absPath;
-      const urlPath = filePathToUrlPath(normalizedFile);
-      const paramNames = extractParamNames(urlPath);
-      const isDynamic = paramNames.length > 0;
-      const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
-      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, dist);
-      const methods = await extractMethodsFromHandler(importPath);
-      for (const method of methods) {
-        routes.push({
-          method,
-          urlPath,
-          filePath: normalizedFile,
-          paramNames,
-          isDynamic,
-          isCatchAll: isCatchAll || void 0,
-          middlewares: middlewareBundle?.middlewares,
-          injectors: middlewareBundle?.injectors
-        });
-      }
-      const hasWs = await hasWsExport(importPath);
-      if (hasWs) {
-        wsRoutes.push({
-          urlPath,
-          filePath: normalizedFile,
-          paramNames,
-          isDynamic,
-          isCatchAll: isCatchAll || void 0,
-          middlewares: middlewareBundle?.middlewares,
-          injectors: middlewareBundle?.injectors
-        });
-      }
-      continue;
-    }
-  }
-  return { routes, wsRoutes };
-}
-
 // src/cli/createDevApp.ts
 async function createDevApp(options) {
   const { app, ctx } = await createAppBase(options);
@@ -3451,18 +3647,21 @@ async function createProdApp(options) {
 export {
   FaapiError,
   InternalError,
+  MessageQueue,
   MethodNotAllowedError,
   ModuleLoadError,
   RouteNotFoundError,
   SchemaExtractionError,
   ValidationError,
   collectRouteSchemaSources,
+  connectWs,
   cors,
   createProdApp as createApp,
   createContext,
   createDevApp,
   createProdApp,
   createProgram,
+  createTestServer,
   extractTypeInfo,
   getInputTypeForMethod,
   helmet,
@@ -3471,6 +3670,7 @@ export {
   loadConfig,
   loadEnv,
   logger,
-  resolveTypeNode
+  resolveTypeNode,
+  waitForWsOpen
 };
 //# sourceMappingURL=index.js.map