@faapi/faapi 1.5.0 → 2.0.1-canary.0

package/dist/testing.js

@@ -0,0 +1,3578 @@
+// src/runtime/sse.ts
+function encodeSseEvent(event) {
+  let out = "";
+  if (event.comment !== void 0) {
+    out += `: ${event.comment}
+`;
+  }
+  if (event.event !== void 0) {
+    out += `event: ${event.event}
+`;
+  }
+  if (event.id !== void 0) {
+    out += `id: ${event.id}
+`;
+  }
+  if (event.retry !== void 0) {
+    out += `retry: ${event.retry}
+`;
+  }
+  if (event.data !== void 0) {
+    let dataStr;
+    if (typeof event.data === "string") {
+      dataStr = event.data;
+    } else if (event.data === null) {
+      dataStr = "null";
+    } else {
+      dataStr = JSON.stringify(event.data);
+    }
+    const lines = dataStr.split("\n");
+    for (const line of lines) {
+      out += `data: ${line}
+`;
+    }
+  }
+  out += "\n";
+  return out;
+}
+function createSseWriter() {
+  const encoder = new TextEncoder();
+  let controller = null;
+  let closed = false;
+  let aborted = false;
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    },
+    cancel() {
+      aborted = true;
+      closed = true;
+      controller = null;
+    }
+  });
+  const response = new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+  const writer = {
+    send(event) {
+      if (closed || !controller) return;
+      const text = encodeSseEvent(event);
+      controller.enqueue(encoder.encode(text));
+    },
+    sendRaw(chunk) {
+      if (closed || !controller) return;
+      const bytes = typeof chunk === "string" ? encoder.encode(chunk) : chunk;
+      controller.enqueue(bytes);
+    },
+    sendError(error) {
+      if (closed || !controller) return;
+      const message = error instanceof Error ? error.message : String(error);
+      const text = encodeSseEvent({ event: "error", data: message });
+      try {
+        controller.enqueue(encoder.encode(text));
+      } finally {
+        writer.close();
+      }
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      if (controller) {
+        try {
+          controller.close();
+        } catch {
+        }
+        controller = null;
+      }
+    },
+    get closed() {
+      return closed;
+    },
+    get aborted() {
+      return aborted;
+    },
+    get response() {
+      return response;
+    }
+  };
+  return writer;
+}
+
+// src/runtime/createContext.ts
+function parseCookies(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader) return cookies;
+  for (const pair of cookieHeader.split(";")) {
+    const [name, ...rest] = pair.split("=");
+    const trimmed = name?.trim();
+    if (trimmed) {
+      cookies.set(trimmed, rest.join("=").trim());
+    }
+  }
+  return cookies;
+}
+function formatSetCookie(name, value, options) {
+  let cookie = `${name}=${value}`;
+  if (options?.domain) cookie += `; Domain=${options.domain}`;
+  if (options?.path) cookie += `; Path=${options.path}`;
+  if (options?.maxAge !== void 0) cookie += `; Max-Age=${options.maxAge}`;
+  if (options?.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options?.httpOnly) cookie += `; HttpOnly`;
+  if (options?.secure) cookie += `; Secure`;
+  if (options?.sameSite) cookie += `; SameSite=${options.sameSite}`;
+  return cookie;
+}
+function createContext(request, params, config = {}, ip = "") {
+  const url = new URL(request.url);
+  const meta = { headers: {}, setCookies: [] };
+  const parsedCookies = parseCookies(request.headers.get("cookie") ?? "");
+  const cookiesObj = {};
+  for (const [key, val] of parsedCookies) {
+    cookiesObj[key] = val;
+  }
+  const ctx = {
+    request,
+    params,
+    query: url.searchParams,
+    headers: request.headers,
+    method: request.method,
+    path: url.pathname,
+    ip,
+    ua: request.headers.get("user-agent") ?? "",
+    cookies: cookiesObj,
+    config,
+    meta,
+    setStatus(status) {
+      meta.status = status;
+    },
+    setHeader(key, value) {
+      meta.headers[key] = value;
+    },
+    setETag(value) {
+      meta.headers["etag"] = value;
+    },
+    redirect(url2, status = 302) {
+      return new Response(null, {
+        status,
+        headers: { Location: url2 }
+      });
+    },
+    json(data, status) {
+      const headers = { "Content-Type": "application/json" };
+      return new Response(JSON.stringify(data), {
+        status: status ?? 200,
+        headers
+      });
+    },
+    html(html, status) {
+      const headers = { "Content-Type": "text/html; charset=utf-8" };
+      return new Response(html, {
+        status: status ?? 200,
+        headers
+      });
+    },
+    getCookie(name) {
+      return parsedCookies.get(name);
+    },
+    setCookie(name, value, options) {
+      meta.setCookies.push(formatSetCookie(name, value, options));
+    },
+    deleteCookie(name) {
+      meta.setCookies.push(formatSetCookie(name, "", { maxAge: 0 }));
+    },
+    /**
+     * 创建 SSE writer，用于流式推送事件
+     *
+     * handler 调用此方法后，通过返回的 writer 推送事件，框架自动把 writer.response
+     * 作为 HTTP 响应（Content-Type: text/event-stream）。
+     *
+     * 与 ctx.json / ctx.html 互斥：一个 handler 只能用一种响应方式。
+     */
+    sse() {
+      const writer = createSseWriter();
+      const ctxWithSse = ctx;
+      ctxWithSse.__sseResponse = writer.response;
+      ctxWithSse.__sseWriter = writer;
+      return writer;
+    },
+    /**
+     * 显式包装成功响应(返回 Response,不会被自动包裹再次包装)
+     *
+     * 用 config.response.ok(或默认 (data) => ({ data })) 包裹 data 并返回 JSON Response。
+     * handler 也可直接 return data,框架会自动用 ok 包裹,两者等价。
+     */
+    ok(data) {
+      const responseConfig = config.response;
+      const okFn = responseConfig?.ok ?? ((d) => ({ data: d }));
+      const body = okFn(data);
+      return ctx.json(body);
+    },
+    /**
+     * 返回错误响应(对象形式参数,status 和 code 均可省略)
+     *
+     * - status 省略时 HTTP 状态码默认 500
+     * - code 省略时响应 body 里不含 code 字段(默认 fail 函数只放非 undefined 的字段)
+     * - status 和 code 独立无关联
+     *
+     * body 用 config.response.fail(或默认实现)包装。
+     */
+    fail(options) {
+      const responseConfig = config.response;
+      const failFn = responseConfig?.fail ?? ((e) => {
+        const error = { message: e.message };
+        if (e.code !== void 0) error.code = e.code;
+        return { error };
+      });
+      const body = failFn({
+        status: options.status,
+        code: options.code,
+        message: options.message
+      });
+      return ctx.json(body, options.status ?? 500);
+    }
+  };
+  const extend = config?.extendContext;
+  if (typeof extend === "function") {
+    extend(ctx);
+  }
+  return ctx;
+}
+function createTestContext(options) {
+  const { method = "GET", path: path11, query, headers, params = {}, config = {}, ip = "" } = options;
+  const url = new URL(`http://localhost${path11}`);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          url.searchParams.append(key, String(item));
+        }
+      } else {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  const request = new Request(url.toString(), {
+    method,
+    headers
+  });
+  return createContext(request, params, config, ip);
+}
+
+// src/utils/isPlainObject.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+
+// src/response/toResponse.ts
+async function toResponse(value, meta) {
+  if (value instanceof Promise) {
+    return toResponse(await value, meta);
+  }
+  const applyMeta = (headers2) => {
+    if (!meta) return;
+    for (const [key, val] of Object.entries(meta.headers)) {
+      headers2.set(key, val);
+    }
+    for (const cookie of meta.setCookies ?? []) {
+      headers2.append("set-cookie", cookie);
+    }
+  };
+  if (value instanceof Response) {
+    if (meta && (meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0)) {
+      const headers2 = new Headers(value.headers);
+      applyMeta(headers2);
+      return new Response(value.body, {
+        status: meta.status ?? value.status,
+        headers: headers2
+      });
+    }
+    return value;
+  }
+  if (value === null || value === void 0) {
+    const status = meta?.status ?? 204;
+    const headers2 = new Headers();
+    applyMeta(headers2);
+    return new Response(null, { status, headers: headers2 });
+  }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (value instanceof Uint8Array) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (isPlainObject(value) || Array.isArray(value)) {
+    const body2 = JSON.stringify(value);
+    const headers2 = new Headers({ "Content-Type": "application/json" });
+    applyMeta(headers2);
+    return new Response(body2, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (typeof value === "string") {
+    const headers2 = new Headers({ "Content-Type": "text/plain" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    const headers2 = new Headers({ "Content-Type": "text/plain" });
+    applyMeta(headers2);
+    return new Response(String(value), {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  const body = JSON.stringify(value);
+  const headers = new Headers({ "Content-Type": "application/json" });
+  applyMeta(headers);
+  return new Response(body, {
+    status: meta?.status ?? 200,
+    headers
+  });
+}
+
+// src/injection/resolveInjection.ts
+import ts from "typescript";
+var PARAM_TYPE_MAP = {
+  query: "query",
+  body: "body",
+  form: "form",
+  headers: "headers",
+  params: "params",
+  context: "context",
+  ctx: "context",
+  // 别名
+  cookies: "cookies",
+  ip: "ip",
+  ua: "ua",
+  files: "files",
+  fields: "fields"
+};
+function resolveInjection(fn) {
+  const fnStr = fn.toString();
+  const params = extractParamsWithAst(fnStr);
+  return params.map((param) => {
+    const type = PARAM_TYPE_MAP[param.name] || "unknown";
+    return {
+      name: param.name,
+      type,
+      hasType: false
+      // 运行时类型已擦除
+    };
+  });
+}
+function extractParamsWithAst(fnStr) {
+  const sourceFile = ts.createSourceFile(
+    "__faapi_injection__.ts",
+    fnStr,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const paramNames = [];
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node) && node.parameters.length > 0) {
+      for (const param of node.parameters) {
+        extractParamName(param, paramNames);
+      }
+      return;
+    }
+    if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && node.parameters.length > 0) {
+      for (const param of node.parameters) {
+        extractParamName(param, paramNames);
+      }
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return paramNames.map((name) => ({ name }));
+}
+function extractParamName(param, names) {
+  const name = param.name;
+  if (ts.isIdentifier(name)) {
+    names.push(name.text);
+    return;
+  }
+  if (ts.isObjectBindingPattern(name)) {
+    for (const element of name.elements) {
+      if (ts.isBindingElement(element)) {
+        const elemName = element.name;
+        if (ts.isIdentifier(elemName)) {
+          names.push(elemName.text);
+        }
+      }
+    }
+    return;
+  }
+  if (ts.isArrayBindingPattern(name)) {
+    for (const element of name.elements) {
+      if (element && ts.isBindingElement(element)) {
+        const elemName = element.name;
+        if (ts.isIdentifier(elemName)) {
+          names.push(elemName.text);
+        }
+      }
+    }
+    return;
+  }
+}
+
+// src/utils/queryToObject.ts
+function queryToObject(params) {
+  const result = {};
+  for (const [key, value] of params) {
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/injection/injectParams.ts
+function getBuiltinInjectionValue(type, ctx, body) {
+  switch (type) {
+    case "query":
+      return queryToObject(ctx.query);
+    case "params":
+      return ctx.params;
+    case "headers":
+      return ctx.headers;
+    case "context":
+      return ctx;
+    case "cookies":
+      return ctx.cookies;
+    case "ip":
+      return ctx.ip;
+    case "ua":
+      return ctx.ua;
+    case "body":
+      return body;
+    // form 与 body 共享解析结果（resolveInput 已按 Content-Type 解析 form-urlencoded）
+    // 差异仅在 schema 校验（form coerce=true，由 collectRouteSchemaSources 标记）
+    case "form":
+      return body;
+    case "files":
+      if (body && typeof body === "object" && "files" in body) {
+        return body.files;
+      }
+      return [];
+    case "fields":
+      if (body && typeof body === "object" && "fields" in body) {
+        return body.fields;
+      }
+      return {};
+    default:
+      return void 0;
+  }
+}
+async function injectParamsAsync(handler, ctx, body, injectors) {
+  const injections = resolveInjection(handler);
+  if (injections.length === 0) {
+    return await handler();
+  }
+  const args = await Promise.all(
+    injections.map(async (injection) => {
+      if (injection.type !== "unknown") {
+        return getBuiltinInjectionValue(injection.type, ctx, body);
+      }
+      if (injectors && injection.name in injectors) {
+        return await injectors[injection.name](ctx);
+      }
+      return void 0;
+    })
+  );
+  return await handler(...args);
+}
+
+// src/runtime/invokeHandler.ts
+function wrapResult(result, ctx) {
+  if (result instanceof Response) return result;
+  const responseConfig = ctx.config.response;
+  const okFn = responseConfig?.ok ?? ((d) => ({ data: d }));
+  return okFn(result);
+}
+function mergeMeta(response, meta) {
+  const hasMeta = meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0;
+  if (!hasMeta) return response;
+  const headers = new Headers(response.headers);
+  for (const [key, value] of Object.entries(meta.headers)) {
+    headers.set(key, value);
+  }
+  for (const cookie of meta.setCookies) {
+    headers.append("set-cookie", cookie);
+  }
+  return new Response(response.body, {
+    status: meta.status ?? response.status,
+    headers
+  });
+}
+async function compose(middlewares, ctx, finalHandler) {
+  const meta = ctx.meta;
+  let index = -1;
+  async function dispatch(i) {
+    if (i <= index) {
+      throw new Error("next() called multiple times");
+    }
+    index = i;
+    if (i >= middlewares.length) {
+      return await finalHandler();
+    }
+    const mw = middlewares[i];
+    let innerResponse;
+    const next = async () => {
+      innerResponse = await dispatch(i + 1);
+      return innerResponse;
+    };
+    const result = await mw(ctx, next);
+    if (result instanceof Response) {
+      return mergeMeta(result, meta);
+    }
+    if (innerResponse !== void 0) {
+      return innerResponse;
+    }
+    throw new Error("\u4E2D\u95F4\u4EF6\u5FC5\u987B await next() \u6216\u8FD4\u56DE Response");
+  }
+  return await dispatch(0);
+}
+async function invokeHandler(handler, ctx, body, middlewares, injectors) {
+  const meta = ctx.meta;
+  const pickSseAndAutoClose = () => {
+    const sseWriter = ctx.__sseWriter;
+    if (!sseWriter) return null;
+    if (!sseWriter.closed && !sseWriter.aborted) {
+      sseWriter.close();
+    }
+    return mergeMeta(sseWriter.response, meta);
+  };
+  const autoCloseSseOnError = () => {
+    const sseWriter = ctx.__sseWriter;
+    if (sseWriter && !sseWriter.closed && !sseWriter.aborted) {
+      sseWriter.close();
+    }
+  };
+  if (!middlewares || middlewares.length === 0) {
+    try {
+      const result = await injectParamsAsync(handler, ctx, body, injectors);
+      const sseResponse = pickSseAndAutoClose();
+      if (sseResponse) return sseResponse;
+      return toResponse(wrapResult(result, ctx), meta);
+    } catch (err) {
+      autoCloseSseOnError();
+      throw err;
+    }
+  }
+  const finalHandler = async () => {
+    try {
+      const result = await injectParamsAsync(handler, ctx, body, injectors);
+      const sseResponse = pickSseAndAutoClose();
+      if (sseResponse) return sseResponse;
+      return toResponse(wrapResult(result, ctx), meta);
+    } catch (err) {
+      autoCloseSseOnError();
+      throw err;
+    }
+  };
+  return await compose(middlewares, ctx, finalHandler);
+}
+
+// src/testServer.ts
+import path10 from "path";
+import os from "os";
+import fs9 from "fs/promises";
+
+// src/router/scanRoutes.ts
+import fg from "fast-glob";
+import path from "path";
+import fs from "fs";
+
+// src/router/constants.ts
+var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+var HTTP_METHOD_SET = new Set(HTTP_METHODS);
+
+// src/utils/normalizePath.ts
+function normalizePath(path11) {
+  if (!path11) return "";
+  let result = path11.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/utils/importWithCacheBust.ts
+import { pathToFileURL } from "url";
+var loadTs;
+function getVitestImportActual() {
+  const vi = globalThis.vi;
+  if (typeof vi?.importActual !== "function") return void 0;
+  return vi.importActual.bind(vi);
+}
+async function importWithCacheBust(filePath, bustViteCache = false) {
+  const importActual = getVitestImportActual();
+  if (importActual) {
+    if (bustViteCache) {
+      let url2 = pathToFileURL(filePath).href;
+      url2 += `?t=${Date.now()}`;
+      return await import(url2);
+    }
+    return await importActual(filePath);
+  }
+  let url = pathToFileURL(filePath).href;
+  if (loadTs !== void 0) {
+    url += `?t=${loadTs}`;
+  }
+  return await import(url);
+}
+
+// src/middleware/loadMiddlewares.ts
+var middlewareCache = /* @__PURE__ */ new Map();
+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: {} };
+  }
+}
+async function loadMergedMiddlewares(middlewarePaths) {
+  if (middlewarePaths.length === 0) return void 0;
+  const mergedMiddlewares = [];
+  const mergedInjectors = {};
+  for (const absMwPath of middlewarePaths) {
+    let bundle = getCachedMiddlewares(absMwPath);
+    if (bundle === void 0) {
+      bundle = await loadMiddlewaresFile(absMwPath);
+      setCachedMiddlewares(absMwPath, bundle);
+    }
+    mergedMiddlewares.push(...bundle.middlewares);
+    for (const [name, injector] of Object.entries(bundle.injectors)) {
+      mergedInjectors[name] = injector;
+    }
+  }
+  if (mergedMiddlewares.length === 0 && Object.keys(mergedInjectors).length === 0) {
+    return void 0;
+  }
+  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
+}
+
+// src/router/scanRoutes.ts
+var HTTP_OR_WS_EXPORT_RE = new RegExp(
+  String.raw`export\s+(?:async\s+)?(?:function\s+|const\s+)(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|WS)\b`,
+  "g"
+);
+function extractExportsFromSource(source) {
+  const names = /* @__PURE__ */ new Set();
+  let match;
+  HTTP_OR_WS_EXPORT_RE.lastIndex = 0;
+  while ((match = HTTP_OR_WS_EXPORT_RE.exec(source)) !== null) {
+    names.add(match[1]);
+  }
+  return names;
+}
+function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
+  const routeDir = path.dirname(routeFilePath);
+  const resolvedRoot = path.resolve(rootDir);
+  const paths = [];
+  let currentDir = path.resolve(rootDir, routeDir);
+  while (true) {
+    if (dist) {
+      const mwTsPath = path.join(currentDir, "middlewares.ts");
+      const mwJsPath = path.join(currentDir, "middlewares.js");
+      const absTsPath = path.resolve(rootDir, mwTsPath);
+      const absJsPath = path.resolve(rootDir, mwJsPath);
+      const absMwPath = fs.existsSync(absTsPath) ? absTsPath : fs.existsSync(absJsPath) ? absJsPath : null;
+      if (absMwPath) {
+        const relMwPath = path.relative(rootDir, absMwPath);
+        const prodAbsPath = path.resolve(rootDir, toProdFilePath(relMwPath, dist));
+        paths.push(prodAbsPath);
+      }
+    } else {
+      for (const ext of [".ts", ".js"]) {
+        const mwPath = path.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path.resolve(rootDir, mwPath);
+        if (fs.existsSync(absMwPath)) {
+          paths.push(absMwPath);
+          break;
+        }
+      }
+    }
+    if (currentDir === resolvedRoot) break;
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  paths.reverse();
+  return paths;
+}
+function toProdFilePath(filePath, dist) {
+  let rel = filePath.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
+  }
+  const jsPath = rel.replace(/\.ts$/, ".js");
+  return jsPath.startsWith(`${dist}/`) ? jsPath : `${dist}/${jsPath}`;
+}
+async function scanRoutes(rootDir, patterns, dist) {
+  const files = await fg(patterns, {
+    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 = path.resolve(rootDir, normalizedFile);
+      const urlPath = filePathToUrlPath(normalizedFile);
+      const paramNames = extractParamNames(urlPath);
+      const isDynamic = paramNames.length > 0;
+      const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
+      let middlewarePaths;
+      let middlewareBundle;
+      if (dist) {
+        middlewarePaths = collectMiddlewarePaths(normalizedFile, rootDir, dist);
+      } else {
+        const mwPaths = collectMiddlewarePaths(normalizedFile, rootDir);
+        middlewareBundle = await loadMergedMiddlewares(mwPaths);
+      }
+      const source = await fs.promises.readFile(absPath, "utf8").catch(() => "");
+      const exportNames = extractExportsFromSource(source);
+      const methods = HTTP_METHODS.filter((m) => exportNames.has(m));
+      for (const method of methods) {
+        routes.push({
+          method,
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewarePaths,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      if (exportNames.has("WS")) {
+        wsRoutes.push({
+          urlPath,
+          filePath: normalizedFile,
+          paramNames,
+          isDynamic,
+          isCatchAll: isCatchAll || void 0,
+          middlewarePaths,
+          middlewares: middlewareBundle?.middlewares,
+          injectors: middlewareBundle?.injectors
+        });
+      }
+      continue;
+    }
+  }
+  return { routes, wsRoutes };
+}
+
+// src/router/sortRoutes.ts
+function sortRoutes(routes) {
+  return [...routes].sort((a, b) => {
+    if (a.isDynamic !== b.isDynamic) {
+      return a.isDynamic ? 1 : -1;
+    }
+    if (a.isCatchAll !== b.isCatchAll) {
+      return a.isCatchAll ? 1 : -1;
+    }
+    const aSegments = a.urlPath.split("/").filter(Boolean).length;
+    const bSegments = b.urlPath.split("/").filter(Boolean).length;
+    if (aSegments !== bSegments) {
+      return aSegments - bSegments;
+    }
+    return a.urlPath.localeCompare(b.urlPath);
+  });
+}
+
+// src/cli/generateSchemaFiles.ts
+import path3 from "path";
+import fs2 from "fs/promises";
+
+// src/ast/createProgram.ts
+import ts2 from "typescript";
+var programCache = /* @__PURE__ */ new Map();
+function createProgram(filePath) {
+  const cached = programCache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  const program = ts2.createProgram([filePath], {
+    strict: true,
+    target: ts2.ScriptTarget.ES2022,
+    module: ts2.ModuleKind.NodeNext,
+    moduleResolution: ts2.ModuleResolutionKind.NodeNext,
+    skipLibCheck: true,
+    noEmit: true
+  });
+  programCache.set(filePath, program);
+  return program;
+}
+
+// src/ast/extractHandlerTypes.ts
+import ts4 from "typescript";
+
+// src/ast/resolveTypeNode.ts
+import ts3 from "typescript";
+var SchemaExtractionError = class extends Error {
+  constructor(typeText, reason, options) {
+    super(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B "${typeText}": ${reason}`, options);
+    this.typeText = typeText;
+    this.reason = reason;
+    this.name = "SchemaExtractionError";
+  }
+  typeText;
+  reason;
+};
+function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
+  const kind = typeNode.kind;
+  switch (kind) {
+    case ts3.SyntaxKind.StringKeyword:
+      return { kind: "string" };
+    case ts3.SyntaxKind.NumberKeyword:
+      return { kind: "number" };
+    case ts3.SyntaxKind.BooleanKeyword:
+      return { kind: "boolean" };
+    case ts3.SyntaxKind.BigIntKeyword:
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        "bigint \u65E0\u6CD5\u901A\u8FC7 HTTP/JSON \u4F20\u8F93,\u8BF7\u6539\u7528 string \u6216 number"
+      );
+    case ts3.SyntaxKind.SymbolKeyword:
+      throw new SchemaExtractionError(typeNode.getText(), "symbol \u65E0\u6CD5\u901A\u8FC7 HTTP/JSON \u4F20\u8F93");
+    case ts3.SyntaxKind.NullKeyword:
+      return { kind: "null" };
+    case ts3.SyntaxKind.UndefinedKeyword:
+      return { kind: "undefined" };
+    case ts3.SyntaxKind.UnknownKeyword:
+      return { kind: "any" };
+    case ts3.SyntaxKind.AnyKeyword:
+      throw new SchemaExtractionError(typeNode.getText(), "any \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528 unknown \u8868\u793A\u4E0D\u6821\u9A8C");
+    case ts3.SyntaxKind.VoidKeyword:
+      throw new SchemaExtractionError(typeNode.getText(), "void \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
+    case ts3.SyntaxKind.NeverKeyword:
+      throw new SchemaExtractionError(typeNode.getText(), "never \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
+    case ts3.SyntaxKind.ObjectKeyword:
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        "object \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528\u5177\u4F53\u5BF9\u8C61\u7C7B\u578B\u6216 unknown"
+      );
+  }
+  if (ts3.isLiteralTypeNode(typeNode)) {
+    const literal = typeNode.literal;
+    if (ts3.isStringLiteral(literal)) {
+      return { kind: "literal", value: literal.text };
+    }
+    if (ts3.isNumericLiteral(literal)) {
+      return { kind: "literal", value: Number(literal.text) };
+    }
+    if (literal.kind === ts3.SyntaxKind.TrueKeyword) {
+      return { kind: "literal", value: true };
+    }
+    if (literal.kind === ts3.SyntaxKind.FalseKeyword) {
+      return { kind: "literal", value: false };
+    }
+    if (literal.kind === ts3.SyntaxKind.NullKeyword) {
+      return { kind: "null" };
+    }
+    throw new SchemaExtractionError(typeNode.getText(), "\u4E0D\u652F\u6301\u7684\u5B57\u9762\u91CF\u7C7B\u578B");
+  }
+  if (ts3.isArrayTypeNode(typeNode)) {
+    return {
+      kind: "array",
+      element: resolveTypeNode(typeNode.elementType, checker, visited)
+    };
+  }
+  if (ts3.isTupleTypeNode(typeNode)) {
+    const elements = typeNode.elements.map((e) => {
+      if (ts3.isRestTypeNode(e)) {
+        const inner = resolveTypeNode(e.type, checker, visited);
+        if (inner.kind === "array") {
+          return { type: inner.element, optional: false, rest: true };
+        }
+        return { type: inner, optional: false, rest: true };
+      }
+      if (ts3.isNamedTupleMember(e)) {
+        return {
+          type: resolveTypeNode(e.type, checker, visited),
+          optional: !!e.questionToken,
+          rest: false
+        };
+      }
+      if (ts3.isOptionalTypeNode(e)) {
+        return {
+          type: resolveTypeNode(e.type, checker, visited),
+          optional: true,
+          rest: false
+        };
+      }
+      return {
+        type: resolveTypeNode(e, checker, visited),
+        optional: false,
+        rest: false
+      };
+    });
+    return { kind: "tuple", elements };
+  }
+  if (ts3.isUnionTypeNode(typeNode)) {
+    const members = typeNode.types.map((t) => resolveTypeNode(t, checker, visited));
+    return { kind: "union", members };
+  }
+  if (ts3.isIntersectionTypeNode(typeNode)) {
+    const properties = [];
+    for (const t of typeNode.types) {
+      const resolved = resolveTypeNode(t, checker, visited);
+      if (resolved.kind === "object") {
+        properties.push(...resolved.properties);
+      }
+    }
+    return { kind: "object", properties };
+  }
+  if (ts3.isTypeLiteralNode(typeNode)) {
+    return resolveTypeLiteral(typeNode, checker, visited);
+  }
+  if (ts3.isTypeOperatorNode(typeNode) && typeNode.operator === ts3.SyntaxKind.KeyOfKeyword) {
+    return resolveKeyOf(typeNode, checker);
+  }
+  if (ts3.isTypeOperatorNode(typeNode) && typeNode.operator === ts3.SyntaxKind.ReadonlyKeyword) {
+    return resolveTypeNode(typeNode.type, checker, visited);
+  }
+  if (ts3.isTypeReferenceNode(typeNode)) {
+    return resolveTypeReference(typeNode, checker, visited);
+  }
+  throw new SchemaExtractionError(typeNode.getText(), "\u4E0D\u652F\u6301\u7684\u7C7B\u578B\u8BED\u6CD5");
+}
+function resolveTypeLiteral(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
+  const properties = [];
+  for (const member of typeNode.members) {
+    if (ts3.isPropertySignature(member) && member.name) {
+      const name = member.name.getText();
+      const optional = !!member.questionToken;
+      const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      const constraints = extractConstraintsFromJsDoc(member, name);
+      validateConstraints(constraints, type, name);
+      properties.push(
+        constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
+      );
+    }
+    if (ts3.isIndexSignatureDeclaration(member)) {
+      const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
+      const valueType = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      return { kind: "record", key: keyType, value: valueType };
+    }
+  }
+  return { kind: "object", properties };
+}
+function extractLiteralKeys(type) {
+  if (type.kind === "literal" && typeof type.value === "string") {
+    return [type.value];
+  }
+  if (type.kind === "union") {
+    const keys = [];
+    for (const member of type.members) {
+      if (member.kind === "literal" && typeof member.value === "string") {
+        keys.push(member.value);
+      } else {
+        return null;
+      }
+    }
+    return keys;
+  }
+  return null;
+}
+function extractKeysFromChecker(typeNode, checker) {
+  if (!checker) return null;
+  const type = checker.getTypeFromTypeNode(typeNode);
+  if (type.isUnion()) {
+    const keys = [];
+    for (const member of type.types) {
+      if (member.isStringLiteral()) {
+        keys.push(member.value);
+      } else if (member.isNumberLiteral()) {
+        keys.push(String(member.value));
+      } else {
+        return null;
+      }
+    }
+    return keys;
+  }
+  if (type.isStringLiteral()) {
+    return [type.value];
+  }
+  if (type.isNumberLiteral()) {
+    return [String(type.value)];
+  }
+  return null;
+}
+function resolveKeyOf(typeNode, checker) {
+  if (!checker) {
+    throw new SchemaExtractionError(typeNode.getText(), "keyof T \u9700\u8981 checker \u624D\u80FD\u89E3\u6790");
+  }
+  const type = checker.getTypeFromTypeNode(typeNode);
+  if (type.isUnion()) {
+    const members = [];
+    for (const member of type.types) {
+      if (member.isStringLiteral()) {
+        members.push({ kind: "literal", value: member.value });
+      } else if (member.isNumberLiteral()) {
+        members.push({ kind: "literal", value: member.value });
+      } else {
+        throw new SchemaExtractionError(typeNode.getText(), "keyof T \u7684\u7ED3\u679C\u5305\u542B\u975E\u5B57\u9762\u91CF\u7C7B\u578B");
+      }
+    }
+    return { kind: "union", members };
+  }
+  if (type.isStringLiteral()) {
+    return { kind: "literal", value: type.value };
+  }
+  if (type.isNumberLiteral()) {
+    return { kind: "literal", value: type.value };
+  }
+  throw new SchemaExtractionError(typeNode.getText(), "keyof T \u7684\u7ED3\u679C\u65E0\u6CD5\u89E3\u6790\u4E3A\u5B57\u9762\u91CF\u8054\u5408");
+}
+function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
+  const typeName = typeNode.typeName.getText();
+  if (typeName === "Date") {
+    return { kind: "date" };
+  }
+  if ((typeName === "Array" || typeName === "ReadonlyArray") && typeNode.typeArguments?.length === 1) {
+    return {
+      kind: "array",
+      element: resolveTypeNode(typeNode.typeArguments[0], checker, visited)
+    };
+  }
+  if (typeName === "Record" && typeNode.typeArguments?.length === 2) {
+    return {
+      kind: "record",
+      key: resolveTypeNode(typeNode.typeArguments[0], checker, visited),
+      value: resolveTypeNode(typeNode.typeArguments[1], checker, visited)
+    };
+  }
+  if ((typeName === "Partial" || typeName === "Required" || typeName === "Readonly") && typeNode.typeArguments?.length === 1) {
+    const inner = resolveTypeNode(typeNode.typeArguments[0], checker, visited);
+    if (inner.kind === "object" && typeName === "Partial") {
+      return {
+        kind: "object",
+        properties: inner.properties.map((p) => ({ ...p, optional: true }))
+      };
+    }
+    return inner;
+  }
+  if ((typeName === "Pick" || typeName === "Omit") && typeNode.typeArguments?.length === 2) {
+    const innerType = resolveTypeNode(typeNode.typeArguments[0], checker, visited);
+    if (innerType.kind !== "object") {
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        `${typeName} \u7684 T \u5FC5\u987B\u662F\u5BF9\u8C61\u7C7B\u578B\uFF0C\u5B9E\u9645\u4E3A ${innerType.kind}`
+      );
+    }
+    const keyTypeNode = typeNode.typeArguments[1];
+    let keys = extractLiteralKeys(resolveTypeNode(keyTypeNode, checker, visited));
+    if (keys === null) {
+      keys = extractKeysFromChecker(keyTypeNode, checker);
+    }
+    if (keys === null) {
+      throw new SchemaExtractionError(typeNode.getText(), `${typeName} \u7684 K \u65E0\u6CD5\u89E3\u6790\u4E3A\u5B57\u9762\u91CF\u96C6\u5408`);
+    }
+    const keySet = new Set(keys);
+    const properties = typeName === "Pick" ? innerType.properties.filter((p) => keySet.has(p.name)) : innerType.properties.filter((p) => !keySet.has(p.name));
+    return { kind: "object", properties };
+  }
+  if (typeName === "Map") {
+    if (!typeNode.typeArguments || typeNode.typeArguments.length !== 2) {
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        "Map \u5FC5\u987B\u5E26 2 \u4E2A\u7C7B\u578B\u53C2\u6570\uFF0C\u5982 Map<K, V>\uFF0C\u88F8 Map \u4E0D\u652F\u6301"
+      );
+    }
+    return {
+      kind: "map",
+      key: resolveTypeNode(typeNode.typeArguments[0], checker, visited),
+      value: resolveTypeNode(typeNode.typeArguments[1], checker, visited)
+    };
+  }
+  if (typeName === "Set") {
+    if (!typeNode.typeArguments || typeNode.typeArguments.length !== 1) {
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        "Set \u5FC5\u987B\u5E26 1 \u4E2A\u7C7B\u578B\u53C2\u6570\uFF0C\u5982 Set<T>\uFF0C\u88F8 Set \u4E0D\u652F\u6301"
+      );
+    }
+    return {
+      kind: "set",
+      element: resolveTypeNode(typeNode.typeArguments[0], checker, visited)
+    };
+  }
+  if (typeName === "WeakMap" || typeName === "WeakSet") {
+    throw new SchemaExtractionError(
+      typeNode.getText(),
+      `${typeName} \u8FD0\u884C\u65F6\u65E0\u6CD5\u679A\u4E3E\u6821\u9A8C\uFF0C\u8BF7\u6539\u7528 Map / Set \u6216\u5BF9\u8C61`
+    );
+  }
+  if (typeName === "Promise") {
+    throw new SchemaExtractionError(
+      typeNode.getText(),
+      "Promise \u8FD0\u884C\u65F6\u65E0\u6CD5\u6821\u9A8C\uFF0C\u8BF7\u52FF\u5728 query/body \u7C7B\u578B\u4E2D\u4F7F\u7528"
+    );
+  }
+  if (typeName === "Function") {
+    throw new SchemaExtractionError(typeNode.getText(), "Function \u65E0\u6CD5\u901A\u8FC7 HTTP/JSON \u4F20\u8F93");
+  }
+  if (visited.has(typeName)) {
+    return { kind: "ref", name: typeName };
+  }
+  visited.add(typeName);
+  if (checker) {
+    const symbol = typeNode.typeName.kind === ts3.SyntaxKind.Identifier ? checker.getSymbolAtLocation(typeNode.typeName) : void 0;
+    if (symbol) {
+      const declaration = symbol.declarations?.[0];
+      if (declaration) {
+        if (ts3.isInterfaceDeclaration(declaration)) {
+          return resolveInterfaceDeclaration(declaration, checker, visited);
+        }
+        if (ts3.isTypeAliasDeclaration(declaration)) {
+          return resolveTypeNode(declaration.type, checker, visited);
+        }
+        if (ts3.isEnumDeclaration(declaration)) {
+          return resolveEnumDeclaration(declaration);
+        }
+      }
+    }
+  }
+  throw new SchemaExtractionError(typeNode.getText(), `\u65E0\u6CD5\u89E3\u6790\u7684\u5F15\u7528\u7C7B\u578B "${typeName}"`);
+}
+function resolveEnumDeclaration(node) {
+  const members = [];
+  let nextNumericValue = 0;
+  for (const member of node.members) {
+    if (member.initializer) {
+      if (ts3.isStringLiteral(member.initializer)) {
+        members.push({ kind: "literal", value: member.initializer.text });
+      } else if (ts3.isNumericLiteral(member.initializer)) {
+        const num = Number(member.initializer.text);
+        members.push({ kind: "literal", value: num });
+        nextNumericValue = num + 1;
+      } else {
+        throw new SchemaExtractionError(
+          node.name.text,
+          `enum \u6210\u5458 "${member.name.getText()}" \u7684\u521D\u59CB\u5316\u503C\u7C7B\u578B\u4E0D\u652F\u6301,\u4EC5\u652F\u6301 string/number \u5B57\u9762\u91CF`
+        );
+      }
+    } else {
+      members.push({ kind: "literal", value: nextNumericValue });
+      nextNumericValue++;
+    }
+  }
+  return { kind: "union", members };
+}
+function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ new Set()) {
+  const properties = [];
+  const propMap = /* @__PURE__ */ new Map();
+  for (const heritageClause of node.heritageClauses ?? []) {
+    if (heritageClause.token === ts3.SyntaxKind.ExtendsKeyword) {
+      for (const expr of heritageClause.types) {
+        const parentType = resolveTypeNode(expr, checker, visited);
+        if (parentType.kind === "object") {
+          for (const prop of parentType.properties) {
+            propMap.set(prop.name, prop);
+          }
+        }
+      }
+    }
+  }
+  for (const member of node.members) {
+    if (ts3.isPropertySignature(member) && member.name) {
+      const name = member.name.getText();
+      const optional = !!member.questionToken;
+      const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      const constraints = extractConstraintsFromJsDoc(member, name);
+      validateConstraints(constraints, type, name);
+      propMap.set(
+        name,
+        constraints.length > 0 ? { name, type, optional, constraints } : { name, type, optional }
+      );
+    }
+    if (ts3.isIndexSignatureDeclaration(member)) {
+      const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
+      const valueType = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      return { kind: "record", key: keyType, value: valueType };
+    }
+  }
+  for (const prop of propMap.values()) {
+    properties.push(prop);
+  }
+  return { kind: "object", properties };
+}
+var NUMBER_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
+  "max",
+  "min",
+  "int",
+  "positive",
+  "negative",
+  "nonnegative",
+  "nonpositive"
+]);
+var LENGTH_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
+  "maxLength",
+  "minLength",
+  "length"
+]);
+var STRING_FORMAT_CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
+  "regex",
+  "email",
+  "url",
+  "uuid"
+]);
+function extractConstraintsFromJsDoc(node, fieldName) {
+  const jsDocs = ts3.getJSDocCommentsAndTags(node).filter((entry) => ts3.isJSDoc(entry));
+  if (jsDocs.length === 0) return [];
+  const constraints = [];
+  for (const jsDoc of jsDocs) {
+    if (!jsDoc.tags) continue;
+    for (const tag of jsDoc.tags) {
+      const constraint = parseJsDocTag(tag, fieldName);
+      if (constraint) constraints.push(constraint);
+    }
+  }
+  return constraints;
+}
+function getTagCommentText(tag) {
+  const comment = tag.comment;
+  if (typeof comment === "string") return comment;
+  return void 0;
+}
+function parseJsDocTag(tag, fieldName) {
+  const tagName = tag.tagName.text;
+  switch (tagName) {
+    // 数值约束（带值）
+    case "max":
+    case "min": {
+      const value = parseNumberValue(tag, fieldName, tagName);
+      return { kind: tagName, value };
+    }
+    // 长度约束（带值）
+    case "maxLength":
+    case "minLength":
+    case "length": {
+      const value = parseNumberValue(tag, fieldName, tagName);
+      return { kind: tagName, value };
+    }
+    // 正则约束（带 /pattern/flags 值）
+    case "regex":
+    case "pattern": {
+      const text = getTagCommentText(tag);
+      if (!text) {
+        throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u9700\u8981 /pattern/flags \u5F62\u5F0F\u7684\u503C`);
+      }
+      const regex = parseRegexLiteral(text.trim(), fieldName);
+      return { kind: "regex", pattern: regex.pattern, flags: regex.flags };
+    }
+    // 数值约束（无值）
+    case "int":
+    case "positive":
+    case "negative":
+    case "nonnegative":
+    case "nonpositive":
+      return { kind: tagName };
+    // 字符串格式约束（无值）
+    case "email":
+    case "url":
+    case "uuid":
+      return { kind: tagName };
+    default:
+      return null;
+  }
+}
+function parseNumberValue(tag, fieldName, tagName) {
+  const text = getTagCommentText(tag);
+  if (!text) {
+    throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u9700\u8981\u4E00\u4E2A\u6570\u5B57\u503C`);
+  }
+  const trimmed = text.trim();
+  const num = Number(trimmed);
+  if (!Number.isFinite(num)) {
+    throw new SchemaExtractionError(fieldName, `@${tagName} \u6807\u7B7E\u7684\u503C "${trimmed}" \u4E0D\u662F\u6709\u6548\u6570\u5B57`);
+  }
+  return num;
+}
+function parseRegexLiteral(text, fieldName) {
+  const match = /^\/(.+)\/([gimsuy]*)$/.exec(text);
+  if (!match) {
+    throw new SchemaExtractionError(fieldName, `\u6B63\u5219\u503C "${text}" \u4E0D\u662F /pattern/flags \u5F62\u5F0F`);
+  }
+  const [, pattern, flags] = match;
+  if (!pattern) {
+    throw new SchemaExtractionError(fieldName, `\u6B63\u5219\u503C "${text}" \u7684 pattern \u90E8\u5206\u4E3A\u7A7A`);
+  }
+  return flags ? { pattern, flags } : { pattern };
+}
+function validateConstraints(constraints, type, fieldName) {
+  if (constraints.length === 0) return;
+  for (const constraint of constraints) {
+    const kind = constraint.kind;
+    if (NUMBER_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "number") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E number \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+    if (LENGTH_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "string" && type.kind !== "array") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E string \u6216 array \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+    if (STRING_FORMAT_CONSTRAINT_KINDS.has(kind)) {
+      if (type.kind !== "string") {
+        throw new SchemaExtractionError(
+          fieldName,
+          `@${kind} \u7EA6\u675F\u4EC5\u9002\u7528\u4E8E string \u5B57\u6BB5\uFF0C\u5B9E\u9645\u4E3A ${type.kind}`
+        );
+      }
+      continue;
+    }
+  }
+}
+
+// src/ast/extractHandlerTypes.ts
+function extractTypeInfo(program, filePath, typeName) {
+  const sourceFile = program.getSourceFile(filePath);
+  if (!sourceFile) return null;
+  const checker = program.getTypeChecker();
+  let result = null;
+  ts4.forEachChild(sourceFile, (node) => {
+    if (result) return;
+    if (ts4.isInterfaceDeclaration(node) && node.name.text === typeName) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(typeName);
+      const runtimeType = withFileContext(
+        filePath,
+        typeName,
+        () => resolveInterfaceDeclaration(node, checker, visited)
+      );
+      result = {
+        name: typeName,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      };
+      return;
+    }
+    if (ts4.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(typeName);
+      const runtimeType = withFileContext(
+        filePath,
+        typeName,
+        () => resolveTypeNode(node.type, checker, visited)
+      );
+      result = {
+        name: typeName,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      };
+      return;
+    }
+  });
+  return result;
+}
+function extractAllTypes(program, filePath) {
+  const sourceFile = program.getSourceFile(filePath);
+  if (!sourceFile) return /* @__PURE__ */ new Map();
+  const checker = program.getTypeChecker();
+  const result = /* @__PURE__ */ new Map();
+  ts4.forEachChild(sourceFile, (node) => {
+    if (ts4.isInterfaceDeclaration(node)) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(node.name.text);
+      const runtimeType = withFileContext(
+        filePath,
+        node.name.text,
+        () => resolveInterfaceDeclaration(node, checker, visited)
+      );
+      result.set(node.name.text, {
+        name: node.name.text,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      });
+      return;
+    }
+    if (ts4.isTypeAliasDeclaration(node)) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(node.name.text);
+      const runtimeType = withFileContext(
+        filePath,
+        node.name.text,
+        () => resolveTypeNode(node.type, checker, visited)
+      );
+      result.set(node.name.text, {
+        name: node.name.text,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      });
+      return;
+    }
+  });
+  return result;
+}
+function withFileContext(filePath, typeName, fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof SchemaExtractionError) {
+      const fileName = filePath.split("/").pop() ?? filePath;
+      const enriched = new SchemaExtractionError(
+        err.typeText,
+        `${err.reason}\uFF08\u6587\u4EF6: ${fileName}, \u7C7B\u578B: ${typeName}\uFF09`,
+        { cause: err }
+      );
+      throw enriched;
+    }
+    throw err;
+  }
+}
+
+// src/runtime/inputType.ts
+function getInputTypeForMethod(method) {
+  const upper = method.toUpperCase();
+  if (upper === "GET" || upper === "DELETE" || upper === "HEAD") {
+    return "query";
+  }
+  return "body";
+}
+function hasBody(method) {
+  const upper = method.toUpperCase();
+  return upper === "POST" || upper === "PUT" || upper === "PATCH" || upper === "DELETE";
+}
+
+// src/validator/schemaName.ts
+function getSchemaName(method, inputType) {
+  return `${method.toUpperCase()}${inputType.charAt(0).toUpperCase() + inputType.slice(1)}`;
+}
+
+// src/injection/analyzeInjection.ts
+import ts5 from "typescript";
+function analyzeInjection(code, functionName) {
+  const sourceFile = ts5.createSourceFile("temp.ts", code, ts5.ScriptTarget.Latest, true);
+  const params = [];
+  ts5.forEachChild(sourceFile, (node) => {
+    if (ts5.isFunctionDeclaration(node) && node.name?.text === functionName) {
+      for (const param of node.parameters) {
+        const paramMeta = analyzeParam(param, sourceFile);
+        params.push(paramMeta);
+      }
+    }
+  });
+  return { params };
+}
+function analyzeParam(param, sourceFile) {
+  const name = param.name.getText(sourceFile);
+  const type = PARAM_TYPE_MAP[name] || "unknown";
+  const result = { name, type };
+  if (param.type) {
+    if (ts5.isTypeReferenceNode(param.type)) {
+      result.typeName = param.type.typeName.getText(sourceFile);
+    } else if (ts5.isTypeLiteralNode(param.type)) {
+      result.schema = extractSchema(param.type, sourceFile);
+    }
+  }
+  return result;
+}
+function extractSchema(typeNode, sourceFile) {
+  const schema = [];
+  for (const member of typeNode.members) {
+    if (ts5.isPropertySignature(member) && member.name && ts5.isIdentifier(member.name)) {
+      const propName = member.name.text;
+      const optional = !!member.questionToken;
+      const propType = member.type?.getText(sourceFile) || "unknown";
+      schema.push({
+        name: propName,
+        type: propType,
+        optional
+      });
+    }
+  }
+  return schema;
+}
+
+// src/cli/collectRouteSchemaSources.ts
+import path2 from "path";
+function collectRouteSchemaSources(routes, rootDir) {
+  const methodsByFile = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const filePath = rootDir ? path2.resolve(rootDir, route.filePath) : route.filePath;
+    let entry = methodsByFile.get(filePath);
+    if (!entry) {
+      entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
+      methodsByFile.set(filePath, entry);
+    }
+    entry.methods.add(route.method);
+  }
+  const programByFile = /* @__PURE__ */ new Map();
+  const allTypesByFile = /* @__PURE__ */ new Map();
+  const mergedAllTypes = /* @__PURE__ */ new Map();
+  for (const filePath of methodsByFile.keys()) {
+    const program = createProgram(filePath);
+    programByFile.set(filePath, program);
+    const allTypes = extractAllTypes(program, filePath);
+    allTypesByFile.set(filePath, allTypes);
+    for (const [name, info] of allTypes) {
+      mergedAllTypes.set(name, info);
+    }
+  }
+  const sources = [];
+  for (const [filePath, entry] of methodsByFile) {
+    const program = programByFile.get(filePath);
+    const sourceFile = program.getSourceFile(filePath);
+    const code = sourceFile?.text ?? "";
+    for (const method of entry.methods) {
+      const inputType = getInputTypeForMethod(method);
+      const schemaName = getSchemaName(method, inputType);
+      const meta = analyzeInjection(code, method);
+      const param = meta.params.find((p) => p.type === inputType) ?? (inputType === "body" ? meta.params.find((p) => p.type === "form") : void 0);
+      const isForm = param?.type === "form";
+      const typeInfo = param?.typeName ? extractTypeInfo(program, filePath, param.typeName) : null;
+      sources.push({
+        urlPath: entry.urlPath,
+        filePath,
+        schemaName,
+        typeInfo,
+        coerce: isForm || void 0
+      });
+    }
+  }
+  return { sources, allTypesByFile, mergedAllTypes };
+}
+
+// src/ast/generateZodSchema.ts
+var CodeGenContext = class {
+  /** 命名类型集合：name → RuntimeType */
+  namedTypes = /* @__PURE__ */ new Map();
+  /** 类型解析器（用于解析 ref 的实际类型） */
+  resolveType;
+  /** 入口类型原始名（typeInfo.name，用于识别入口类型的自引用） */
+  entryTypeName = "";
+  /** 入口类型导出名（exportName，自引用时用此名生成变量名） */
+  entryExportName = "";
+  /**
+   * 是否生成 coerce 逻辑（query/params 场景，URL 来源均为 string）
+   *
+   * true 时为 number/boolean 字段包 z.preprocess，把合法的字符串转成对应类型。
+   * 嵌套类型（array/object/tuple/union 等）的元素递归处理。
+   */
+  coerce = false;
+  constructor(resolveType) {
+    this.resolveType = resolveType;
+  }
+};
+function collectNamedTypes(type, ctx) {
+  switch (type.kind) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "null":
+    case "undefined":
+    case "any":
+    case "unknown":
+    case "literal":
+    case "date":
+      return;
+    case "array":
+      collectNamedTypes(type.element, ctx);
+      return;
+    case "tuple":
+      for (const el of type.elements) {
+        collectNamedTypes(el.type, ctx);
+      }
+      return;
+    case "object":
+      for (const prop of type.properties) {
+        collectNamedTypes(prop.type, ctx);
+      }
+      return;
+    case "union":
+      for (const member of type.members) {
+        collectNamedTypes(member, ctx);
+      }
+      return;
+    case "record":
+      collectNamedTypes(type.key, ctx);
+      collectNamedTypes(type.value, ctx);
+      return;
+    case "map":
+      collectNamedTypes(type.key, ctx);
+      collectNamedTypes(type.value, ctx);
+      return;
+    case "set":
+      collectNamedTypes(type.element, ctx);
+      return;
+    case "ref": {
+      if (ctx.namedTypes.has(type.name)) return;
+      ctx.namedTypes.set(type.name, { kind: "any" });
+      const resolved = ctx.resolveType(type.name);
+      if (resolved) {
+        ctx.namedTypes.set(type.name, resolved);
+        collectNamedTypes(resolved, ctx);
+      }
+      return;
+    }
+  }
+}
+function runtimeTypeToZodExpression(type, ctx, constraints) {
+  const expr = baseExpression(type, ctx);
+  const withConstraints = constraints && constraints.length > 0 ? applyConstraints(expr, constraints, type.kind) : expr;
+  if (ctx.coerce && (type.kind === "number" || type.kind === "boolean")) {
+    return wrapCoercePreprocess(type.kind, withConstraints);
+  }
+  return withConstraints;
+}
+function applyConstraints(baseExpr, constraints, typeKind) {
+  const suffix = constraints.map((c) => constraintToZodChain(c, typeKind)).join("");
+  return `${baseExpr}${suffix}`;
+}
+function constraintToZodChain(constraint, _typeKind) {
+  switch (constraint.kind) {
+    case "max":
+      return `.max(${constraint.value})`;
+    case "min":
+      return `.min(${constraint.value})`;
+    case "int":
+      return ".int()";
+    case "positive":
+      return ".positive()";
+    case "negative":
+      return ".negative()";
+    case "nonnegative":
+      return ".nonnegative()";
+    case "nonpositive":
+      return ".nonpositive()";
+    case "maxLength":
+      return `.max(${constraint.value})`;
+    case "minLength":
+      return `.min(${constraint.value})`;
+    case "length":
+      return `.length(${constraint.value})`;
+    case "regex": {
+      const flags = constraint.flags ?? "";
+      return `.regex(new RegExp(${JSON.stringify(constraint.pattern)}${flags ? `, ${JSON.stringify(flags)}` : ""}))`;
+    }
+    case "email":
+      return ".email()";
+    case "url":
+      return ".url()";
+    case "uuid":
+      return ".uuid()";
+  }
+}
+function baseExpression(type, ctx) {
+  switch (type.kind) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "bigint":
+      return "z.never()";
+    case "null":
+      return "z.null()";
+    case "undefined":
+      return "z.undefined()";
+    case "any":
+    case "unknown":
+      return "z.unknown()";
+    case "literal":
+      return `z.literal(${JSON.stringify(type.value)})`;
+    case "array":
+      return `z.array(${runtimeTypeToZodExpression(type.element, ctx)})`;
+    case "tuple":
+      return generateTupleExpression(type.elements, ctx);
+    case "object":
+      return generateObjectExpression(type.properties, ctx);
+    case "union":
+      return generateUnionExpression(type.members, ctx);
+    case "date":
+      return 'z.preprocess((v) => (typeof v === "string" ? new Date(v) : v), z.date())';
+    case "record":
+      return `z.record(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)})`;
+    case "map":
+      return `z.preprocess(coerceMap, z.map(${runtimeTypeToZodExpression(type.key, ctx)}, ${runtimeTypeToZodExpression(type.value, ctx)}))`;
+    case "set":
+      return `z.preprocess(coerceSet, z.set(${runtimeTypeToZodExpression(type.element, ctx)}))`;
+    case "ref":
+      if (type.name === ctx.entryTypeName) {
+        return `${ctx.entryExportName}Schema`;
+      }
+      return `${type.name}Schema`;
+  }
+}
+var COERCE_NUMBER_HELPER = 'export const coerceNumber = (v) => typeof v === "string" && v.trim() !== "" && !isNaN(Number(v)) ? Number(v) : v;';
+var COERCE_BOOLEAN_HELPER = 'export const coerceBoolean = (v) => v === "true" || v === "1" ? true : v === "false" || v === "0" ? false : v;';
+var COERCE_MAP_HELPER = 'export const coerceMap = (v) => Array.isArray(v) ? new Map(v) : v instanceof Map ? v : (v && typeof v === "object" ? new Map(Object.entries(v)) : v);';
+var COERCE_SET_HELPER = "export const coerceSet = (v) => v instanceof Set ? v : (Array.isArray(v) ? new Set(v) : v);";
+var HELPERS_FILENAME = "faapi-helpers.js";
+function generateHelpersFileSource() {
+  return [
+    "// faapi-helpers.js \u2014 faapi \u81EA\u52A8\u751F\u6210\u7684\u516C\u7528\u51FD\u6570\uFF08\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91\uFF09",
+    COERCE_NUMBER_HELPER,
+    COERCE_BOOLEAN_HELPER,
+    COERCE_MAP_HELPER,
+    COERCE_SET_HELPER,
+    ""
+  ].join("\n");
+}
+function usesCoerceHelpers(code) {
+  return code.includes("coerceNumber") || code.includes("coerceBoolean") || code.includes("coerceMap") || code.includes("coerceSet");
+}
+function wrapCoercePreprocess(kind, inner) {
+  if (kind === "number") {
+    return `z.preprocess(coerceNumber, ${inner})`;
+  }
+  return `z.preprocess(coerceBoolean, ${inner})`;
+}
+function generateTupleExpression(elements, ctx) {
+  const fixedExprs = [];
+  const fixedOptional = [];
+  let restExpression = "";
+  let restStarted = false;
+  for (const el of elements) {
+    if (el.rest) {
+      restExpression = runtimeTypeToZodExpression(el.type, ctx);
+      restStarted = true;
+    } else if (!restStarted) {
+      fixedExprs.push(runtimeTypeToZodExpression(el.type, ctx));
+      fixedOptional.push(el.optional);
+    }
+  }
+  if (restExpression) {
+    return `z.tuple([${fixedExprs.join(", ")}]).rest(${restExpression})`;
+  }
+  const hasOptional = fixedOptional.some((o) => o);
+  if (!hasOptional) {
+    return `z.tuple([${fixedExprs.join(", ")}])`;
+  }
+  const variants = [];
+  for (let len = fixedExprs.length; len >= 0; len--) {
+    const removed = fixedOptional.slice(len);
+    if (removed.length > 0 && removed.some((o) => !o)) {
+      break;
+    }
+    const subset = fixedExprs.slice(0, len);
+    variants.push(`z.tuple([${subset.join(", ")}])`);
+  }
+  variants.reverse();
+  if (variants.length === 1) {
+    return variants[0];
+  }
+  return `z.union([${variants.join(", ")}])`;
+}
+function generateObjectExpression(properties, ctx) {
+  const fields = properties.map((prop) => {
+    const expr = runtimeTypeToZodExpression(prop.type, ctx, prop.constraints);
+    const finalExpr = prop.optional ? `${expr}.optional()` : expr;
+    return `${JSON.stringify(prop.name)}: ${finalExpr}`;
+  });
+  return `z.object({ ${fields.join(", ")} })`;
+}
+function generateUnionExpression(members, ctx) {
+  const hasNull = members.some((m) => m.kind === "null");
+  const nonNull = members.filter((m) => m.kind !== "null");
+  if (hasNull && nonNull.length === 1) {
+    return `${runtimeTypeToZodExpression(nonNull[0], ctx)}.nullable()`;
+  }
+  if (hasNull) {
+    const unionInner2 = nonNull.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
+    return `z.union([${unionInner2}]).nullable()`;
+  }
+  const unionInner = members.map((m) => runtimeTypeToZodExpression(m, ctx)).join(", ");
+  return `z.union([${unionInner}])`;
+}
+function generateNamedTypeDeclaration(name, type, ctx) {
+  const expr = runtimeTypeToZodExpression(type, ctx);
+  const hasRef = containsRef(type, /* @__PURE__ */ new Set([name]));
+  if (hasRef) {
+    return `const ${name}Schema = z.lazy(() => ${expr});`;
+  }
+  return `const ${name}Schema = ${expr};`;
+}
+function containsRef(type, visited) {
+  switch (type.kind) {
+    case "ref":
+      return visited.has(type.name);
+    case "array":
+      return containsRef(type.element, visited);
+    case "tuple":
+      return type.elements.some((el) => containsRef(el.type, visited));
+    case "object":
+      return type.properties.some((prop) => containsRef(prop.type, visited));
+    case "union":
+      return type.members.some((m) => containsRef(m, visited));
+    case "record":
+      return containsRef(type.key, visited) || containsRef(type.value, visited);
+    case "map":
+      return containsRef(type.key, visited) || containsRef(type.value, visited);
+    case "set":
+      return containsRef(type.element, visited);
+    default:
+      return false;
+  }
+}
+function generateZodSchemaSource(typeInfo, resolveType, exportName, coerce = false) {
+  const ctx = new CodeGenContext(resolveType);
+  const name = exportName ?? typeInfo.name;
+  ctx.entryTypeName = typeInfo.name;
+  ctx.entryExportName = name;
+  ctx.coerce = coerce;
+  collectNamedTypes(typeInfo.runtimeType, ctx);
+  ctx.namedTypes.delete(typeInfo.name);
+  const lines = [];
+  lines.push("import { z } from 'zod';");
+  lines.push("");
+  for (const [n, type] of ctx.namedTypes) {
+    lines.push(generateNamedTypeDeclaration(n, type, ctx));
+  }
+  if (ctx.namedTypes.size > 0) lines.push("");
+  const entryExpr = runtimeTypeToZodExpression(typeInfo.runtimeType, ctx);
+  const hasSelfRef = containsRef(typeInfo.runtimeType, /* @__PURE__ */ new Set([typeInfo.name]));
+  if (hasSelfRef) {
+    lines.push(`export const ${name}Schema = z.lazy(() => ${entryExpr});`);
+  } else {
+    lines.push(`export const ${name}Schema = ${entryExpr};`);
+  }
+  return lines.join("\n");
+}
+
+// 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 path3.resolve(rootDir, dist, relDir, "zod.js");
+}
+function getRuntimeSchemaPath(filePath, dist, rootDir) {
+  let rel = filePath.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
+  } else if (rel.startsWith(`${dist}/`)) {
+    rel = rel.slice(dist.length + 1);
+  }
+  const idx = rel.lastIndexOf("/");
+  const relDir = idx >= 0 ? rel.slice(0, idx) : "";
+  return path3.resolve(rootDir, dist, relDir, "zod.js");
+}
+function getHelpersImportPath(relDir) {
+  if (!relDir) return `./${HELPERS_FILENAME}`;
+  const depth = relDir.split("/").filter(Boolean).length;
+  return `${"../".repeat(depth)}${HELPERS_FILENAME}`;
+}
+function generateSchemaFileSource(sources, allTypes, helpersImportPath) {
+  const resolveType = (name) => allTypes.get(name)?.runtimeType;
+  const lines = ["import { z } from 'zod';"];
+  const schemaBlocks = [];
+  for (const source of sources) {
+    const { schemaName, typeInfo } = source;
+    if (!typeInfo) {
+      continue;
+    }
+    const coerce = source.coerce ?? /(?:Query|Params)$/.test(schemaName);
+    const block = [`// ${schemaName}`];
+    const schemaCode = generateZodSchemaSource(typeInfo, resolveType, schemaName, coerce).replace(
+      /^import \{ z \} from 'zod';\s*\n\s*\n/,
+      ""
+    );
+    block.push(schemaCode);
+    block.push("");
+    schemaBlocks.push(block.join("\n"));
+  }
+  const allSchemaCode = schemaBlocks.join("\n");
+  if (helpersImportPath && usesCoerceHelpers(allSchemaCode)) {
+    lines.push(
+      `import { coerceNumber, coerceBoolean, coerceMap, coerceSet } from '${helpersImportPath}';`
+    );
+  }
+  lines.push("");
+  lines.push(...schemaBlocks);
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+async function generateSchemaFiles(routes, rootDir, dist) {
+  if (routes.length === 0) return;
+  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
+  const sourcesByFile = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    let list = sourcesByFile.get(source.filePath);
+    if (!list) {
+      list = [];
+      sourcesByFile.set(source.filePath, list);
+    }
+    list.push(source);
+  }
+  const fileEntries = [];
+  for (const [filePath, fileSources] of sourcesByFile) {
+    const relFile = path3.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 = path3.resolve(rootDir, dist, HELPERS_FILENAME);
+    await writeSchemaFile(helpersPath, generateHelpersFileSource());
+  }
+  await Promise.all(
+    fileEntries.map(({ outputPath, source }) => writeSchemaFile(outputPath, source))
+  );
+}
+async function writeSchemaFile(outputPath, source) {
+  await fs2.mkdir(path3.dirname(outputPath), { recursive: true });
+  await fs2.writeFile(outputPath, source, "utf-8");
+}
+
+// src/errors/FaapiError.ts
+var FaapiError = class extends Error {
+  constructor(code, message, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "FaapiError";
+  }
+  code;
+  statusCode;
+};
+
+// src/errors/httpErrors.ts
+function deriveStatusCode(issues) {
+  const has400 = issues.some((i) => i.code === "INVALID_FORMAT" || i.code === "MISSING_FIELD");
+  return has400 ? 400 : 422;
+}
+var ValidationError = class extends FaapiError {
+  constructor(message, issues) {
+    super("VALIDATION_ERROR", message, deriveStatusCode(issues));
+    this.issues = issues;
+    this.name = "ValidationError";
+  }
+  issues;
+};
+var RouteNotFoundError = class extends FaapiError {
+  constructor(path11) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path11}`, 404);
+    this.name = "RouteNotFoundError";
+  }
+};
+var MethodNotAllowedError = class extends FaapiError {
+  constructor(method, path11, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path11}`, 405);
+    this.allowedMethods = allowedMethods;
+    this.name = "MethodNotAllowedError";
+  }
+  allowedMethods;
+};
+var InternalError = class extends FaapiError {
+  constructor(message) {
+    super("INTERNAL_ERROR", message, 500);
+    this.name = "InternalError";
+  }
+};
+
+// src/cli/compileOnDemand.ts
+import path7 from "path";
+import fs6 from "fs";
+
+// src/cli/compileDevRoutes.ts
+import path6 from "path";
+import fs5 from "fs";
+import fg2 from "fast-glob";
+
+// src/cli/aliasPlugin.ts
+import path5 from "path";
+import fs4 from "fs";
+
+// src/utils/resolveAlias.ts
+function resolveAlias(specifier, config) {
+  const candidates = [];
+  for (const [pattern, targets] of Object.entries(config.paths)) {
+    const wildcardIndex = pattern.indexOf("*");
+    if (wildcardIndex === -1) {
+      if (specifier === pattern) {
+        candidates.push(...targets);
+      }
+      continue;
+    }
+    const prefix = pattern.slice(0, wildcardIndex);
+    const suffix = pattern.slice(wildcardIndex + 1);
+    if (specifier.startsWith(prefix) && specifier.endsWith(suffix) && specifier.length >= prefix.length + suffix.length) {
+      const captured = specifier.slice(prefix.length, specifier.length - suffix.length);
+      for (const target of targets) {
+        candidates.push(target.replace("*", captured));
+      }
+    }
+  }
+  return candidates;
+}
+
+// src/utils/readTsconfig.ts
+import ts6 from "typescript";
+import path4 from "path";
+import fs3 from "fs";
+function readTsconfig(rootDir) {
+  const tsconfigPath = path4.resolve(rootDir, "tsconfig.json");
+  if (!fs3.existsSync(tsconfigPath)) return null;
+  const configFile = ts6.readConfigFile(tsconfigPath, ts6.sys.readFile);
+  if (configFile.error || !configFile.config) return null;
+  const parsed = ts6.parseJsonConfigFileContent(configFile.config, ts6.sys, rootDir);
+  const baseUrl = parsed.options.baseUrl ?? rootDir;
+  const rawPaths = parsed.options.paths;
+  if (!rawPaths) return null;
+  const paths = {};
+  for (const [pattern, targets] of Object.entries(rawPaths)) {
+    paths[pattern] = targets.map((t) => path4.resolve(baseUrl, t));
+  }
+  return { baseUrl, paths };
+}
+
+// src/cli/aliasPlugin.ts
+function toProdExtension(filePath) {
+  if (filePath.endsWith(".ts")) return filePath.slice(0, -3) + ".js";
+  if (filePath.endsWith(".tsx")) return filePath.slice(0, -4) + ".js";
+  if (filePath.endsWith(".jsx")) return filePath.slice(0, -4) + ".js";
+  return filePath;
+}
+function toProdImportPath(sourceFile, importer) {
+  const importerDir = path5.dirname(importer);
+  let rel = path5.relative(importerDir, sourceFile);
+  rel = rel.split(path5.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return toProdExtension(rel);
+}
+function toRealPath(p) {
+  try {
+    return fs4.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function isInsideDir(filePath, dir) {
+  const rel = path5.relative(dir, filePath);
+  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
+}
+var APP_DIR = "src";
+function toStrippedProdImportPath(sourceFile, rootDir) {
+  const appDirAbs = toRealPath(path5.resolve(rootDir, APP_DIR));
+  const sourceReal = toRealPath(sourceFile);
+  let rel = path5.relative(appDirAbs, sourceReal);
+  rel = rel.split(path5.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return toProdExtension(rel);
+}
+var PROD_EXTS = [".js", ".mjs", ".cjs"];
+var SOURCE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+var INDEX_EXTS = [
+  "/index.ts",
+  "/index.tsx",
+  "/index.js",
+  "/index.jsx",
+  "/index.mjs",
+  "/index.cjs"
+];
+function resolveRelativeSpecifier(importer, specifier) {
+  const importerDir = path5.dirname(importer);
+  const base = path5.resolve(importerDir, specifier);
+  if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
+    return fs4.existsSync(base) ? base : null;
+  }
+  if (/\.(ts|tsx|jsx)$/.test(specifier)) {
+    return fs4.existsSync(base) ? base : null;
+  }
+  for (const ext of SOURCE_EXTS) {
+    const file = base + ext;
+    if (fs4.existsSync(file)) return file;
+  }
+  for (const indexExt of INDEX_EXTS) {
+    const file = base + indexExt;
+    if (fs4.existsSync(file)) return file;
+  }
+  return null;
+}
+function createAliasPlugin(config, options) {
+  const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
+  const appDirAbs = options?.rootDir ? toRealPath(path5.resolve(options.rootDir, APP_DIR)) : null;
+  return {
+    name: "faapi-alias",
+    setup(build) {
+      build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
+        let source;
+        try {
+          source = fs4.readFileSync(args.path, "utf8");
+        } catch {
+          return void 0;
+        }
+        const importer = args.path;
+        const importerOutsideAppDir = appDirAbs ? !isInsideDir(importer, appDirAbs) : false;
+        let modified = false;
+        const newSource = source.replace(SPEC_RE, (full, prefix, quote, specifier) => {
+          if (specifier.startsWith("/") || specifier.startsWith("file:") || specifier.startsWith("node:")) {
+            return full;
+          }
+          if (specifier.startsWith("./") || specifier.startsWith("../")) {
+            const resolved = resolveRelativeSpecifier(importer, specifier);
+            if (resolved) {
+              if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
+                return full;
+              }
+              if (appDirAbs && importerOutsideAppDir && isInsideDir(resolved, appDirAbs)) {
+                modified = true;
+                return `${prefix}${quote}${toStrippedProdImportPath(
+                  resolved,
+                  options.rootDir
+                )}${quote}`;
+              }
+              modified = true;
+              return `${prefix}${quote}${toProdImportPath(resolved, importer)}${quote}`;
+            }
+            return full;
+          }
+          const candidates = resolveAlias(specifier, config);
+          for (const candidate of candidates) {
+            for (const ext of SOURCE_EXTS) {
+              const file = candidate + ext;
+              if (fs4.existsSync(file)) {
+                modified = true;
+                if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
+                  return `${prefix}${quote}${toStrippedProdImportPath(
+                    file,
+                    options.rootDir
+                  )}${quote}`;
+                }
+                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
+              }
+            }
+            for (const indexExt of INDEX_EXTS) {
+              const file = candidate + indexExt;
+              if (fs4.existsSync(file)) {
+                modified = true;
+                if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
+                  return `${prefix}${quote}${toStrippedProdImportPath(
+                    file,
+                    options.rootDir
+                  )}${quote}`;
+                }
+                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
+              }
+            }
+          }
+          return full;
+        });
+        if (!modified) return void 0;
+        return { contents: newSource, loader: "default" };
+      });
+    }
+  };
+}
+function buildAliasPlugins(rootDir) {
+  const tsconfig = readTsconfig(rootDir);
+  return [createAliasPlugin(tsconfig ?? { baseUrl: ".", paths: {} }, { rootDir })];
+}
+
+// src/cli/compileDevRoutes.ts
+var APP_DIR2 = "src";
+async function compileDevRoutes(options) {
+  const { rootDir, dist, files, logLevel = "silent" } = options;
+  const entryPoints = files ?? await fg2([`${APP_DIR2}/**/*.ts`], {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
+  });
+  if (entryPoints.length === 0) {
+    return { compiledFiles: [] };
+  }
+  const absDist = path6.resolve(rootDir, dist);
+  await fs5.promises.mkdir(absDist, { recursive: true });
+  const plugins = buildAliasPlugins(rootDir);
+  const esbuild = await import("esbuild");
+  const outbase = path6.resolve(rootDir, APP_DIR2);
+  const result = await esbuild.build({
+    entryPoints,
+    outdir: absDist,
+    outbase,
+    bundle: false,
+    platform: "node",
+    format: "esm",
+    sourcemap: true,
+    packages: "external",
+    plugins,
+    logLevel,
+    write: false
+  });
+  if (result.outputFiles) {
+    await Promise.all(
+      result.outputFiles.map(async (file) => {
+        await fs5.promises.mkdir(path6.dirname(file.path), { recursive: true });
+        const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+        await fs5.promises.writeFile(tmp, file.contents);
+        await fs5.promises.rename(tmp, file.path);
+      })
+    );
+  }
+  return { compiledFiles: entryPoints };
+}
+
+// src/cli/compileOnDemand.ts
+function isProductFresh(sourceAbsPath, productAbsPath) {
+  try {
+    const srcStat = fs6.statSync(sourceAbsPath);
+    const prodStat = fs6.statSync(productAbsPath);
+    return prodStat.mtimeMs >= srcStat.mtimeMs;
+  } catch {
+    return false;
+  }
+}
+var compiledFiles = /* @__PURE__ */ new Set();
+async function ensureCompiled(sourceAbsPath, rootDir, dist) {
+  if (compiledFiles.has(sourceAbsPath)) {
+    return false;
+  }
+  if (!fs6.existsSync(sourceAbsPath)) {
+    return false;
+  }
+  const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
+  if (productPath && isProductFresh(sourceAbsPath, productPath)) {
+    compiledFiles.add(sourceAbsPath);
+    return false;
+  }
+  await compileDevRoutes({
+    rootDir,
+    dist,
+    files: [sourceAbsPath],
+    logLevel: "silent"
+  });
+  compiledFiles.add(sourceAbsPath);
+  return true;
+}
+function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
+  const rel = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  if (!rel.startsWith("src/")) return null;
+  const relWithoutSrc = rel.slice(4);
+  const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
+  return path7.resolve(rootDir, dist, jsRel);
+}
+var generatedSchemas = /* @__PURE__ */ new Set();
+async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
+  if (generatedSchemas.has(schemaPath)) {
+    return false;
+  }
+  const prodAbsPath = path7.resolve(rootDir, routeFilePath);
+  const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
+  if (!fs6.existsSync(sourceAbsPath)) {
+    return false;
+  }
+  if (isProductFresh(sourceAbsPath, schemaPath)) {
+    generatedSchemas.add(schemaPath);
+    return false;
+  }
+  const fileRoutes = routes.filter((r) => r.filePath === routeFilePath);
+  if (fileRoutes.length === 0) {
+    return false;
+  }
+  const sourceRelPath = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
+  await generateSchemaFiles(sourceRoutes, rootDir, dist);
+  generatedSchemas.add(schemaPath);
+  return true;
+}
+function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
+  const rel = path7.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  let relWithoutDist = rel;
+  if (relWithoutDist.startsWith(`${dist}/`)) {
+    relWithoutDist = relWithoutDist.slice(dist.length + 1);
+  }
+  const srcRel = `src/${relWithoutDist}`;
+  const tsRel = srcRel.replace(/\.js$/, ".ts");
+  const tsAbs = path7.resolve(rootDir, tsRel);
+  if (fs6.existsSync(tsAbs)) return tsAbs;
+  return path7.resolve(rootDir, srcRel);
+}
+var devOnDemandEnabled = false;
+function isDevOnDemandEnabled() {
+  return devOnDemandEnabled;
+}
+var devDistDir;
+function getDevDist() {
+  return devDistDir;
+}
+
+// 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, isDevOnDemandEnabled());
+    moduleCache.set(schemaPath, mod);
+  }
+  return mod;
+}
+async function validateInput(schemaPath, method, inputType, input) {
+  const schemaName = getSchemaName(method, inputType);
+  const schemaKey = `${schemaName}Schema`;
+  let mod;
+  try {
+    mod = await loadSchemaModule(schemaPath);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new InternalError(`Schema \u6A21\u5757\u52A0\u8F7D\u5931\u8D25: ${schemaPath}: ${reason}`);
+  }
+  const schema = mod[schemaKey];
+  if (schema === void 0 || schema === null) {
+    const data = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+    return { valid: true, issues: [], data };
+  }
+  if (typeof schema !== "object" || typeof schema.safeParse !== "function") {
+    throw new InternalError(`Schema \u4E0D\u662F\u6709\u6548\u7684 zod schema: ${schemaPath}#${schemaName}`);
+  }
+  const inputObj = typeof input === "object" && input !== null && !Array.isArray(input) ? input : {};
+  const zodSchema = schema;
+  const result = zodSchema.safeParse(inputObj);
+  if (result.success) {
+    const data = typeof result.data === "object" && result.data !== null && !Array.isArray(result.data) ? result.data : {};
+    return { valid: true, issues: [], data };
+  }
+  const issues = mapZodIssues(result.error);
+  return { valid: false, issues, data: inputObj };
+}
+function mapZodIssues(error) {
+  return error.issues.map((issue) => {
+    const code = mapZodCode(issue.code, issue.message);
+    const 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
+    };
+  });
+}
+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/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 path9 from "path";
+
+// 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: {} };
+      }
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+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 null;
+}
+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;
+}
+
+// src/loader/loadRouteModule.ts
+import fs7 from "fs";
+
+// src/loader/resolveExports.ts
+function resolveExport(module, exportName) {
+  if (exportName in module && typeof module[exportName] !== "undefined") {
+    return module[exportName];
+  }
+  const defaultExport = module.default;
+  if (defaultExport !== null && typeof defaultExport === "object") {
+    const value = defaultExport[exportName];
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return 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, rootDir) {
+  if (isDevOnDemandEnabled() && rootDir) {
+    const dist = getDevDist();
+    if (dist) {
+      const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+      if (sourcePath && fs7.existsSync(sourcePath)) {
+        try {
+          await ensureCompiled(sourcePath, rootDir, dist);
+        } catch (compileErr) {
+          const reason = compileErr instanceof Error ? compileErr.message : String(compileErr);
+          throw new Error(`Failed to compile route module "${sourcePath}": ${reason}`, {
+            cause: compileErr
+          });
+        }
+      }
+    }
+  }
+  let module;
+  try {
+    module = await importWithCacheBust(filePath, isDevOnDemandEnabled());
+  } 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" };
+  }
+}
+
+// src/utils/parseMultipart.ts
+async function parseMultipart(request) {
+  const formData = await request.formData();
+  const fields = {};
+  const files = [];
+  for (const [key, value] of formData.entries()) {
+    if (value instanceof File) {
+      files.push({
+        name: key,
+        filename: value.name,
+        type: value.type,
+        size: value.size,
+        arrayBuffer: () => value.arrayBuffer()
+      });
+    } else {
+      if (key in fields) {
+        const existing = fields[key];
+        if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          fields[key] = [existing, value];
+        }
+      } else {
+        fields[key] = value;
+      }
+    }
+  }
+  return { fields, files };
+}
+
+// src/runtime/resolveInput.ts
+async function resolveInput(method, request) {
+  const inputType = getInputTypeForMethod(method);
+  if (inputType === "body") {
+    const contentType = request.headers.get("content-type") ?? "";
+    if (contentType.includes("multipart/form-data")) {
+      return parseMultipart(request);
+    }
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      const text2 = await request.text();
+      if (text2.trim() === "") return null;
+      const params = new URLSearchParams(text2);
+      const obj = {};
+      for (const [key, value] of params) {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    const text = await request.text();
+    if (text.trim() === "") {
+      return null;
+    }
+    const result = parseJsonBody(text);
+    if (!result.success) {
+      throw new ValidationError("\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON", [
+        {
+          path: "body",
+          code: "INVALID_FORMAT",
+          expected: "JSON",
+          received: "text",
+          message: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON"
+        }
+      ]);
+    }
+    return result.data;
+  }
+  const url = new URL(request.url);
+  return queryToObject(url.searchParams);
+}
+
+// src/response/sendNodeResponse.ts
+import { Readable } from "stream";
+async function sendNodeResponse(response, res) {
+  res.statusCode = response.status;
+  for (const [key, value] of response.headers) {
+    if (key.toLowerCase() === "set-cookie") {
+      res.appendHeader(key, value);
+    } else {
+      res.setHeader(key, value);
+    }
+  }
+  if (response.body) {
+    const nodeStream = Readable.fromWeb(response.body);
+    await new Promise((resolve, reject) => {
+      nodeStream.on("error", reject);
+      res.on("error", reject);
+      res.on("finish", resolve);
+      nodeStream.pipe(res);
+    });
+    return;
+  }
+  res.end();
+}
+
+// src/utils/getClientIp.ts
+function getClientIp(req) {
+  const xff = req.headers["x-forwarded-for"];
+  if (typeof xff === "string" && xff.length > 0) {
+    const first = xff.split(",")[0]?.trim();
+    if (first) return first;
+  }
+  const remote = req.socket?.remoteAddress;
+  if (remote) {
+    if (remote.startsWith("::ffff:")) {
+      return remote.slice(7);
+    }
+    return remote;
+  }
+  return "";
+}
+
+// src/middleware/cors.ts
+var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+function cors(options = {}) {
+  const {
+    origin = true,
+    methods = DEFAULT_METHODS,
+    allowedHeaders,
+    exposeHeaders,
+    credentials = false,
+    maxAge
+  } = options;
+  return async (ctx, next) => {
+    const reqOrigin = ctx.headers.get("origin");
+    if (!reqOrigin) {
+      await next();
+      return;
+    }
+    let allowOrigin = null;
+    if (origin === true) {
+      allowOrigin = reqOrigin;
+    } else if (typeof origin === "string") {
+      allowOrigin = reqOrigin === origin ? origin : null;
+    } else if (Array.isArray(origin)) {
+      allowOrigin = origin.includes(reqOrigin) ? reqOrigin : null;
+    }
+    if (!allowOrigin) {
+      await next();
+      return;
+    }
+    ctx.setHeader("Access-Control-Allow-Origin", allowOrigin);
+    if (origin === true || Array.isArray(origin)) {
+      const existingVary = ctx.headers.get("vary");
+      if (existingVary) {
+        if (!existingVary.toLowerCase().includes("origin")) {
+          ctx.setHeader("Vary", `${existingVary}, Origin`);
+        }
+      } else {
+        ctx.setHeader("Vary", "Origin");
+      }
+    }
+    ctx.setHeader("Access-Control-Allow-Methods", methods.join(", "));
+    if (allowedHeaders) {
+      ctx.setHeader("Access-Control-Allow-Headers", allowedHeaders.join(", "));
+    } else {
+      const requestHeaders = ctx.headers.get("access-control-request-headers");
+      if (requestHeaders) {
+        ctx.setHeader("Access-Control-Allow-Headers", requestHeaders);
+      }
+    }
+    if (exposeHeaders && exposeHeaders.length > 0) {
+      ctx.setHeader("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+    }
+    if (credentials) {
+      ctx.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+    if (maxAge !== void 0) {
+      ctx.setHeader("Access-Control-Max-Age", String(maxAge));
+    }
+    if (ctx.method === "OPTIONS") {
+      return new Response(null, { status: 204 });
+    }
+    await next();
+  };
+}
+
+// src/middleware/helmet.ts
+var DEFAULTS = {
+  contentSecurityPolicy: "default-src 'self'",
+  xFrameOptions: "SAMEORIGIN",
+  xContentTypeOptions: true,
+  referrerPolicy: "no-referrer",
+  strictTransportSecurity: "max-age=31536000; includeSubDomains",
+  xDnsPrefetchControl: true,
+  xDownloadOptions: true,
+  xPermittedCrossDomainPolicies: "none",
+  crossOriginOpenerPolicy: "same-origin",
+  crossOriginResourcePolicy: "same-origin",
+  crossOriginEmbedderPolicy: false,
+  originAgentCluster: true,
+  xPoweredBy: true
+};
+function helmet(options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  return async (ctx, next) => {
+    if (opts.contentSecurityPolicy !== false) {
+      ctx.setHeader("Content-Security-Policy", opts.contentSecurityPolicy);
+    }
+    if (opts.xFrameOptions !== false) {
+      ctx.setHeader("X-Frame-Options", opts.xFrameOptions);
+    }
+    if (opts.xContentTypeOptions) {
+      ctx.setHeader("X-Content-Type-Options", "nosniff");
+    }
+    if (opts.referrerPolicy !== false) {
+      ctx.setHeader("Referrer-Policy", opts.referrerPolicy);
+    }
+    if (opts.strictTransportSecurity !== false) {
+      ctx.setHeader("Strict-Transport-Security", opts.strictTransportSecurity);
+    }
+    if (opts.xDnsPrefetchControl) {
+      ctx.setHeader("X-DNS-Prefetch-Control", "off");
+    }
+    if (opts.xDownloadOptions) {
+      ctx.setHeader("X-Download-Options", "noopen");
+    }
+    if (opts.xPermittedCrossDomainPolicies !== false) {
+      ctx.setHeader("X-Permitted-Cross-Domain-Policies", opts.xPermittedCrossDomainPolicies);
+    }
+    if (opts.crossOriginOpenerPolicy !== false) {
+      ctx.setHeader("Cross-Origin-Opener-Policy", opts.crossOriginOpenerPolicy);
+    }
+    if (opts.crossOriginResourcePolicy !== false) {
+      ctx.setHeader("Cross-Origin-Resource-Policy", opts.crossOriginResourcePolicy);
+    }
+    if (opts.crossOriginEmbedderPolicy !== false) {
+      ctx.setHeader("Cross-Origin-Embedder-Policy", opts.crossOriginEmbedderPolicy);
+    }
+    if (opts.originAgentCluster) {
+      ctx.setHeader("Origin-Agent-Cluster", "?1");
+    }
+    if (opts.xPoweredBy) {
+      ctx.setHeader("X-Powered-By", "faapi");
+    }
+    return await next();
+  };
+}
+
+// src/middleware/logger.ts
+function logger(options = {}) {
+  return async (ctx, next) => {
+    const log = options.log ?? console.log;
+    const start = Date.now();
+    try {
+      const response = await next();
+      const duration = Date.now() - start;
+      const entry = {
+        method: ctx.method,
+        path: ctx.path,
+        status: response.status,
+        durationMs: duration
+      };
+      log(entry, `${ctx.method} ${ctx.path} ${response.status} ${duration}ms`);
+      return response;
+    } catch (err) {
+      const duration = Date.now() - start;
+      const message = err instanceof Error ? err.message : String(err);
+      const status = err?.statusCode ?? 500;
+      const entry = {
+        method: ctx.method,
+        path: ctx.path,
+        status,
+        durationMs: duration,
+        error: message
+      };
+      log(entry, `${ctx.method} ${ctx.path} ${status} ${duration}ms - ${message}`);
+      throw err;
+    }
+  };
+}
+
+// src/server/handleWsUpgrade.ts
+import fs8 from "fs";
+import { WebSocketServer, WebSocket } from "ws";
+import path8 from "path";
+
+// src/errors/formatErrorResponse.ts
+function formatErrorResponse(error) {
+  if (error instanceof ValidationError) {
+    const body2 = {
+      code: error.code,
+      message: error.message,
+      issues: error.issues
+    };
+    return new Response(JSON.stringify({ error: body2 }), {
+      status: error.statusCode,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  if (error instanceof MethodNotAllowedError) {
+    const body2 = {
+      code: error.code,
+      message: error.message
+    };
+    return new Response(JSON.stringify({ error: body2 }), {
+      status: error.statusCode,
+      headers: {
+        "Content-Type": "application/json",
+        Allow: error.allowedMethods.join(", ")
+      }
+    });
+  }
+  if (error instanceof FaapiError) {
+    const body2 = {
+      code: error.code,
+      message: error.message
+    };
+    return new Response(JSON.stringify({ error: body2 }), {
+      status: error.statusCode,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  const body = {
+    code: "INTERNAL_ERROR",
+    message: error instanceof Error ? error.message : "An unknown error occurred"
+  };
+  return new Response(JSON.stringify({ error: body }), {
+    status: 500,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+// src/server/serverUtils.ts
+function nodeHttpToWebHeaders(req) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) headers.append(key, v);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+function buildErrorResponse(err) {
+  try {
+    return formatErrorResponse(err);
+  } catch {
+    return new Response(
+      JSON.stringify({ error: { code: "INTERNAL_ERROR", message: "Internal Server Error" } }),
+      {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+
+// src/runtime/wsHandler.ts
+function wrapWsSocket(rawSocket) {
+  return {
+    send(data) {
+      const payload = typeof data === "string" || Buffer.isBuffer(data) ? data : JSON.stringify(data);
+      rawSocket.send(payload);
+    },
+    close(code, reason) {
+      rawSocket.close(code, reason);
+    },
+    get readyState() {
+      return rawSocket.readyState;
+    }
+  };
+}
+
+// src/server/handleWsUpgrade.ts
+function getPathname(req) {
+  const url = req.url ?? "/";
+  const idx = url.indexOf("?");
+  return idx >= 0 ? url.slice(0, idx) : url;
+}
+async function loadWsHandler(filePath, ctx, rootDir) {
+  if (isDevOnDemandEnabled() && rootDir) {
+    const dist = getDevDist();
+    if (dist) {
+      const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
+      if (sourcePath && fs8.existsSync(sourcePath)) {
+        await ensureCompiled(sourcePath, rootDir, dist);
+      }
+    }
+  }
+  const module = await importWithCacheBust(filePath, isDevOnDemandEnabled());
+  const handler = module["WS"];
+  if (typeof handler !== "function") {
+    throw new Error(`WS export not found in ${filePath}`);
+  }
+  return handler(ctx);
+}
+function bindEvents(rawSocket, handlers) {
+  if (!handlers) return;
+  const ws = wrapWsSocket(rawSocket);
+  if (handlers.onOpen) {
+    if (rawSocket.readyState === WebSocket.OPEN) {
+      handlers.onOpen(ws);
+    } else {
+      rawSocket.once("open", () => handlers.onOpen(ws));
+    }
+  }
+  if (handlers.onMessage) {
+    rawSocket.on("message", (data) => {
+      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      handlers.onMessage(ws, buf.toString("utf8"));
+    });
+  }
+  if (handlers.onClose) {
+    rawSocket.on("close", (code, reason) => {
+      handlers.onClose(ws, code, reason.toString("utf8"));
+    });
+  }
+  if (handlers.onError) {
+    rawSocket.on("error", (err) => {
+      handlers.onError(ws, err);
+    });
+  }
+}
+async function sendResponseToSocket(socket, response) {
+  const body = await response.text().catch(() => "");
+  const statusLine = `HTTP/1.1 ${response.status} ${response.statusText || ""}\r
+`;
+  const headerLines = [];
+  let hasContentLength = false;
+  for (const [key, value] of response.headers) {
+    if (key.toLowerCase() === "content-length") {
+      hasContentLength = true;
+    }
+    headerLines.push(`${key}: ${value}`);
+  }
+  if (!hasContentLength) {
+    headerLines.push(`Content-Length: ${Buffer.byteLength(body)}`);
+  }
+  socket.write(statusLine + headerLines.join("\r\n") + "\r\n\r\n" + body);
+  socket.destroy();
+}
+function attachWebSocket(options) {
+  const { server, routesRef, rootDir, config, globalMiddlewares } = options;
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", async (req, socket, head) => {
+    const currentWsRoutes = routesRef.wsCurrent;
+    const pathname = getPathname(req);
+    const match = matchWsRoute(currentWsRoutes, pathname);
+    if (!match) {
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const { route, params } = match;
+    const headers = nodeHttpToWebHeaders(req);
+    const host = req.headers.host ?? "localhost";
+    const url = `http://${host}${req.url ?? "/"}`;
+    const request = new Request(url, { method: "GET", headers });
+    const ctx = createContext(request, params, config, getClientIp(req));
+    const meta = ctx.meta;
+    let upgraded = false;
+    const finalHandler = async () => {
+      let handlers;
+      try {
+        const absoluteFilePath = path8.resolve(rootDir, route.filePath);
+        handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        console.error(`[faapi] WS handler \u52A0\u8F7D\u5931\u8D25 ${route.filePath}: ${reason}`);
+        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 {
+      if (route.middlewares === void 0 && route.middlewarePaths) {
+        const bundle = await loadMergedMiddlewares(route.middlewarePaths);
+        if (bundle) {
+          route.middlewares = bundle.middlewares;
+        } else {
+          route.middlewares = [];
+        }
+      }
+      const dirMiddlewares = route.middlewares ?? [];
+      const allMiddlewares = globalMiddlewares && globalMiddlewares.length > 0 ? [...globalMiddlewares, ...dirMiddlewares] : dirMiddlewares;
+      if (allMiddlewares.length > 0) {
+        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
+var DEFAULT_BODY_LIMIT = 10 * 1024 * 1024;
+function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
+  const forwardedProto = req.headers["x-forwarded-proto"];
+  const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+  const headers = nodeHttpToWebHeaders(req);
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return new Request(url.toString(), { method, headers });
+  }
+  const stream = Readable2.toWeb(req);
+  const limitedStream = limitStreamSize(stream, bodyLimit);
+  return new Request(url.toString(), {
+    method,
+    headers,
+    body: limitedStream,
+    duplex: "half"
+  });
+}
+function limitStreamSize(stream, maxSize) {
+  let totalSize = 0;
+  const reader = stream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await reader.read();
+      if (done) {
+        controller.close();
+        reader.releaseLock();
+        return;
+      }
+      totalSize += value.byteLength;
+      if (totalSize > maxSize) {
+        controller.error(new Error(`\u8BF7\u6C42\u4F53\u8D85\u8FC7\u5927\u5C0F\u9650\u5236 ${maxSize} \u5B57\u8282`));
+        reader.releaseLock();
+        return;
+      }
+      controller.enqueue(value);
+    },
+    cancel(reason) {
+      reader.cancel(reason);
+    }
+  });
+}
+function findAllowedMethods(routes, path11) {
+  const methods = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (route.urlPath === path11) {
+      methods.add(route.method);
+      continue;
+    }
+    if (route.isDynamic) {
+      const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+      if (params !== null) {
+        methods.add(route.method);
+      }
+    }
+  }
+  return Array.from(methods);
+}
+function createServer(options) {
+  const {
+    routes,
+    rootDir,
+    dist,
+    cors: corsOption,
+    onError,
+    config,
+    wsRoutes,
+    middlewares: globalMiddlewares,
+    injectors: globalInjectors,
+    helmet: helmetOption,
+    logger: loggerOption,
+    bodyLimit = DEFAULT_BODY_LIMIT,
+    http2: http2Option
+  } = options;
+  const routesRef = { current: routes, wsCurrent: wsRoutes ?? [] };
+  const configMiddlewares = [];
+  const corsMiddleware = corsOption === false ? null : corsOption === true || corsOption === void 0 ? cors() : cors(corsOption);
+  if (corsMiddleware) configMiddlewares.push(corsMiddleware);
+  if (helmetOption) {
+    const helmOpts = typeof helmetOption === "object" ? helmetOption : {};
+    configMiddlewares.push(helmet(helmOpts));
+  }
+  const loggerMiddlewareInst = loggerOption === false ? null : loggerOption === true || loggerOption === void 0 ? logger() : logger(loggerOption);
+  if (loggerMiddlewareInst) configMiddlewares.push(loggerMiddlewareInst);
+  const server = (() => {
+    if (http2Option) {
+      const h2Opts = typeof http2Option === "object" ? http2Option : {};
+      return createHttp2SecureServer({
+        key: h2Opts.key ? readFileSync(h2Opts.key) : void 0,
+        cert: h2Opts.cert ? readFileSync(h2Opts.cert) : void 0,
+        allowHTTP1: true
+      });
+    }
+    return createHttpServer();
+  })();
+  server.on("request", (req, res) => {
+    const currentRoutes = routesRef.current;
+    handleRequest(
+      currentRoutes,
+      rootDir,
+      dist,
+      req,
+      res,
+      configMiddlewares,
+      onError,
+      config,
+      globalMiddlewares,
+      globalInjectors,
+      bodyLimit
+    ).catch(() => {
+      res.statusCode = 500;
+      res.end();
+    });
+  });
+  if (routesRef.wsCurrent.length > 0) {
+    attachWebSocket({ server, routesRef, rootDir, config, globalMiddlewares });
+  }
+  return { server, routesRef };
+}
+async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
+  const request = toWebRequest(req, bodyLimit);
+  const method = request.method.toUpperCase();
+  const urlPath = new URL(request.url).pathname;
+  const ctx = createContext(request, {}, config, getClientIp(req));
+  const meta = ctx.meta;
+  const routePipeline = async () => {
+    const match = matchRoute(routes, method, urlPath);
+    if (!match) {
+      const allowedMethods = findAllowedMethods(routes, urlPath);
+      if (allowedMethods.length > 0) {
+        throw new MethodNotAllowedError(method, urlPath, allowedMethods);
+      }
+      throw new RouteNotFoundError(urlPath);
+    }
+    ctx.params = match.params;
+    const { route } = match;
+    const absoluteFilePath = path9.resolve(rootDir, route.filePath);
+    const routeModule = await loadRouteModule(absoluteFilePath, route.method, rootDir);
+    const input = await resolveInput(route.method, request);
+    const inputType = getInputTypeForMethod(route.method);
+    const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
+    if (isDevOnDemandEnabled()) {
+      const devDist = getDevDist();
+      if (devDist) {
+        await ensureSchemaGenerated(schemaPath, route.filePath, routes, rootDir, dist);
+      }
+    }
+    const result = await validateInput(schemaPath, route.method, inputType, input);
+    if (!result.valid) {
+      throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", result.issues);
+    }
+    const body = hasBody(route.method) ? result.data : void 0;
+    if (route.middlewares === void 0 && route.injectors === void 0 && route.middlewarePaths) {
+      const bundle = await loadMergedMiddlewares(route.middlewarePaths);
+      if (bundle) {
+        route.middlewares = bundle.middlewares;
+        route.injectors = bundle.injectors;
+      } else {
+        route.middlewares = [];
+        route.injectors = {};
+      }
+    }
+    const mergedInjectors = globalInjectors ? { ...globalInjectors, ...route.injectors } : route.injectors;
+    const response = await invokeHandler(
+      routeModule.handler,
+      ctx,
+      body,
+      route.middlewares,
+      mergedInjectors
+    );
+    return response;
+  };
+  try {
+    let response;
+    const outerMiddlewares = [];
+    if (configMiddlewares.length > 0) outerMiddlewares.push(...configMiddlewares);
+    if (globalMiddlewares && globalMiddlewares.length > 0) {
+      outerMiddlewares.push(...globalMiddlewares);
+    }
+    if (outerMiddlewares.length > 0) {
+      response = await compose(outerMiddlewares, ctx, routePipeline);
+    } else {
+      response = await routePipeline();
+    }
+    await sendNodeResponse(response, res);
+  } catch (err) {
+    const errorResponse = buildErrorResponse(err);
+    await sendNodeResponse(mergeMeta(errorResponse, meta), res);
+    if (onError) {
+      try {
+        await onError(err, ctx);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/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 ? path10.isAbsolute(dist) ? dist : path10.resolve(rootDir, dist) : await fs9.mkdtemp(path10.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 fs9.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();
+        });
+      });
+    }
+  };
+}
+export {
+  MessageQueue,
+  connectWs,
+  createTestContext,
+  createTestServer,
+  invokeHandler,
+  waitForWsOpen
+};
+//# sourceMappingURL=testing.js.map