@faapi/faapi 6.17.0 → 6.18.1

package/dist/testing.js

@@ -1,3 +1,12 @@
+// src/response/bufferedBody.ts
+var bufferedBodyResponses = /* @__PURE__ */ new WeakSet();
+function markBufferedBody(response) {
+  bufferedBodyResponses.add(response);
+}
+function hasBufferedBody(response) {
+  return bufferedBodyResponses.has(response);
+}
+
 // src/utils/isPlainObject.ts
 function isPlainObject(value) {
   if (value === null || typeof value !== "object") {
@@ -12,8 +21,50 @@ function isPlainObject(value) {
 
 // src/utils/stringifyJson.ts
 function stringifyJson(value) {
+  if (!needsConversion(value, /* @__PURE__ */ new Set())) {
+    return JSON.stringify(value);
+  }
   return JSON.stringify(convertValue(value, /* @__PURE__ */ new Set()));
 }
+function needsConversion(value, ancestors) {
+  if (value === null) return false;
+  const type = typeof value;
+  if (type === "bigint") return true;
+  if (type === "number") return !Number.isFinite(value);
+  if (type !== "object") return false;
+  const obj = value;
+  if (ancestors.has(obj)) {
+    throw new TypeError("[faapi] Converting circular structure to JSON");
+  }
+  if (obj instanceof Date || obj instanceof Map || obj instanceof Set || obj instanceof RegExp) {
+    return true;
+  }
+  if (typeof obj.toJSON === "function") return true;
+  if (Array.isArray(obj)) {
+    ancestors.add(obj);
+    for (let i = 0; i < obj.length; i++) {
+      if (needsConversion(obj[i], ancestors)) {
+        ancestors.delete(obj);
+        return true;
+      }
+    }
+    ancestors.delete(obj);
+    return false;
+  }
+  if (isPlainObject(obj)) {
+    ancestors.add(obj);
+    for (const key in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      if (needsConversion(obj[key], ancestors)) {
+        ancestors.delete(obj);
+        return true;
+      }
+    }
+    ancestors.delete(obj);
+    return false;
+  }
+  return false;
+}
 function convertValue(value, ancestors) {
   if (value === null) return value;
   const type = typeof value;
@@ -108,16 +159,30 @@ function createSseWriter() {
   let controller = null;
   let closed = false;
   let aborted = false;
-  const stream = new ReadableStream({
-    start(c) {
-      controller = c;
+  let drainWaiters = [];
+  const resolveDrainWaiters = () => {
+    const waiters = drainWaiters;
+    drainWaiters = [];
+    for (const resolve of waiters) resolve();
+  };
+  const stream = new ReadableStream(
+    {
+      start(c) {
+        controller = c;
+      },
+      // 消费者排空缓冲后再要数据 → 背压解除，唤醒 waitForDrain 等待方
+      pull() {
+        resolveDrainWaiters();
+      },
+      cancel() {
+        aborted = true;
+        closed = true;
+        controller = null;
+        resolveDrainWaiters();
+      }
     },
-    cancel() {
-      aborted = true;
-      closed = true;
-      controller = null;
-    }
-  });
+    { highWaterMark: 16 }
+  );
   const response = new Response(stream, {
     status: 200,
     headers: {
@@ -152,6 +217,7 @@ function createSseWriter() {
     close() {
       if (closed) return;
       closed = true;
+      resolveDrainWaiters();
       if (controller) {
         try {
           controller.close();
@@ -163,6 +229,16 @@ function createSseWriter() {
     get closed() {
       return closed;
     },
+    get desiredSize() {
+      return controller ? controller.desiredSize : null;
+    },
+    waitForDrain() {
+      if (closed || !controller) return Promise.resolve();
+      if ((controller.desiredSize ?? 0) > 0) return Promise.resolve();
+      return new Promise((resolve) => {
+        drainWaiters.push(resolve);
+      });
+    },
     get aborted() {
       return aborted;
     },
@@ -199,14 +275,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path15) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path15}`, 404);
+  constructor(path16) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path16}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path15, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path15}`, 405);
+  constructor(method, path16, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path16}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -252,7 +328,9 @@ function jsonRaw(body, status, extraHeaders) {
     const extra = new Headers(extraHeaders);
     extra.forEach((value, key) => headers.set(key, value));
   }
-  return new Response(stringifyJson(body), { status, headers });
+  const response = new Response(stringifyJson(body), { status, headers });
+  markBufferedBody(response);
+  return response;
 }
 function wrapOkResult(result, config) {
   if (result instanceof Response) return result;
@@ -269,12 +347,9 @@ function formatFailResponse(options, config) {
 }
 function formatErrorResponse(error, config) {
   const failFn = resolveFailFn(config);
+  const buildFailBody = (e) => failFn({ status: e.statusCode, code: e.code, message: e.message });
   if (error instanceof ValidationError) {
-    const body2 = failFn({
-      status: error.statusCode,
-      code: error.code,
-      message: error.message
-    });
+    const body2 = buildFailBody(error);
     const bodyObj = typeof body2 === "object" && body2 !== null ? { ...body2 } : { error: body2 };
     const existingError = bodyObj.error;
     if (existingError && typeof existingError === "object") {
@@ -287,28 +362,15 @@ function formatErrorResponse(error, config) {
     return jsonOk(bodyObj, error.statusCode);
   }
   if (error instanceof MethodNotAllowedError) {
-    const body2 = failFn({
-      status: error.statusCode,
-      code: error.code,
-      message: error.message
+    return jsonOk(buildFailBody(error), error.statusCode, {
+      Allow: error.allowedMethods.join(", ")
     });
-    return jsonOk(body2, error.statusCode, { Allow: error.allowedMethods.join(", ") });
   }
   if (error instanceof PayloadTooLargeError) {
-    const body2 = failFn({
-      status: error.statusCode,
-      code: error.code,
-      message: error.message
-    });
-    return jsonOk(body2, error.statusCode);
+    return jsonOk(buildFailBody(error), error.statusCode);
   }
   if (error instanceof FaapiError) {
-    const body2 = failFn({
-      status: error.statusCode,
-      code: error.code,
-      message: error.message
-    });
-    return jsonOk(body2, error.statusCode);
+    return jsonOk(buildFailBody(error), error.statusCode);
   }
   const message = error instanceof Error ? error.message : "An unknown error occurred";
   const body = failFn({ status: 500, code: "INTERNAL_ERROR", message });
@@ -513,10 +575,12 @@ function createContextFromUrl(request, url, params, config = {}, ip = "", regist
     },
     html(html, status) {
       const headers = { "Content-Type": "text/html; charset=utf-8" };
-      return new Response(html, {
+      const response = new Response(html, {
         status: status ?? 200,
         headers
       });
+      markBufferedBody(response);
+      return response;
     },
     getCookie(name) {
       return parsedCookies.get(name);
@@ -584,7 +648,7 @@ function createContextFromUrl(request, url, params, config = {}, ip = "", regist
 function createTestContext(options) {
   const {
     method = "GET",
-    path: path15,
+    path: path16,
     query,
     headers,
     params = {},
@@ -592,7 +656,7 @@ function createTestContext(options) {
     ip = "",
     registries
   } = options;
-  const url = new URL(`http://localhost${path15}`);
+  const url = new URL(`http://localhost${path16}`);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (Array.isArray(value)) {
@@ -676,51 +740,67 @@ async function toResponse(value, meta) {
   if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
     const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
     applyMeta(headers2);
-    return new Response(value, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+    return markBuffered(
+      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
-    });
+    return markBuffered(
+      new Response(value, {
+        status: meta?.status ?? 200,
+        headers: headers2
+      })
+    );
   }
   if (isPlainObject(value) || Array.isArray(value)) {
     const body2 = stringifyJson(value);
     const headers2 = new Headers({ "Content-Type": "application/json" });
     applyMeta(headers2);
-    return new Response(body2, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+    return markBuffered(
+      new Response(body2, {
+        status: meta?.status ?? 200,
+        headers: headers2
+      })
+    );
   }
   if (typeof value === "string") {
     const headers2 = new Headers({ "Content-Type": "text/plain" });
     applyMeta(headers2);
-    return new Response(value, {
-      status: meta?.status ?? 200,
-      headers: headers2
-    });
+    return markBuffered(
+      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
-    });
+    return markBuffered(
+      new Response(String(value), {
+        status: meta?.status ?? 200,
+        headers: headers2
+      })
+    );
   }
   const body = stringifyJson(value);
   const headers = new Headers({ "Content-Type": "application/json" });
   applyMeta(headers);
-  return new Response(body, {
-    status: meta?.status ?? 200,
-    headers
-  });
+  return markBuffered(
+    new Response(body, {
+      status: meta?.status ?? 200,
+      headers
+    })
+  );
+}
+function markBuffered(response) {
+  markBufferedBody(response);
+  return response;
 }
 
 // src/injection/resolveInjection.ts
@@ -825,7 +905,10 @@ function extractParamName(param, names) {
 }
 
 // src/utils/queryToObject.ts
+var queryCache = /* @__PURE__ */ new WeakMap();
 function queryToObject(params) {
+  const cached = queryCache.get(params);
+  if (cached) return cached;
   const result = {};
   for (const [key, value] of params) {
     const existing = result[key];
@@ -837,6 +920,7 @@ function queryToObject(params) {
       result[key] = [existing, value];
     }
   }
+  queryCache.set(params, result);
   return result;
 }
 
@@ -1157,18 +1241,7 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
       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 () => {
+  const executeAndFormat = async () => {
     try {
       const result = await injectParamsAsync(handler, ctx, body, injectors);
       const sseResponse = pickSseAndAutoClose();
@@ -1179,27 +1252,31 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
       throw err;
     }
   };
+  if (!middlewares || middlewares.length === 0) {
+    return executeAndFormat();
+  }
+  const finalHandler = executeAndFormat;
   return await compose(middlewares, ctx, finalHandler);
 }
 
 // src/testServer.ts
-import path14 from "path";
+import path15 from "path";
 import os from "os";
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 
 // src/router/scanRoutes.ts
 import fg from "fast-glob";
 import path2 from "path";
-import fs2 from "fs";
+import fs3 from "fs";
 
 // src/router/constants.ts
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var HTTP_METHOD_SET = new Set(HTTP_METHODS);
 
 // src/utils/normalizePath.ts
-function normalizePath(path15) {
-  if (!path15) return "";
-  let result = path15.replace(/\\/g, "/");
+function normalizePath(path16) {
+  if (!path16) return "";
+  let result = path16.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -1246,6 +1323,7 @@ function filePathToUrlPath(filePath) {
 }
 
 // src/utils/importWithCacheBust.ts
+import fs from "fs";
 import { pathToFileURL } from "url";
 var loadTs;
 function getVitestImportActual() {
@@ -1253,13 +1331,26 @@ function getVitestImportActual() {
   if (typeof vi?.importActual !== "function") return void 0;
   return vi.importActual.bind(vi);
 }
+var bustCache = /* @__PURE__ */ new Map();
+var bustCounter = 0;
 async function importWithCacheBust(filePath, bustViteCache = false) {
   const importActual = getVitestImportActual();
   if (importActual) {
     if (bustViteCache) {
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs.statSync(filePath).mtimeMs;
+      } catch {
+      }
+      const cached = bustCache.get(filePath);
+      if (cached && cached.mtimeMs === mtimeMs) {
+        return cached.module;
+      }
       let url2 = pathToFileURL(filePath).href;
-      url2 += `?t=${Date.now()}`;
-      return await import(url2);
+      url2 += `?t=${Date.now()}-${++bustCounter}`;
+      const module = await import(url2);
+      bustCache.set(filePath, { mtimeMs, module });
+      return module;
     }
     return await importActual(filePath);
   }
@@ -1347,7 +1438,7 @@ async function loadMergedMiddlewares(middlewarePaths) {
 
 // src/utils/prodPaths.ts
 import path from "path";
-import fs from "fs";
+import fs2 from "fs";
 var APP_DIR = "src";
 function toProdFilePath(filePath, dist) {
   let rel = filePath.replace(/\\/g, "/");
@@ -1365,7 +1456,7 @@ function toProdExtension(filePath) {
 }
 function toRealPath(p) {
   try {
-    return fs.realpathSync(p);
+    return fs2.realpathSync(p);
   } catch {
     return p;
   }
@@ -1400,7 +1491,7 @@ function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
       const mwJsPath = path2.join(currentDir, "middlewares.js");
       const absTsPath = path2.resolve(rootDir, mwTsPath);
       const absJsPath = path2.resolve(rootDir, mwJsPath);
-      const absMwPath = fs2.existsSync(absTsPath) ? absTsPath : fs2.existsSync(absJsPath) ? absJsPath : null;
+      const absMwPath = fs3.existsSync(absTsPath) ? absTsPath : fs3.existsSync(absJsPath) ? absJsPath : null;
       if (absMwPath) {
         const relMwPath = path2.relative(rootDir, absMwPath);
         const prodAbsPath = path2.resolve(rootDir, toProdFilePath(relMwPath, dist));
@@ -1410,7 +1501,7 @@ function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
       for (const ext of [".ts", ".js"]) {
         const mwPath = path2.join(currentDir, `middlewares${ext}`);
         const absMwPath = path2.resolve(rootDir, mwPath);
-        if (fs2.existsSync(absMwPath)) {
+        if (fs3.existsSync(absMwPath)) {
           paths.push(absMwPath);
           break;
         }
@@ -1449,7 +1540,7 @@ async function scanRoutes(rootDir, patterns, dist) {
         const mwPaths = collectMiddlewarePaths(normalizedFile, rootDir);
         middlewareBundle = await loadMergedMiddlewares(mwPaths);
       }
-      const source = await fs2.promises.readFile(absPath, "utf8").catch(() => "");
+      const source = await fs3.promises.readFile(absPath, "utf8").catch(() => "");
       const exportNames = extractExportsFromSource(source);
       const methods = HTTP_METHODS.filter((m) => exportNames.has(m));
       for (const method of methods) {
@@ -1502,34 +1593,24 @@ function sortRoutes(routes) {
 }
 
 // src/cli/generateSchemaFiles.ts
-import path6 from "path";
-
-// src/utils/atomicWrite.ts
-import path3 from "path";
-import fs3 from "fs";
-async function atomicWriteFile(outputPath, content) {
-  await fs3.promises.mkdir(path3.dirname(outputPath), { recursive: true });
-  const tmp = `${outputPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  await fs3.promises.writeFile(tmp, content, "utf-8");
-  await fs3.promises.rename(tmp, outputPath);
-}
+import path7 from "path";
 
 // src/ast/createProgram.ts
 import ts2 from "typescript";
 import fs4 from "fs";
-import path4 from "path";
+import path3 from "path";
 var programCache = /* @__PURE__ */ new Map();
 var tsConfigCache = /* @__PURE__ */ new Map();
 function findTsConfig(filePath) {
-  let dir = path4.dirname(filePath);
-  const root = path4.parse(dir).root;
+  let dir = path3.dirname(filePath);
+  const root = path3.parse(dir).root;
   while (true) {
-    const candidate = path4.join(dir, "tsconfig.json");
+    const candidate = path3.join(dir, "tsconfig.json");
     if (fs4.existsSync(candidate)) {
       return candidate;
     }
     if (dir === root) return null;
-    const parent = path4.dirname(dir);
+    const parent = path3.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -1545,7 +1626,7 @@ function parseTsConfig(tsconfigPath) {
       return result;
     }
     const config = configFile.config ?? {};
-    const basePath = path4.dirname(tsconfigPath);
+    const basePath = path3.dirname(tsconfigPath);
     const parsed = ts2.parseJsonConfigFileContent(
       config,
       ts2.sys,
@@ -2545,11 +2626,11 @@ function extractSchema(typeNode, sourceFile) {
 }
 
 // src/cli/collectRouteSchemaSources.ts
-import path5 from "path";
+import path4 from "path";
 function collectRouteSchemaSources(routes, rootDir) {
   const methodsByFile = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    const filePath = rootDir ? path5.resolve(rootDir, route.filePath) : route.filePath;
+    const filePath = rootDir ? path4.resolve(rootDir, route.filePath) : route.filePath;
     let entry = methodsByFile.get(filePath);
     if (!entry) {
       entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
@@ -2893,6 +2974,63 @@ function generateZodSchemaSourceParts(typeInfo, resolveType, exportName, coerce
   return { namedTypeDeclarations, entryDeclaration };
 }
 
+// src/cli/generateZodArtifacts.ts
+import path6 from "path";
+import { existsSync } from "fs";
+
+// src/utils/atomicWrite.ts
+import path5 from "path";
+import fs5 from "fs";
+async function atomicWriteFile(outputPath, content) {
+  await fs5.promises.mkdir(path5.dirname(outputPath), { recursive: true });
+  const tmp = `${outputPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  await fs5.promises.writeFile(tmp, content, "utf-8");
+  await fs5.promises.rename(tmp, outputPath);
+}
+
+// src/cli/generateZodArtifacts.ts
+async function generateZodArtifacts(sources, options) {
+  const { generateFileSource, resolversByFile, rootDir, dist } = options;
+  if (sources.length === 0) return;
+  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 = path6.relative(rootDir, filePath).replace(/\\/g, "/");
+    const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
+    const resolver = resolversByFile.get(filePath);
+    let relForDir = relFile;
+    if (relForDir.startsWith("src/")) {
+      relForDir = relForDir.slice(4);
+    }
+    const dirIdx = relForDir.lastIndexOf("/");
+    const zodRelDir = dirIdx >= 0 ? relForDir.slice(0, dirIdx) : "";
+    const source = generateFileSource(
+      fileSources,
+      (name) => resolver?.resolve(name)?.runtimeType,
+      getHelpersImportPath(zodRelDir)
+    );
+    fileEntries.push({ outputPath, source });
+  }
+  const allSourceCode = fileEntries.map((e) => e.source).join("\n");
+  if (usesCoerceHelpers(allSourceCode)) {
+    const helpersPath = path6.resolve(rootDir, dist, HELPERS_FILENAME);
+    if (!existsSync(helpersPath)) {
+      await atomicWriteFile(helpersPath, generateHelpersFileSource());
+    }
+  }
+  await Promise.all(
+    fileEntries.map(({ outputPath, source }) => atomicWriteFile(outputPath, source))
+  );
+}
+
 // src/cli/generateSchemaFiles.ts
 function getSchemaOutputPath(sourceFile, dist, rootDir) {
   let rel = sourceFile.replace(/\\/g, "/");
@@ -2901,7 +3039,7 @@ function getSchemaOutputPath(sourceFile, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path6.resolve(rootDir, dist, relDir, "zod.js");
+  return path7.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getRuntimeSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -2912,7 +3050,7 @@ function getRuntimeSchemaPath(filePath, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path6.resolve(rootDir, dist, relDir, "zod.js");
+  return path7.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -2960,60 +3098,27 @@ function generateSchemaFileSource(sources, resolveType, helpersImportPath) {
 async function generateSchemaFiles(routes, rootDir, dist) {
   if (routes.length === 0) return;
   const { sources, resolversByFile } = 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 = path6.relative(rootDir, filePath).replace(/\\/g, "/");
-    const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
-    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 resolver = resolversByFile.get(filePath);
-    const source = generateSchemaFileSource(
-      fileSources,
-      (name) => resolver?.resolve(name)?.runtimeType,
-      helpersImportPath
-    );
-    fileEntries.push({ outputPath, source });
-  }
-  const allSourceCode = fileEntries.map((e) => e.source).join("\n");
-  if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path6.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 atomicWriteFile(outputPath, source);
+  await generateZodArtifacts(sources, {
+    generateFileSource: generateSchemaFileSource,
+    resolversByFile,
+    rootDir,
+    dist
+  });
 }
 
 // src/cli/compileOnDemand.ts
-import path11 from "path";
-import fs9 from "fs";
+import path12 from "path";
+import fs10 from "fs";
 
 // src/cli/compileSourceFiles.ts
-import path9 from "path";
-import fs7 from "fs";
+import path10 from "path";
+import fs8 from "fs";
 import fg2 from "fast-glob";
 
 // src/cli/aliasPlugin.ts
 import ts7 from "typescript";
-import path8 from "path";
-import fs6 from "fs";
+import path9 from "path";
+import fs7 from "fs";
 
 // src/utils/resolveAlias.ts
 function resolveAlias(specifier, config) {
@@ -3040,15 +3145,15 @@ function resolveAlias(specifier, config) {
 
 // src/utils/readTsconfig.ts
 import ts6 from "typescript";
-import path7 from "path";
-import fs5 from "fs";
+import path8 from "path";
+import fs6 from "fs";
 var tsconfigCache = /* @__PURE__ */ new Map();
 function readTsconfig(rootDir) {
-  const tsconfigPath = path7.resolve(rootDir, "tsconfig.json");
-  if (!fs5.existsSync(tsconfigPath)) return null;
+  const tsconfigPath = path8.resolve(rootDir, "tsconfig.json");
+  if (!fs6.existsSync(tsconfigPath)) return null;
   let mtimeMs;
   try {
-    mtimeMs = fs5.statSync(tsconfigPath).mtimeMs;
+    mtimeMs = fs6.statSync(tsconfigPath).mtimeMs;
   } catch {
     return null;
   }
@@ -3064,7 +3169,7 @@ function readTsconfig(rootDir) {
   const config = rawPaths ? (() => {
     const paths = {};
     for (const [pattern, targets] of Object.entries(rawPaths)) {
-      paths[pattern] = targets.map((t) => path7.resolve(baseUrl, t));
+      paths[pattern] = targets.map((t) => path8.resolve(baseUrl, t));
     }
     return { baseUrl, paths };
   })() : null;
@@ -3074,26 +3179,26 @@ function readTsconfig(rootDir) {
 
 // src/cli/aliasPlugin.ts
 function toProdImportPath(sourceFile, importer) {
-  const importerDir = path8.dirname(importer);
-  let rel = path8.relative(importerDir, sourceFile);
-  rel = rel.split(path8.sep).join("/");
+  const importerDir = path9.dirname(importer);
+  let rel = path9.relative(importerDir, sourceFile);
+  rel = rel.split(path9.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
 function toStrippedProdImportPath(sourceFile, rootDir) {
-  const appDirAbs = toRealPath(path8.resolve(rootDir, APP_DIR));
+  const appDirAbs = toRealPath(path9.resolve(rootDir, APP_DIR));
   const sourceReal = toRealPath(sourceFile);
-  let rel = path8.relative(appDirAbs, sourceReal);
-  rel = rel.split(path8.sep).join("/");
+  let rel = path9.relative(appDirAbs, sourceReal);
+  rel = rel.split(path9.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
 function toProdImportFromImporter(importer, rootDir, relFromDist) {
-  const importerRel = path8.relative(toRealPath(path8.resolve(rootDir)), toRealPath(importer)).split(path8.sep).join("/");
-  const importerProdDir = path8.posix.dirname(toProdExtension(importerRel));
+  const importerRel = path9.relative(toRealPath(path9.resolve(rootDir)), toRealPath(importer)).split(path9.sep).join("/");
+  const importerProdDir = path9.posix.dirname(toProdExtension(importerRel));
   if (importerProdDir === ".") return relFromDist;
   const target = relFromDist.replace(/^\.\//, "");
-  let rel = path8.posix.relative(importerProdDir, target);
+  let rel = path9.posix.relative(importerProdDir, target);
   if (!rel.startsWith(".")) rel = "./" + rel;
   return rel;
 }
@@ -3108,41 +3213,41 @@ var INDEX_EXTS = [
   "/index.cjs"
 ];
 function resolveRelativeSpecifier(importer, specifier) {
-  const importerDir = path8.dirname(importer);
-  const base = path8.resolve(importerDir, specifier);
+  const importerDir = path9.dirname(importer);
+  const base = path9.resolve(importerDir, specifier);
   if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
-    if (fs6.existsSync(base)) return base;
+    if (fs7.existsSync(base)) return base;
     if (base.endsWith(".js")) {
       for (const ext of [".ts", ".tsx", ".jsx"]) {
         const file = base.slice(0, -3) + ext;
-        if (fs6.existsSync(file)) return file;
+        if (fs7.existsSync(file)) return file;
       }
     }
     return null;
   }
   if (/\.(ts|tsx|jsx)$/.test(specifier)) {
-    return fs6.existsSync(base) ? base : null;
+    return fs7.existsSync(base) ? base : null;
   }
   for (const ext of SOURCE_EXTS) {
     const file = base + ext;
-    if (fs6.existsSync(file)) return file;
+    if (fs7.existsSync(file)) return file;
   }
   for (const indexExt of INDEX_EXTS) {
     const file = base + indexExt;
-    if (fs6.existsSync(file)) return file;
+    if (fs7.existsSync(file)) return file;
   }
   return null;
 }
 function createAliasPlugin(config, options) {
-  const appDirAbs = options?.rootDir ? toRealPath(path8.resolve(options.rootDir, APP_DIR)) : null;
+  const appDirAbs = options?.rootDir ? toRealPath(path9.resolve(options.rootDir, APP_DIR)) : null;
   const probeCandidateFile = (candidate) => {
     for (const ext of SOURCE_EXTS) {
       const file = candidate + ext;
-      if (fs6.existsSync(file)) return file;
+      if (fs7.existsSync(file)) return file;
     }
     for (const indexExt of INDEX_EXTS) {
       const file = candidate + indexExt;
-      if (fs6.existsSync(file)) return file;
+      if (fs7.existsSync(file)) return file;
     }
     return null;
   };
@@ -3152,7 +3257,7 @@ function createAliasPlugin(config, options) {
       build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
         let source;
         try {
-          source = fs6.readFileSync(args.path, "utf8");
+          source = fs7.readFileSync(args.path, "utf8");
         } catch {
           return void 0;
         }
@@ -3277,11 +3382,11 @@ async function compileSourceFiles(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path9.resolve(rootDir, dist);
-  await fs7.promises.mkdir(absDist, { recursive: true });
+  const absDist = path10.resolve(rootDir, dist);
+  await fs8.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path9.resolve(rootDir, APP_DIR);
+  const outbase = path10.resolve(rootDir, APP_DIR);
   const result = await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -3301,10 +3406,10 @@ async function compileSourceFiles(options) {
   if (atomicWrite && result.outputFiles) {
     await Promise.all(
       result.outputFiles.map(async (file) => {
-        await fs7.promises.mkdir(path9.dirname(file.path), { recursive: true });
+        await fs8.promises.mkdir(path10.dirname(file.path), { recursive: true });
         const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-        await fs7.promises.writeFile(tmp, file.contents);
-        await fs7.promises.rename(tmp, file.path);
+        await fs8.promises.writeFile(tmp, file.contents);
+        await fs8.promises.rename(tmp, file.path);
       })
     );
   }
@@ -3317,8 +3422,8 @@ async function compileDevRoutes(options) {
 }
 
 // src/cli/collectImports.ts
-import path10 from "path";
-import fs8 from "fs";
+import path11 from "path";
+import fs9 from "fs";
 var SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
 function extractImportSpecifiers(source) {
   const specifiers = [];
@@ -3330,10 +3435,10 @@ function extractImportSpecifiers(source) {
   return specifiers;
 }
 function resolveSpecifierFromDir(dir, specifier) {
-  return resolveRelativeSpecifier(path10.join(dir, "__faapi_probe__.ts"), specifier);
+  return resolveRelativeSpecifier(path11.join(dir, "__faapi_probe__.ts"), specifier);
 }
 async function collectRelativeImports(entryFiles, rootDir) {
-  const appDirAbs = toRealPath(path10.resolve(rootDir, "src"));
+  const appDirAbs = toRealPath(path11.resolve(rootDir, "src"));
   const tsconfig = readTsconfig(rootDir);
   const visited = /* @__PURE__ */ new Set();
   const insideFiles = /* @__PURE__ */ new Set();
@@ -3343,7 +3448,7 @@ async function collectRelativeImports(entryFiles, rootDir) {
     visited.add(filePath);
     let source;
     try {
-      source = await fs8.promises.readFile(filePath, "utf8");
+      source = await fs9.promises.readFile(filePath, "utf8");
     } catch {
       return;
     }
@@ -3365,7 +3470,7 @@ async function collectRelativeImports(entryFiles, rootDir) {
         resolved = null;
       }
       if (!resolved) continue;
-      if (!isInsideDir(toRealPath(resolved), toRealPath(path10.resolve(rootDir)))) continue;
+      if (!isInsideDir(toRealPath(resolved), toRealPath(path11.resolve(rootDir)))) continue;
       if (isInsideDir(toRealPath(resolved), appDirAbs)) {
         insideFiles.add(resolved);
       } else {
@@ -3386,8 +3491,8 @@ async function collectRelativeImports(entryFiles, rootDir) {
 // src/cli/compileOnDemand.ts
 function isProductFresh(sourceAbsPath, productAbsPath) {
   try {
-    const srcStat = fs9.statSync(sourceAbsPath);
-    const prodStat = fs9.statSync(productAbsPath);
+    const srcStat = fs10.statSync(sourceAbsPath);
+    const prodStat = fs10.statSync(productAbsPath);
     return prodStat.mtimeMs >= srcStat.mtimeMs;
   } catch {
     return false;
@@ -3407,14 +3512,13 @@ var state = createDevOnDemandState();
 async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   const inFlight2 = state.inFlightCompilations.get(sourceAbsPath);
   if (inFlight2) {
-    await inFlight2.catch(() => {
-    });
+    await inFlight2;
     return false;
   }
   if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
-  if (!fs9.existsSync(sourceAbsPath)) {
+  if (!fs10.existsSync(sourceAbsPath)) {
     return false;
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
@@ -3464,25 +3568,24 @@ async function ensureMiddlewaresCompiled(middlewarePaths, rootDir) {
   }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
-  const rel = path11.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const rel = path12.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   if (!rel.startsWith("src/")) return null;
   const relWithoutSrc = rel.slice(4);
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
-  return path11.resolve(rootDir, dist, jsRel);
+  return path12.resolve(rootDir, dist, jsRel);
 }
 async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
   const inFlight2 = state.inFlightSchemaGenerations.get(schemaPath);
   if (inFlight2) {
-    await inFlight2.catch(() => {
-    });
+    await inFlight2;
     return false;
   }
   if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
-  const prodAbsPath = path11.resolve(rootDir, routeFilePath);
+  const prodAbsPath = path12.resolve(rootDir, routeFilePath);
   const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
-  if (!fs9.existsSync(sourceAbsPath)) {
+  if (!fs10.existsSync(sourceAbsPath)) {
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
@@ -3493,7 +3596,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (fileRoutes.length === 0) {
     return false;
   }
-  const sourceRelPath = path11.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRelPath = path12.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const generatePromise = (async () => {
     await generateSchemaFiles(sourceRoutes, rootDir, dist);
@@ -3511,19 +3614,19 @@ var sourcePathCache = /* @__PURE__ */ new Map();
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   const cached = sourcePathCache.get(prodAbsPath);
   if (cached) return cached;
-  const rel = path11.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  const rel = path12.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 = path11.resolve(rootDir, tsRel);
+  const tsAbs = path12.resolve(rootDir, tsRel);
   let result;
-  if (fs9.existsSync(tsAbs)) {
+  if (fs10.existsSync(tsAbs)) {
     result = tsAbs;
   } else {
-    result = path11.resolve(rootDir, srcRel);
+    result = path12.resolve(rootDir, srcRel);
   }
   sourcePathCache.set(prodAbsPath, result);
   return result;
@@ -3576,9 +3679,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue);
-    const path15 = issue.path.map(String).join(".") || "";
+    const path16 = issue.path.map(String).join(".") || "";
     return {
-      path: path15,
+      path: path16,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -3628,7 +3731,7 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable2 } from "stream";
-import path13 from "path";
+import path14 from "path";
 
 // src/router/matchRoute.ts
 var httpIndexCache = /* @__PURE__ */ new WeakMap();
@@ -3670,65 +3773,72 @@ function getWsIndex(routes) {
   wsIndexCache.set(routes, index);
   return index;
 }
-function matchRoute(routes, method, path15) {
+function matchRoute(routes, method, path16) {
   const index = getHttpIndex(routes);
   const upper = method.toUpperCase();
-  const hit = matchByMethod(index, upper, path15);
+  const hit = matchByMethod(index, upper, path16);
   if (hit) return hit;
   if (upper === "HEAD") {
-    return matchByMethod(index, "GET", path15);
+    return matchByMethod(index, "GET", path16);
   }
   return null;
 }
-function matchByMethod(index, method, path15) {
-  const staticHit = index.static.get(`${method}|${path15}`);
+function matchByMethod(index, method, path16) {
+  const staticHit = index.static.get(`${method}|${path16}`);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
+  if (index.dynamics.length === 0) {
+    return null;
+  }
+  const pathSegments = path16.split("/").filter(Boolean);
   for (const entry of index.dynamics) {
     const route = entry.route;
     if (route.method !== method) {
       continue;
     }
-    const params = matchSegments(entry.segments, path15, route.paramNames, route.isCatchAll);
+    const params = matchSegments(entry.segments, pathSegments, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path15) {
+function matchWsRoute(wsRoutes, path16) {
   const index = getWsIndex(wsRoutes);
-  const staticHit = index.static.get(path15);
+  const staticHit = index.static.get(path16);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   for (const route of index.dynamics) {
-    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path16, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function findAllowedMethods(routes, path15) {
+function findAllowedMethods(routes, path16) {
   const index = getHttpIndex(routes);
   const methods = /* @__PURE__ */ new Set();
-  const staticMethods = index.methodsByStaticPath.get(path15);
+  const staticMethods = index.methodsByStaticPath.get(path16);
   if (staticMethods) {
     for (const method of staticMethods) {
       methods.add(method);
     }
   }
-  for (const entry of index.dynamics) {
-    const params = matchSegments(
-      entry.segments,
-      path15,
-      entry.route.paramNames,
-      entry.route.isCatchAll
-    );
-    if (params !== null) {
-      methods.add(entry.route.method);
+  if (index.dynamics.length > 0) {
+    const pathSegments = path16.split("/").filter(Boolean);
+    for (const entry of index.dynamics) {
+      const params = matchSegments(
+        entry.segments,
+        pathSegments,
+        entry.route.paramNames,
+        entry.route.isCatchAll
+      );
+      if (params !== null) {
+        methods.add(entry.route.method);
+      }
     }
   }
   if (methods.has("GET")) {
@@ -3736,11 +3846,15 @@ function findAllowedMethods(routes, path15) {
   }
   return Array.from(methods);
 }
-function matchDynamicPath(pattern, path15, paramNames, isCatchAll) {
-  return matchSegments(pattern.split("/").filter(Boolean), path15, paramNames, isCatchAll);
+function matchDynamicPath(pattern, path16, paramNames, isCatchAll) {
+  return matchSegments(
+    pattern.split("/").filter(Boolean),
+    path16.split("/").filter(Boolean),
+    paramNames,
+    isCatchAll
+  );
 }
-function matchSegments(patternSegments, path15, paramNames, isCatchAll) {
-  const pathSegments = path15.split("/").filter(Boolean);
+function matchSegments(patternSegments, pathSegments, paramNames, isCatchAll) {
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -3956,6 +4070,20 @@ async function sendNodeResponse(response, res) {
     }
   }
   if (response.body) {
+    if (hasBufferedBody(response)) {
+      const buffer = await readBufferedBody(response.body);
+      await new Promise((resolve) => {
+        res.on("close", () => {
+          if (!res.writableEnded) res.destroy();
+        });
+        if (res.destroyed) {
+          resolve();
+          return;
+        }
+        res.end(buffer, () => resolve());
+      });
+      return;
+    }
     const nodeStream = Readable.fromWeb(response.body);
     await new Promise((resolve, reject) => {
       nodeStream.on("error", reject);
@@ -3974,6 +4102,25 @@ async function sendNodeResponse(response, res) {
   }
   res.end();
 }
+async function readBufferedBody(body) {
+  const reader = body.getReader();
+  const chunks = [];
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  if (chunks.length === 0) return new Uint8Array(0);
+  if (chunks.length === 1) return chunks[0];
+  return Buffer.concat(chunks);
+}
 
 // src/utils/getClientIp.ts
 function getClientIp(req, trustedProxy = false) {
@@ -3994,6 +4141,20 @@ function getClientIp(req, trustedProxy = false) {
   return "";
 }
 
+// src/middleware/mergeVary.ts
+function mergeVary(meta, value) {
+  const existing = meta.headers["Vary"] ?? meta.headers["vary"];
+  if (!existing) {
+    meta.headers["Vary"] = value;
+    return;
+  }
+  const segments = existing.split(",").map((s) => s.trim().toLowerCase());
+  if (!segments.includes(value.toLowerCase())) {
+    const key = meta.headers["Vary"] !== void 0 ? "Vary" : "vary";
+    meta.headers[key] = `${existing}, ${value}`;
+  }
+}
+
 // src/middleware/cors.ts
 var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 function cors(options = {}) {
@@ -4006,6 +4167,7 @@ function cors(options = {}) {
     maxAge
   } = options;
   return async (ctx, next) => {
+    const meta = ctx.meta;
     const reqOrigin = ctx.headers.get("origin");
     if (!reqOrigin) {
       await next();
@@ -4020,14 +4182,7 @@ function cors(options = {}) {
       allowOrigin = origin.includes(reqOrigin) ? reqOrigin : null;
     }
     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");
-      }
+      mergeVary(meta, "Origin");
     }
     if (!allowOrigin) {
       await next();
@@ -4178,17 +4333,6 @@ async function compressBody(encoding, body) {
       return deflateAsync(buf);
   }
 }
-function mergeVary(meta, value) {
-  const existing = meta.headers["Vary"] ?? meta.headers["vary"];
-  if (!existing) {
-    meta.headers["Vary"] = value;
-    return;
-  }
-  if (!existing.toLowerCase().includes(value.toLowerCase())) {
-    const key = meta.headers["Vary"] !== void 0 ? "Vary" : "vary";
-    meta.headers[key] = `${existing}, ${value}`;
-  }
-}
 function compression(options = {}) {
   const threshold = options.threshold ?? DEFAULT_THRESHOLD;
   return async (ctx, next) => {
@@ -4338,9 +4482,9 @@ function logger(options = {}) {
 }
 
 // src/server/handleWsUpgrade.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path12 from "path";
+import path13 from "path";
 
 // src/server/serverUtils.ts
 function nodeHttpToWebHeaders(req) {
@@ -4359,13 +4503,15 @@ function buildErrorResponse(err, config) {
   try {
     return formatErrorResponse(err, config);
   } catch {
-    return new Response(
+    const fallback = new Response(
       JSON.stringify({ error: { code: "INTERNAL_ERROR", message: "Internal Server Error" } }),
       {
         status: 500,
         headers: { "Content-Type": "application/json" }
       }
     );
+    markBufferedBody(fallback);
+    return fallback;
   }
 }
 
@@ -4396,7 +4542,7 @@ async function loadWsHandler(filePath, ctx, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs10.existsSync(sourcePath)) {
+      if (sourcePath && fs11.existsSync(sourcePath)) {
         await ensureCompiled(sourcePath, rootDir, dist);
       }
     }
@@ -4411,27 +4557,47 @@ async function loadWsHandler(filePath, ctx, rootDir) {
 function bindEvents(rawSocket, handlers) {
   if (!handlers) return;
   const ws = wrapWsSocket(rawSocket);
+  const guard = (event, fn) => {
+    try {
+      fn();
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (handlers.onError) {
+        try {
+          handlers.onError(ws, error);
+        } catch (hookErr) {
+          console.error(`[faapi] WS onError \u56DE\u8C03\u629B\u9519 (after ${event}):`, hookErr);
+        }
+      } else {
+        console.error(`[faapi] WS ${event} \u56DE\u8C03\u629B\u9519:`, error);
+      }
+    }
+  };
   if (handlers.onOpen) {
     if (rawSocket.readyState === WebSocket.OPEN) {
-      handlers.onOpen(ws);
+      guard("onOpen", () => handlers.onOpen(ws));
     } else {
-      rawSocket.once("open", () => handlers.onOpen(ws));
+      rawSocket.once("open", () => guard("onOpen", () => handlers.onOpen(ws)));
     }
   }
   if (handlers.onMessage) {
     rawSocket.on("message", (data, isBinary) => {
       const buf = toWsBuffer(data);
-      handlers.onMessage(ws, isBinary ? buf : buf.toString("utf8"));
+      guard("onMessage", () => handlers.onMessage(ws, isBinary ? buf : buf.toString("utf8")));
     });
   }
   if (handlers.onClose) {
     rawSocket.on("close", (code, reason) => {
-      handlers.onClose(ws, code, reason.toString("utf8"));
+      guard("onClose", () => handlers.onClose(ws, code, reason.toString("utf8")));
     });
   }
   if (handlers.onError) {
     rawSocket.on("error", (err) => {
-      handlers.onError(ws, err);
+      try {
+        handlers.onError(ws, err);
+      } catch (hookErr) {
+        console.error("[faapi] WS onError \u56DE\u8C03\u629B\u9519 (after onError):", hookErr);
+      }
     });
   }
 }
@@ -4510,7 +4676,7 @@ function attachWebSocket(options) {
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path12.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path13.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -4715,9 +4881,17 @@ function createServer(options) {
       bodyLimit,
       trustedProxy,
       registries
-    ).catch(() => {
-      res.statusCode = 500;
-      res.end();
+    ).catch((err) => {
+      console.error("[faapi] Request pipeline failed after error response attempt:", err);
+      try {
+        if (!res.headersSent) {
+          res.statusCode = 500;
+          res.end();
+        } else if (!res.writableEnded) {
+          res.end();
+        }
+      } catch {
+      }
     });
   });
   attachWebSocket({
@@ -4760,13 +4934,14 @@ function getRoutePaths(route, rootDir, dist) {
   let cached = routePathCache.get(route);
   if (!cached) {
     cached = {
-      absFilePath: path13.resolve(rootDir, route.filePath),
+      absFilePath: path14.resolve(rootDir, route.filePath),
       schemaPath: getRuntimeSchemaPath(route.filePath, dist, rootDir)
     };
     routePathCache.set(route, cached);
   }
   return cached;
 }
+var mergedInjectorsCache = /* @__PURE__ */ new WeakMap();
 function createRoutePipeline(opts) {
   const { routes, method, urlPath, url, ctx, request, rootDir, dist, globalInjectors } = opts;
   return async () => {
@@ -4799,7 +4974,15 @@ function createRoutePipeline(opts) {
         route.injectors = {};
       }
     }
-    const mergedInjectors = globalInjectors ? { ...globalInjectors, ...route.injectors } : route.injectors;
+    let mergedInjectors = route.injectors;
+    if (globalInjectors) {
+      let merged = mergedInjectorsCache.get(route);
+      if (!merged) {
+        merged = { ...globalInjectors, ...route.injectors };
+        mergedInjectorsCache.set(route, merged);
+      }
+      mergedInjectors = merged;
+    }
     return await invokeHandler(routeModule.handler, ctx, body, route.middlewares, mergedInjectors);
   };
 }
@@ -4849,6 +5032,10 @@ async function handleRequest(routes, rootDir, dist, req, res, outerMiddlewares,
     await sendSuccessResponse(response, res);
   } catch (err) {
     if (res.destroyed || res.writableEnded) return;
+    if (err instanceof PayloadTooLargeError) {
+      res.setHeader("Connection", "close");
+      res.once("finish", () => req.destroy());
+    }
     await sendErrorResponse(err, meta, res, onError, ctx);
   }
 }
@@ -4871,7 +5058,7 @@ async function createTestServer(options) {
   } = options;
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns);
   const sorted = sortRoutes(routes);
-  const schemaDist = dist ? path14.isAbsolute(dist) ? dist : path14.resolve(rootDir, dist) : await fs11.mkdtemp(path14.join(os.tmpdir(), "faapi-test-schema-"));
+  const schemaDist = dist ? path15.isAbsolute(dist) ? dist : path15.resolve(rootDir, dist) : await fs12.mkdtemp(path15.join(os.tmpdir(), "faapi-test-schema-"));
   await generateSchemaFiles(sorted, rootDir, schemaDist);
   const { server } = createServer({
     routes: sorted,
@@ -4903,7 +5090,7 @@ async function createTestServer(options) {
       await new Promise((resolve) => {
         server.close(() => resolve());
       });
-      await fs11.rm(schemaDist, { recursive: true, force: true }).catch(() => {
+      await fs12.rm(schemaDist, { recursive: true, force: true }).catch(() => {
       });
       invalidateSchemaCache();
     }