@faapi/faapi 6.19.0 → 6.21.0

package/dist/testing.js

@@ -154,17 +154,24 @@ function encodeSseEvent(event) {
   out += "\n";
   return out;
 }
-function createSseWriter() {
+function createSseWriter(options = {}) {
+  const { onFirstWrite } = options;
   const encoder = new TextEncoder();
   let controller = null;
   let closed = false;
   let aborted = false;
+  let firstWriteTriggered = false;
   let drainWaiters = [];
   const resolveDrainWaiters = () => {
     const waiters = drainWaiters;
     drainWaiters = [];
     for (const resolve of waiters) resolve();
   };
+  const triggerFirstWrite = () => {
+    if (firstWriteTriggered) return;
+    firstWriteTriggered = true;
+    onFirstWrite?.(response);
+  };
   const stream = new ReadableStream(
     {
       start(c) {
@@ -198,11 +205,13 @@ function createSseWriter() {
       if (closed || !controller) return;
       const text = encodeSseEvent(event);
       controller.enqueue(encoder.encode(text));
+      triggerFirstWrite();
     },
     sendRaw(chunk) {
       if (closed || !controller) return;
       const bytes = typeof chunk === "string" ? encoder.encode(chunk) : chunk;
       controller.enqueue(bytes);
+      triggerFirstWrite();
     },
     sendError(error) {
       if (closed || !controller) return;
@@ -210,6 +219,7 @@ function createSseWriter() {
       const text = encodeSseEvent({ event: "error", data: message });
       try {
         controller.enqueue(encoder.encode(text));
+        triggerFirstWrite();
       } finally {
         writer.close();
       }
@@ -497,6 +507,26 @@ function createLogger(scope, options) {
   return makeLogger(void 0);
 }
 
+// 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];
+    if (existing === void 0) {
+      result[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      result[key] = [existing, value];
+    }
+  }
+  queryCache.set(params, result);
+  return result;
+}
+
 // src/runtime/createContext.ts
 function resolveRequestId(request) {
   const header = request.headers.get("x-request-id");
@@ -546,7 +576,11 @@ function createContextFromUrl(request, url, params, config = {}, ip = "", regist
     log,
     request,
     params,
-    query: url.searchParams,
+    rawParams: params,
+    // ctx.query 为对象口径（createContext 挂原始 string 值对象；handler 声明
+    // query 类型时管线校验后替换为转换值）。原始 URLSearchParams 恒在 rawQuery。
+    query: queryToObject(url.searchParams),
+    rawQuery: url.searchParams,
     headers: request.headers,
     method: request.method,
     path: url.pathname,
@@ -594,13 +628,19 @@ function createContextFromUrl(request, url, params, config = {}, ip = "", regist
     /**
      * 创建 SSE writer，用于流式推送事件
      *
-     * handler 调用此方法后，通过返回的 writer 推送事件，框架自动把 writer.response
-     * 作为 HTTP 响应（Content-Type: text/event-stream）。
+     * handler 调用此方法后，通过返回的 writer 推送事件。HTTP 服务场景下首次
+     * 写入（send/sendRaw/sendError）即触发 server 层提前接管钩子，把 writer.response
+     * 接入底层连接——流式期间字节即产即达（见 createServer.md「SSE 提前接管」）。
+     * 无钩子场景（app.inject / 测试直调 invokeHandler）回落为 handler 返回后交出。
      *
      * 与 ctx.json / ctx.html 互斥：一个 handler 只能用一种响应方式。
      */
     sse() {
-      const writer = createSseWriter();
+      const writer = createSseWriter({
+        onFirstWrite: (response) => {
+          ctx.__earlyRespond?.(response);
+        }
+      });
       const ctxWithSse = ctx;
       ctxWithSse.__sseResponse = writer.response;
       ctxWithSse.__sseWriter = writer;
@@ -825,8 +865,16 @@ var PARAM_TYPE_MAP = {
   // Phase 2.3
   tasks: "tasks",
   // 任务子系统：TaskClient（入队/查询）
-  log: "log"
+  log: "log",
   // 请求级日志器（ctx.log 同一实例：scope http，自动带 requestId 等字段）
+  // raw 系：恒原始输入（无 schema、无校验、管线永不转换），与 query/params/body
+  // 的「校验转换后」口径二分互补
+  rawQuery: "rawQuery",
+  // URLSearchParams（原始查询参数）
+  rawParams: "rawParams",
+  // Record<string, string>（URL 原始路径段）
+  rawBody: "rawBody"
+  // string | undefined（请求体原始文本）
 };
 var injectionCache = /* @__PURE__ */ new WeakMap();
 function resolveInjection(fn) {
@@ -904,26 +952,6 @@ 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];
-    if (existing === void 0) {
-      result[key] = value;
-    } else if (Array.isArray(existing)) {
-      existing.push(value);
-    } else {
-      result[key] = [existing, value];
-    }
-  }
-  queryCache.set(params, result);
-  return result;
-}
-
 // src/task/taskRegistry.ts
 function createTaskRegistry() {
   let registry = /* @__PURE__ */ new Map();
@@ -1108,12 +1136,17 @@ function getAgentHandle(ctx) {
 // src/injection/injectParams.ts
 function getBuiltinInjectionValue(type, ctx, body) {
   switch (type) {
-    case "query": {
-      const validated = ctx.__validatedQuery;
-      return validated ?? queryToObject(ctx.query);
-    }
+    case "query":
+      return ctx.query;
     case "params":
       return ctx.params;
+    // raw 系：恒原始，管线永不覆盖（ctx 字段即注入值）
+    case "rawQuery":
+      return ctx.rawQuery;
+    case "rawParams":
+      return ctx.rawParams;
+    case "rawBody":
+      return ctx.rawBody;
     case "headers":
       return ctx.headers;
     case "context":
@@ -2629,7 +2662,19 @@ function extractSchema(typeNode, sourceFile) {
 
 // src/cli/collectRouteSchemaSources.ts
 import path4 from "path";
-function collectRouteSchemaSources(routes, rootDir) {
+import ts6 from "typescript";
+function findExportedTypeName(sourceFile, name) {
+  for (const statement of sourceFile.statements) {
+    const modifiers = ts6.canHaveModifiers(statement) ? ts6.getModifiers(statement) : void 0;
+    const isExported = modifiers?.some((m) => m.kind === ts6.SyntaxKind.ExportKeyword);
+    if (!isExported) continue;
+    if ((ts6.isInterfaceDeclaration(statement) || ts6.isTypeAliasDeclaration(statement)) && statement.name?.text === name) {
+      return true;
+    }
+  }
+  return false;
+}
+function collectRouteSchemaSources(routes, rootDir, wsRoutes) {
   const methodsByFile = /* @__PURE__ */ new Map();
   for (const route of routes) {
     const filePath = rootDir ? path4.resolve(rootDir, route.filePath) : route.filePath;
@@ -2640,9 +2685,17 @@ function collectRouteSchemaSources(routes, rootDir) {
     }
     entry.methods.add(route.method);
   }
-  const programByFile = createPrograms([...methodsByFile.keys()]);
+  const wsFiles = [];
+  for (const wsRoute of wsRoutes ?? []) {
+    wsFiles.push({
+      filePath: rootDir ? path4.resolve(rootDir, wsRoute.filePath) : wsRoute.filePath,
+      urlPath: wsRoute.urlPath
+    });
+  }
+  const allFiles = [.../* @__PURE__ */ new Set([...methodsByFile.keys(), ...wsFiles.map((f) => f.filePath)])];
+  const programByFile = createPrograms(allFiles);
   const resolversByFile = /* @__PURE__ */ new Map();
-  for (const filePath of methodsByFile.keys()) {
+  for (const filePath of allFiles) {
     resolversByFile.set(filePath, createLazyTypeResolver(programByFile.get(filePath), filePath));
   }
   const sources = [];
@@ -2674,6 +2727,50 @@ function collectRouteSchemaSources(routes, rootDir) {
           typeInfo: resolver.resolve(paramsArg.typeName) ?? null
         });
       }
+      if (inputType === "body") {
+        const queryArg = meta.params.find((p) => p.type === "query");
+        if (queryArg?.typeName) {
+          sources.push({
+            urlPath: entry.urlPath,
+            filePath,
+            schemaName: getSchemaName(method, "query"),
+            typeInfo: resolver.resolve(queryArg.typeName) ?? null
+          });
+        }
+      } else if (hasBody(method)) {
+        const bodyArg = meta.params.find((p) => p.type === "body") ?? meta.params.find((p) => p.type === "form");
+        if (bodyArg?.typeName) {
+          sources.push({
+            urlPath: entry.urlPath,
+            filePath,
+            schemaName: getSchemaName(method, "body"),
+            typeInfo: resolver.resolve(bodyArg.typeName) ?? null,
+            coerce: bodyArg.type === "form" || void 0
+          });
+        }
+      }
+    }
+  }
+  for (const wsFile of wsFiles) {
+    const program = programByFile.get(wsFile.filePath);
+    const sourceFile = program?.getSourceFile(wsFile.filePath);
+    if (!sourceFile) continue;
+    const resolver = resolversByFile.get(wsFile.filePath);
+    if (findExportedTypeName(sourceFile, "Query")) {
+      sources.push({
+        urlPath: wsFile.urlPath,
+        filePath: wsFile.filePath,
+        schemaName: getSchemaName("WS", "query"),
+        typeInfo: resolver.resolve("Query") ?? null
+      });
+    }
+    if (findExportedTypeName(sourceFile, "Params")) {
+      sources.push({
+        urlPath: wsFile.urlPath,
+        filePath: wsFile.filePath,
+        schemaName: getSchemaName("WS", "params"),
+        typeInfo: resolver.resolve("Params") ?? null
+      });
     }
   }
   return { sources, resolversByFile };
@@ -3106,9 +3203,9 @@ function generateSchemaFileSource(sources, resolveType, helpersImportPath) {
   lines.push(...schemaBlocks);
   return lines.join("\n").replace(/\n+$/, "\n");
 }
-async function generateSchemaFiles(routes, rootDir, dist) {
-  if (routes.length === 0) return;
-  const { sources, resolversByFile } = collectRouteSchemaSources(routes, rootDir);
+async function generateSchemaFiles(routes, rootDir, dist, wsRoutes) {
+  if (routes.length === 0 && (wsRoutes?.length ?? 0) === 0) return;
+  const { sources, resolversByFile } = collectRouteSchemaSources(routes, rootDir, wsRoutes);
   await generateZodArtifacts(sources, {
     generateFileSource: generateSchemaFileSource,
     resolversByFile,
@@ -3127,7 +3224,7 @@ import fs8 from "fs";
 import fg2 from "fast-glob";
 
 // src/cli/aliasPlugin.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 import path9 from "path";
 import fs7 from "fs";
 
@@ -3155,7 +3252,7 @@ function resolveAlias(specifier, config) {
 }
 
 // src/utils/readTsconfig.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 import path8 from "path";
 import fs6 from "fs";
 var tsconfigCache = /* @__PURE__ */ new Map();
@@ -3172,9 +3269,9 @@ function readTsconfig(rootDir) {
   if (cached && cached.mtimeMs === mtimeMs) {
     return cached.config;
   }
-  const configFile = ts6.readConfigFile(tsconfigPath, ts6.sys.readFile);
+  const configFile = ts7.readConfigFile(tsconfigPath, ts7.sys.readFile);
   if (configFile.error || !configFile.config) return null;
-  const parsed = ts6.parseJsonConfigFileContent(configFile.config, ts6.sys, rootDir);
+  const parsed = ts7.parseJsonConfigFileContent(configFile.config, ts7.sys, rootDir);
   const baseUrl = parsed.options.baseUrl ?? rootDir;
   const rawPaths = parsed.options.paths;
   const config = rawPaths ? (() => {
@@ -3274,23 +3371,23 @@ function createAliasPlugin(config, options) {
         }
         const importer = args.path;
         const importerOutsideAppDir = appDirAbs ? !isInsideDir(importer, appDirAbs) : false;
-        const sourceFile = ts7.createSourceFile(importer, source, ts7.ScriptTarget.Latest, false);
+        const sourceFile = ts8.createSourceFile(importer, source, ts8.ScriptTarget.Latest, false);
         const literals = [];
         const visit = (node) => {
-          if (ts7.isImportDeclaration(node)) {
+          if (ts8.isImportDeclaration(node)) {
             if (!node.importClause?.isTypeOnly && node.moduleSpecifier) {
-              if (ts7.isStringLiteral(node.moduleSpecifier)) literals.push(node.moduleSpecifier);
+              if (ts8.isStringLiteral(node.moduleSpecifier)) literals.push(node.moduleSpecifier);
             }
-          } else if (ts7.isExportDeclaration(node)) {
+          } else if (ts8.isExportDeclaration(node)) {
             if (!node.isTypeOnly && node.moduleSpecifier) {
-              if (ts7.isStringLiteral(node.moduleSpecifier)) literals.push(node.moduleSpecifier);
+              if (ts8.isStringLiteral(node.moduleSpecifier)) literals.push(node.moduleSpecifier);
             }
-          } else if (ts7.isCallExpression(node) && node.expression.kind === ts7.SyntaxKind.ImportKeyword && node.arguments[0] && ts7.isStringLiteral(node.arguments[0])) {
+          } else if (ts8.isCallExpression(node) && node.expression.kind === ts8.SyntaxKind.ImportKeyword && node.arguments[0] && ts8.isStringLiteral(node.arguments[0])) {
             literals.push(node.arguments[0]);
           }
-          ts7.forEachChild(node, visit);
+          ts8.forEachChild(node, visit);
         };
-        ts7.forEachChild(sourceFile, visit);
+        ts8.forEachChild(sourceFile, visit);
         const replacements = [];
         const unresolvable = [];
         for (const lit of literals) {
@@ -3585,7 +3682,7 @@ function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
   return path12.resolve(rootDir, dist, jsRel);
 }
-async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
+async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist, wsRoutes) {
   const inFlight2 = state.inFlightSchemaGenerations.get(schemaPath);
   if (inFlight2) {
     await inFlight2;
@@ -3604,13 +3701,15 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
     return false;
   }
   const fileRoutes = routes.filter((r) => r.filePath === routeFilePath);
-  if (fileRoutes.length === 0) {
+  const fileWsRoutes = (wsRoutes ?? []).filter((r) => r.filePath === routeFilePath);
+  if (fileRoutes.length === 0 && fileWsRoutes.length === 0) {
     return false;
   }
   const sourceRelPath = path12.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
+  const sourceWsRoutes = fileWsRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const generatePromise = (async () => {
-    await generateSchemaFiles(sourceRoutes, rootDir, dist);
+    await generateSchemaFiles(sourceRoutes, rootDir, dist, sourceWsRoutes);
     state.generatedSchemas.add(schemaPath);
   })();
   state.inFlightSchemaGenerations.set(schemaPath, generatePromise);
@@ -4008,46 +4107,29 @@ async function parseMultipart(request) {
 async function resolveInputFromUrl(method, request, url) {
   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 (isBlankText(text2)) 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 (isBlankText(text)) {
-      return null;
-    }
-    const result = parseJsonBody(text);
-    if (!result.success) {
-      throw new ValidationError("\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON", [
-        {
-          path: "body",
-          code: "INVALID_FORMAT",
-          expected: "JSON",
-          received: "text",
-          message: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON"
-        }
-      ]);
-    }
-    return result.data;
+    return parseBodyByContentType(request);
   }
-  return queryToObject(url.searchParams);
-}
-function isBlankText(text) {
-  return text.length === 0 || !/\S/.test(text);
+  return { input: queryToObject(url.searchParams) };
 }
-async function resolveBodyForQueryMethod(request) {
+async function parseBodyByContentType(request) {
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.includes("multipart/form-data")) {
+    return { input: await parseMultipart(request) };
+  }
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const text2 = await request.text();
+    if (isBlankText(text2)) return { input: null };
+    const params = new URLSearchParams(text2);
+    const obj = {};
+    for (const [key, value] of params) {
+      obj[key] = value;
+    }
+    return { input: obj, rawBody: text2 };
+  }
   const text = await request.text();
-  if (isBlankText(text)) return void 0;
+  if (isBlankText(text)) {
+    return { input: null };
+  }
   const result = parseJsonBody(text);
   if (!result.success) {
     throw new ValidationError("\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON", [
@@ -4060,7 +4142,13 @@ async function resolveBodyForQueryMethod(request) {
       }
     ]);
   }
-  return result.data;
+  return { input: result.data, rawBody: text };
+}
+function isBlankText(text) {
+  return text.length === 0 || !/\S/.test(text);
+}
+async function resolveBodyForQueryMethod(request) {
+  return parseBodyByContentType(request);
 }
 
 // src/response/sendNodeResponse.ts
@@ -4645,6 +4733,7 @@ function attachWebSocket(options) {
     server,
     routesRef,
     rootDir,
+    dist,
     config,
     globalMiddlewares,
     trustedProxy = false,
@@ -4679,12 +4768,50 @@ function attachWebSocket(options) {
     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 fullUrl = new URL(`http://${host}${req.url ?? "/"}`);
+    const request = new Request(fullUrl.toString(), { method: "GET", headers });
     const ctx = createContext(request, params, config, getClientIp(req, trustedProxy), registries);
     const meta = ctx.meta;
     let upgraded = false;
     const finalHandler = async () => {
+      const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
+      if (fs11.existsSync(schemaPath)) {
+        if (isDevOnDemandEnabled()) {
+          const devDist = getDevDist();
+          if (devDist) {
+            await ensureSchemaGenerated(
+              schemaPath,
+              route.filePath,
+              routesRef.current,
+              rootDir,
+              dist,
+              routesRef.wsCurrent
+            );
+          }
+        }
+        const searchParams = fullUrl.searchParams;
+        const rawQueryObject = queryToObject(searchParams);
+        const paramsResult = await validateInput(schemaPath, "WS", "params", params);
+        if (!paramsResult.valid) {
+          throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", paramsResult.issues);
+        }
+        if (paramsResult.data !== params && typeof paramsResult.data === "object" && paramsResult.data !== null) {
+          ctx.params = {
+            ...params,
+            ...paramsResult.data
+          };
+        }
+        const queryResult = await validateInput(schemaPath, "WS", "query", rawQueryObject);
+        if (!queryResult.valid) {
+          throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", queryResult.issues);
+        }
+        if (queryResult.data !== rawQueryObject && typeof queryResult.data === "object" && queryResult.data !== null) {
+          ctx.query = {
+            ...rawQueryObject,
+            ...queryResult.data
+          };
+        }
+      }
       let handlers;
       try {
         const absoluteFilePath = path13.resolve(rootDir, route.filePath);
@@ -4891,7 +5018,8 @@ function createServer(options) {
       globalInjectors,
       bodyLimit,
       trustedProxy,
-      registries
+      registries,
+      routesRef.wsCurrent
     ).catch((err) => {
       console.error("[faapi] Request pipeline failed after error response attempt:", err);
       try {
@@ -4909,6 +5037,7 @@ function createServer(options) {
     server,
     routesRef,
     rootDir,
+    dist,
     config,
     globalMiddlewares,
     trustedProxy,
@@ -4916,14 +5045,13 @@ function createServer(options) {
   });
   return { server, routesRef };
 }
-function prepareRequest(req, config, bodyLimit, trustedProxy, registries, requestSignal) {
-  const { request, url } = toWebRequest(req, bodyLimit, requestSignal);
+function prepareRequest(req, request, url, config, trustedProxy, registries, preMatched) {
   const method = request.method.toUpperCase();
   const urlPath = url.pathname;
   const ctx = createContextFromUrl(
     request,
     url,
-    {},
+    preMatched?.params ?? {},
     config,
     getClientIp(req, trustedProxy),
     registries
@@ -4954,19 +5082,33 @@ function getRoutePaths(route, rootDir, dist) {
 }
 var mergedInjectorsCache = /* @__PURE__ */ new WeakMap();
 function createRoutePipeline(opts) {
-  const { routes, method, urlPath, url, ctx, request, rootDir, dist, globalInjectors } = opts;
+  const {
+    routes,
+    method,
+    urlPath,
+    url,
+    ctx,
+    request,
+    rootDir,
+    dist,
+    globalInjectors,
+    preMatched,
+    wsRoutes
+  } = opts;
   return async () => {
-    const match = resolveRouteOrThrow(routes, method, urlPath);
-    ctx.params = match.params;
+    const match = preMatched ?? resolveRouteOrThrow(routes, method, urlPath);
     const { route } = match;
     const { absFilePath, schemaPath } = getRoutePaths(route, rootDir, dist);
     const routeModule = await loadRouteModule(absFilePath, route.method, rootDir);
-    const input = await resolveInputFromUrl(route.method, request, url);
+    const { input, rawBody } = await resolveInputFromUrl(route.method, request, url);
+    if (rawBody !== void 0) {
+      ctx.rawBody = rawBody;
+    }
     const inputType = getInputTypeForMethod(route.method);
     if (isDevOnDemandEnabled()) {
       const devDist = getDevDist();
       if (devDist) {
-        await ensureSchemaGenerated(schemaPath, route.filePath, routes, rootDir, dist);
+        await ensureSchemaGenerated(schemaPath, route.filePath, routes, rootDir, dist, wsRoutes);
       }
     }
     const result = await validateInput(schemaPath, route.method, inputType, input);
@@ -4974,7 +5116,7 @@ function createRoutePipeline(opts) {
       throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", result.issues);
     }
     if (inputType === "query" && result.data !== input && typeof result.data === "object" && result.data !== null) {
-      ctx.__validatedQuery = {
+      ctx.query = {
         ...input,
         ...result.data
       };
@@ -4989,7 +5131,36 @@ function createRoutePipeline(opts) {
         ...paramsResult.data
       } : match.params;
     }
-    const body = inputType === "query" && hasBody(route.method) ? await resolveBodyForQueryMethod(request) : hasBody(route.method) ? result.data : void 0;
+    if (inputType === "body") {
+      const rawQuery = queryToObject(url.searchParams);
+      const queryResult = await validateInput(schemaPath, route.method, "query", rawQuery);
+      if (!queryResult.valid) {
+        throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", queryResult.issues);
+      }
+      if (queryResult.data !== rawQuery && typeof queryResult.data === "object" && queryResult.data !== null) {
+        ctx.query = {
+          ...rawQuery,
+          ...queryResult.data
+        };
+      }
+    }
+    let body;
+    if (inputType === "query" && hasBody(route.method)) {
+      const parsed = await resolveBodyForQueryMethod(request);
+      if (parsed.rawBody !== void 0) {
+        ctx.rawBody = parsed.rawBody;
+      }
+      const bodyResult = await validateInput(schemaPath, route.method, "body", parsed.input);
+      if (!bodyResult.valid) {
+        throw new ValidationError("\u53C2\u6570\u6821\u9A8C\u5931\u8D25", bodyResult.issues);
+      }
+      body = bodyResult.data;
+    } else if (hasBody(route.method)) {
+      body = result.data;
+    }
+    if (body !== void 0 && body !== null) {
+      ctx.body = body;
+    }
     if (route.middlewares === void 0 && route.injectors === void 0 && route.middlewarePaths) {
       await ensureMiddlewaresCompiled(route.middlewarePaths, rootDir);
       const bundle = await loadMergedMiddlewares(route.middlewarePaths);
@@ -5025,25 +5196,37 @@ async function sendErrorResponse(err, meta, res, onError, ctx) {
     }
   }
 }
-async function handleRequest(routes, rootDir, dist, req, res, outerMiddlewares, onError, config, globalInjectors, bodyLimit, trustedProxy, registries) {
+async function handleRequest(routes, rootDir, dist, req, res, outerMiddlewares, onError, config, globalInjectors, bodyLimit, trustedProxy, registries, wsRoutes) {
   let meta = { headers: {}, setCookies: [] };
   let ctx;
+  let sseEarlySent = false;
   const abortController = new AbortController();
   res.on("close", () => {
     if (!res.writableEnded) abortController.abort();
   });
   try {
+    const { request, url } = toWebRequest(req, bodyLimit, abortController.signal);
+    const method = request.method.toUpperCase();
+    const urlPath = url.pathname;
+    const preMatched = matchRoute(routes, method, urlPath);
     const prepared = prepareRequest(
       req,
+      request,
+      url,
       config,
-      bodyLimit,
       trustedProxy,
       registries,
-      abortController.signal
+      preMatched
     );
     ctx = prepared.ctx;
     meta = prepared.meta;
-    const { request, url, method, urlPath } = prepared;
+    ctx.__earlyRespond = (response2) => {
+      if (sseEarlySent) return;
+      sseEarlySent = true;
+      void sendNodeResponse(mergeMeta(response2, meta), res).catch(() => {
+        if (!res.writableEnded) res.destroy();
+      });
+    };
     const routePipeline = createRoutePipeline({
       routes,
       method,
@@ -5053,12 +5236,25 @@ async function handleRequest(routes, rootDir, dist, req, res, outerMiddlewares,
       request,
       rootDir,
       dist,
-      globalInjectors
+      globalInjectors,
+      preMatched,
+      wsRoutes
     });
     const response = outerMiddlewares.length > 0 ? await compose(outerMiddlewares, ctx, routePipeline) : await routePipeline();
-    await sendSuccessResponse(response, res);
+    if (!sseEarlySent) {
+      await sendSuccessResponse(response, res);
+    }
   } catch (err) {
     if (res.destroyed || res.writableEnded) return;
+    if (sseEarlySent) {
+      if (onError && ctx) {
+        try {
+          await onError(err, ctx);
+        } catch {
+        }
+      }
+      return;
+    }
     if (err instanceof PayloadTooLargeError) {
       res.setHeader("Connection", "close");
       res.once("finish", () => req.destroy());