@faapi/faapi 1.5.0 → 2.0.0

package/dist/index.js

@@ -1219,8 +1219,8 @@ __export(generateSchemaFiles_exports, {
   getRuntimeSchemaPath: () => getRuntimeSchemaPath,
   getSchemaOutputPath: () => getSchemaOutputPath
 });
-import path5 from "path";
-import fs4 from "fs/promises";
+import path7 from "path";
+import fs6 from "fs/promises";
 function getSchemaOutputPath(sourceFile, dist, rootDir) {
   let rel = sourceFile.replace(/\\/g, "/");
   if (rel.startsWith("src/")) {
@@ -1228,7 +1228,7 @@ function getSchemaOutputPath(sourceFile, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
+  return path7.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getRuntimeSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -1239,7 +1239,7 @@ function getRuntimeSchemaPath(filePath, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
+  return path7.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -1289,7 +1289,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path5.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path7.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
@@ -1304,7 +1304,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path5.resolve(rootDir, dist, HELPERS_FILENAME);
+    const helpersPath = path7.resolve(rootDir, dist, HELPERS_FILENAME);
     await writeSchemaFile(helpersPath, generateHelpersFileSource());
   }
   await Promise.all(
@@ -1312,8 +1312,8 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   );
 }
 async function writeSchemaFile(outputPath, source) {
-  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
-  await fs4.writeFile(outputPath, source, "utf-8");
+  await fs6.mkdir(path7.dirname(outputPath), { recursive: true });
+  await fs6.writeFile(outputPath, source, "utf-8");
 }
 var init_generateSchemaFiles = __esm({
   "src/cli/generateSchemaFiles.ts"() {
@@ -1646,14 +1646,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path15) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path15}`, 404);
+  constructor(path14) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path14}`, 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, path14, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path14}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -1672,1358 +1672,800 @@ var ModuleLoadError = class extends FaapiError {
   }
 };
 
-// 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";
+// src/cli/createAppCore.ts
+import fs11 from "fs";
+import path12 from "path";
+import { PassThrough, Readable as Readable3 } from "stream";
+
+// src/router/sortRoutes.ts
+function sortRoutes(routes) {
+  return [...routes].sort((a, b) => {
+    if (a.isDynamic !== b.isDynamic) {
+      return a.isDynamic ? 1 : -1;
+    }
+    if (a.isCatchAll !== b.isCatchAll) {
+      return a.isCatchAll ? 1 : -1;
+    }
+    const aSegments = a.urlPath.split("/").filter(Boolean).length;
+    const bSegments = b.urlPath.split("/").filter(Boolean).length;
+    if (aSegments !== bSegments) {
+      return aSegments - bSegments;
+    }
+    return a.urlPath.localeCompare(b.urlPath);
+  });
+}
+
+// src/router/detectRouteConflicts.ts
+function detectRouteConflicts(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = `${route.method} ${route.urlPath}`;
+    const existing = map.get(key);
+    if (existing) {
+      existing.files.push(route.filePath);
     } else {
-      dataStr = JSON.stringify(event.data);
+      map.set(key, {
+        method: route.method,
+        urlPath: route.urlPath,
+        files: [route.filePath]
+      });
     }
-    const lines = dataStr.split("\n");
-    for (const line of lines) {
-      out += `data: ${line}
-`;
+  }
+  const conflicts = [];
+  for (const conflict of map.values()) {
+    if (conflict.files.length > 1) {
+      conflicts.push(conflict);
     }
   }
-  out += "\n";
-  return out;
+  return conflicts;
 }
-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;
+
+// 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 path10 from "path";
+
+// src/router/matchRoute.ts
+function matchRoute(routes, method, path14) {
+  for (const route of routes) {
+    if (route.method !== method) {
+      continue;
     }
-  });
-  const response = new Response(stream, {
-    status: 200,
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
+    if (!route.isDynamic) {
+      if (route.urlPath === path14) {
+        return { route, params: {} };
+      }
+      continue;
     }
-  });
-  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();
+    const params = matchDynamicPath(route.urlPath, path14, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+function matchWsRoute(wsRoutes, path14) {
+  for (const route of wsRoutes) {
+    if (!route.isDynamic) {
+      if (route.urlPath === path14) {
+        return { route, params: {} };
       }
-    },
-    close() {
-      if (closed) return;
-      closed = true;
-      if (controller) {
-        try {
-          controller.close();
-        } catch {
-        }
-        controller = null;
+      continue;
+    }
+    const params = matchDynamicPath(route.urlPath, path14, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+function matchDynamicPath(pattern, path14, paramNames, isCatchAll) {
+  const patternSegments = pattern.split("/").filter(Boolean);
+  const pathSegments = path14.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;
       }
-    },
-    get closed() {
-      return closed;
-    },
-    get aborted() {
-      return aborted;
-    },
-    get response() {
-      return response;
     }
-  };
-  return writer;
+    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/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());
+// src/loader/loadRouteModule.ts
+import fs8 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 cookies;
+  return void 0;
 }
-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;
+
+// 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}.`
+    );
+  }
 }
-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);
+
+// src/cli/compileOnDemand.ts
+import path8 from "path";
+import fs7 from "fs";
+
+// src/cli/compileDevRoutes.ts
+import path6 from "path";
+import fs5 from "fs";
+import fg 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));
+      }
     }
-  };
-  const extend = config?.extendContext;
-  if (typeof extend === "function") {
-    extend(ctx);
   }
-  return ctx;
+  return candidates;
 }
 
-// src/utils/isPlainObject.ts
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return false;
+// 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));
   }
-  const proto = Object.getPrototypeOf(value);
-  return proto === null || proto === Object.prototype;
+  return { baseUrl, paths };
 }
 
-// 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;
+// 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;
   }
-  if (value === null || value === void 0) {
-    const status = meta?.status ?? 204;
-    const headers2 = new Headers();
-    applyMeta(headers2);
-    return new Response(null, { status, headers: headers2 });
+}
+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 (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 (/\.(ts|tsx|jsx)$/.test(specifier)) {
+    return fs4.existsSync(base) ? base : null;
   }
-  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
-    });
+  for (const ext of SOURCE_EXTS) {
+    const file = base + ext;
+    if (fs4.existsSync(file)) return file;
   }
-  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
-    });
+  for (const indexExt of INDEX_EXTS) {
+    const file = base + indexExt;
+    if (fs4.existsSync(file)) return file;
   }
-  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
-  });
+  return null;
 }
-
-// src/injection/injectParams.ts
-init_resolveInjection();
-
-// src/utils/queryToObject.ts
-function queryToObject(params) {
-  const result = {};
-  for (const [key, value] of params) {
-    result[key] = value;
-  }
-  return result;
+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/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;
+// src/cli/compileDevRoutes.ts
+var APP_DIR2 = "src";
+async function compileDevRoutes(options) {
+  const { rootDir, dist, files, logLevel = "silent" } = options;
+  const entryPoints = files ?? await fg([`${APP_DIR2}/**/*.ts`], {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
+  });
+  if (entryPoints.length === 0) {
+    return { compiledFiles: [] };
   }
-}
-async function injectParamsAsync(handler, ctx, body, injectors) {
-  const injections = resolveInjection(handler);
-  if (injections.length === 0) {
-    return await handler();
+  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);
+      })
+    );
   }
-  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);
+  return { compiledFiles: entryPoints };
 }
 
-// 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);
+// src/cli/compileOnDemand.ts
+init_generateSchemaFiles();
+init_generateSchemaFiles();
+function isProductFresh(sourceAbsPath, productAbsPath) {
+  try {
+    const srcStat = fs7.statSync(sourceAbsPath);
+    const prodStat = fs7.statSync(productAbsPath);
+    return prodStat.mtimeMs >= srcStat.mtimeMs;
+  } catch {
+    return false;
+  }
 }
-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);
+var compiledFiles = /* @__PURE__ */ new Set();
+function clearCompiledFiles() {
+  compiledFiles.clear();
+}
+async function ensureCompiled(sourceAbsPath, rootDir, dist) {
+  if (compiledFiles.has(sourceAbsPath)) {
+    return false;
   }
-  for (const cookie of meta.setCookies) {
-    headers.append("set-cookie", cookie);
+  if (!fs7.existsSync(sourceAbsPath)) {
+    return false;
   }
-  return new Response(response.body, {
-    status: meta.status ?? response.status,
-    headers
+  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;
 }
-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);
+function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
+  const rel = path8.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  if (!rel.startsWith("src/")) return null;
+  const relWithoutSrc = rel.slice(4);
+  const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
+  return path8.resolve(rootDir, dist, jsRel);
 }
-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);
+var generatedSchemas = /* @__PURE__ */ new Set();
+function clearGeneratedSchemas() {
+  generatedSchemas.clear();
 }
-
-// src/testServer.ts
-import path12 from "path";
-import os from "os";
-import fs11 from "fs/promises";
-
-// src/router/scanRoutes.ts
-import fg from "fast-glob";
-import path4 from "path";
-import fs3 from "fs";
-
-// src/router/constants.ts
-var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
-var HTTP_METHOD_SET = new Set(HTTP_METHODS);
-
-// src/utils/normalizePath.ts
-function normalizePath(path15) {
-  if (!path15) return "";
-  let result = path15.replace(/\\/g, "/");
-  result = result.replace(/\/+/g, "/");
-  result = result.replace(/\/+$/, "");
-  if (result && !result.startsWith("/")) {
-    result = "/" + result;
+async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
+  if (generatedSchemas.has(schemaPath)) {
+    return false;
   }
-  return result;
-}
-
-// src/router/parseRouteFile.ts
-function dynamicSegmentToParam(segment) {
-  const match = segment.match(/^\[(.+)\]$/);
-  if (match) {
-    return ":" + match[1];
+  const prodAbsPath = path8.resolve(rootDir, routeFilePath);
+  const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
+  if (!fs7.existsSync(sourceAbsPath)) {
+    return false;
   }
-  return segment;
+  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 = path8.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
+  await generateSchemaFiles(sourceRoutes, rootDir, dist);
+  generatedSchemas.add(schemaPath);
+  return true;
 }
-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));
+async function deleteSchemaFiles(routes, rootDir, dist) {
+  const deleted = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
+    if (deleted.has(schemaPath)) continue;
+    deleted.add(schemaPath);
+    try {
+      await fs7.promises.unlink(schemaPath);
+    } catch {
     }
   }
-  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 "";
+function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
+  const rel = path8.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  let relWithoutDist = rel;
+  if (relWithoutDist.startsWith(`${dist}/`)) {
+    relWithoutDist = relWithoutDist.slice(dist.length + 1);
   }
-  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
-  return normalizePath(segments.join("/"));
-}
-
-// src/middleware/loadMiddlewares.ts
-var middlewareCache = /* @__PURE__ */ new Map();
-function invalidateMiddlewareCache() {
-  middlewareCache.clear();
+  const srcRel = `src/${relWithoutDist}`;
+  const tsRel = srcRel.replace(/\.js$/, ".ts");
+  const tsAbs = path8.resolve(rootDir, tsRel);
+  if (fs7.existsSync(tsAbs)) return tsAbs;
+  return path8.resolve(rootDir, srcRel);
 }
-function getCachedMiddlewares(absPath) {
-  return middlewareCache.get(absPath);
+var devOnDemandEnabled = false;
+function isDevOnDemandEnabled() {
+  return devOnDemandEnabled;
 }
-function setCachedMiddlewares(absPath, bundle) {
-  middlewareCache.set(absPath, bundle);
+var devDistDir;
+function getDevDist() {
+  return devDistDir;
 }
-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;
+
+// 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 && fs8.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
+          });
+        }
       }
-      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;
+  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 });
   }
-  return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
+  const handler = resolveExport(module, method);
+  validateRouteModule(handler, method, filePath);
+  return { handler, method };
 }
 
-// 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]);
+// src/runtime/sse.ts
+function encodeSseEvent(event) {
+  let out = "";
+  if (event.comment !== void 0) {
+    out += `: ${event.comment}
+`;
   }
-  return names;
-}
-function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
-  const routeDir = path4.dirname(routeFilePath);
-  const resolvedRoot = path4.resolve(rootDir);
-  const paths = [];
-  let currentDir = path4.resolve(rootDir, routeDir);
-  while (true) {
-    if (dist) {
-      const mwTsPath = path4.join(currentDir, "middlewares.ts");
-      const mwJsPath = path4.join(currentDir, "middlewares.js");
-      const absTsPath = path4.resolve(rootDir, mwTsPath);
-      const absJsPath = path4.resolve(rootDir, mwJsPath);
-      const absMwPath = fs3.existsSync(absTsPath) ? absTsPath : fs3.existsSync(absJsPath) ? absJsPath : null;
-      if (absMwPath) {
-        const relMwPath = path4.relative(rootDir, absMwPath);
-        const prodAbsPath = path4.resolve(rootDir, toProdFilePath(relMwPath, dist));
-        paths.push(prodAbsPath);
-      }
-    } else {
-      for (const ext of [".ts", ".js"]) {
-        const mwPath = path4.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path4.resolve(rootDir, mwPath);
-        if (fs3.existsSync(absMwPath)) {
-          paths.push(absMwPath);
-          break;
-        }
-      }
-    }
-    if (currentDir === resolvedRoot) break;
-    const parentDir = path4.dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
+  if (event.event !== void 0) {
+    out += `event: ${event.event}
+`;
   }
-  paths.reverse();
-  return paths;
-}
-function toProdFilePath(filePath, dist) {
-  let rel = filePath.replace(/\\/g, "/");
-  if (rel.startsWith("src/")) {
-    rel = rel.slice(4);
+  if (event.id !== void 0) {
+    out += `id: ${event.id}
+`;
   }
-  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 = path4.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 fs3.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;
+  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}
+`;
     }
   }
-  return { routes, wsRoutes };
+  out += "\n";
+  return out;
 }
-
-// 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;
+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 aSegments = a.urlPath.split("/").filter(Boolean).length;
-    const bSegments = b.urlPath.split("/").filter(Boolean).length;
-    if (aSegments !== bSegments) {
-      return aSegments - bSegments;
+  });
+  const response = new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
     }
-    return a.urlPath.localeCompare(b.urlPath);
   });
-}
-
-// src/testServer.ts
-init_generateSchemaFiles();
-
-// src/validator/validateInput.ts
-init_schemaName();
-
-// src/cli/compileOnDemand.ts
-import path9 from "path";
-import fs8 from "fs";
-
-// src/cli/compileDevRoutes.ts
-import path8 from "path";
-import fs7 from "fs";
-import fg2 from "fast-glob";
-
-// src/cli/aliasPlugin.ts
-import path7 from "path";
-import fs6 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);
+  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();
       }
-      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));
+    },
+    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 candidates;
+  };
+  return writer;
 }
 
-// src/utils/readTsconfig.ts
-import ts6 from "typescript";
-import path6 from "path";
-import fs5 from "fs";
-function readTsconfig(rootDir) {
-  const tsconfigPath = path6.resolve(rootDir, "tsconfig.json");
-  if (!fs5.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) => path6.resolve(baseUrl, t));
+// 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 { baseUrl, paths };
+  return cookies;
 }
-
-// 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 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 toProdImportPath(sourceFile, importer) {
-  const importerDir = path7.dirname(importer);
-  let rel = path7.relative(importerDir, sourceFile);
-  rel = rel.split(path7.sep).join("/");
-  if (!rel.startsWith(".")) rel = "./" + rel;
-  return toProdExtension(rel);
-}
-function toRealPath(p) {
-  try {
-    return fs6.realpathSync(p);
-  } catch {
-    return p;
-  }
-}
-function isInsideDir(filePath, dir) {
-  const rel = path7.relative(dir, filePath);
-  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
-}
-var APP_DIR = "src";
-function toStrippedProdImportPath(sourceFile, rootDir) {
-  const appDirAbs = toRealPath(path7.resolve(rootDir, APP_DIR));
-  const sourceReal = toRealPath(sourceFile);
-  let rel = path7.relative(appDirAbs, sourceReal);
-  rel = rel.split(path7.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 = path7.dirname(importer);
-  const base = path7.resolve(importerDir, specifier);
-  if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
-    return fs6.existsSync(base) ? base : null;
-  }
-  if (/\.(ts|tsx|jsx)$/.test(specifier)) {
-    return fs6.existsSync(base) ? base : null;
-  }
-  for (const ext of SOURCE_EXTS) {
-    const file = base + ext;
-    if (fs6.existsSync(file)) return file;
-  }
-  for (const indexExt of INDEX_EXTS) {
-    const file = base + indexExt;
-    if (fs6.existsSync(file)) return file;
+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;
   }
-  return null;
-}
-function createAliasPlugin(config, options) {
-  const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
-  const appDirAbs = options?.rootDir ? toRealPath(path7.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 = fs6.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 (fs6.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 (fs6.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" };
+  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 }
       });
-    }
-  };
-}
-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 = path8.resolve(rootDir, dist);
-  await fs7.promises.mkdir(absDist, { recursive: true });
-  const plugins = buildAliasPlugins(rootDir);
-  const esbuild = await import("esbuild");
-  const outbase = path8.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 fs7.promises.mkdir(path8.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);
-      })
-    );
-  }
-  return { compiledFiles: entryPoints };
-}
-
-// src/cli/compileOnDemand.ts
-init_generateSchemaFiles();
-init_generateSchemaFiles();
-function isProductFresh(sourceAbsPath, productAbsPath) {
-  try {
-    const srcStat = fs8.statSync(sourceAbsPath);
-    const prodStat = fs8.statSync(productAbsPath);
-    return prodStat.mtimeMs >= srcStat.mtimeMs;
-  } catch {
-    return false;
-  }
-}
-var compiledFiles = /* @__PURE__ */ new Set();
-function clearCompiledFiles() {
-  compiledFiles.clear();
-}
-async function ensureCompiled(sourceAbsPath, rootDir, dist) {
-  if (compiledFiles.has(sourceAbsPath)) {
-    return false;
-  }
-  if (!fs8.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 = path9.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
-  if (!rel.startsWith("src/")) return null;
-  const relWithoutSrc = rel.slice(4);
-  const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
-  return path9.resolve(rootDir, dist, jsRel);
-}
-var generatedSchemas = /* @__PURE__ */ new Set();
-function clearGeneratedSchemas() {
-  generatedSchemas.clear();
-}
-async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
-  if (generatedSchemas.has(schemaPath)) {
-    return false;
-  }
-  const prodAbsPath = path9.resolve(rootDir, routeFilePath);
-  const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
-  if (!fs8.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 = path9.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
-  const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
-  await generateSchemaFiles(sourceRoutes, rootDir, dist);
-  generatedSchemas.add(schemaPath);
-  return true;
-}
-async function deleteSchemaFiles(routes, rootDir, dist) {
-  const deleted = /* @__PURE__ */ new Set();
-  for (const route of routes) {
-    const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
-    if (deleted.has(schemaPath)) continue;
-    deleted.add(schemaPath);
-    try {
-      await fs8.promises.unlink(schemaPath);
-    } catch {
-    }
-  }
-}
-function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
-  const rel = path9.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 = path9.resolve(rootDir, tsRel);
-  if (fs8.existsSync(tsAbs)) return tsAbs;
-  return path9.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 path15 = issue.path.map(String).join(".") || "";
-    return {
-      path: path15,
-      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 path11 from "path";
-
-// src/router/matchRoute.ts
-function matchRoute(routes, method, path15) {
-  for (const route of routes) {
-    if (route.method !== method) {
-      continue;
-    }
-    if (!route.isDynamic) {
-      if (route.urlPath === path15) {
-        return { route, params: {} };
-      }
-      continue;
-    }
-    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
-    if (params !== null) {
-      return { route, params };
-    }
-  }
-  return null;
-}
-function matchWsRoute(wsRoutes, path15) {
-  for (const route of wsRoutes) {
-    if (!route.isDynamic) {
-      if (route.urlPath === path15) {
-        return { route, params: {} };
-      }
-      continue;
-    }
-    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
-    if (params !== null) {
-      return { route, params };
-    }
-  }
-  return null;
-}
-function matchDynamicPath(pattern, path15, paramNames, isCatchAll) {
-  const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path15.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 fs9 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}.`
-    );
+    },
+    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;
 }
 
-// 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 && fs9.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 });
+// src/utils/queryToObject.ts
+function queryToObject(params) {
+  const result = {};
+  for (const [key, value] of params) {
+    result[key] = value;
   }
-  const handler = resolveExport(module, method);
-  validateRouteModule(handler, method, filePath);
-  return { handler, method };
+  return result;
 }
 
 // src/utils/parseJsonBody.ts
@@ -3063,48 +2505,297 @@ async function parseMultipart(request) {
       }
     }
   }
-  return { fields, files };
+  return { fields, files };
+}
+
+// src/runtime/resolveInput.ts
+init_inputType();
+async function resolveInput(method, request) {
+  const inputType = getInputTypeForMethod(method);
+  if (inputType === "body") {
+    const contentType = request.headers.get("content-type") ?? "";
+    if (contentType.includes("multipart/form-data")) {
+      return parseMultipart(request);
+    }
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      const text2 = await request.text();
+      if (text2.trim() === "") return null;
+      const params = new URLSearchParams(text2);
+      const obj = {};
+      for (const [key, value] of params) {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    const text = await request.text();
+    if (text.trim() === "") {
+      return null;
+    }
+    const result = parseJsonBody(text);
+    if (!result.success) {
+      throw new ValidationError("\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON", [
+        {
+          path: "body",
+          code: "INVALID_FORMAT",
+          expected: "JSON",
+          received: "text",
+          message: "\u8BF7\u6C42\u4F53\u4E0D\u662F\u5408\u6CD5\u7684 JSON"
+        }
+      ]);
+    }
+    return result.data;
+  }
+  const url = new URL(request.url);
+  return queryToObject(url.searchParams);
+}
+
+// src/utils/isPlainObject.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+
+// src/response/toResponse.ts
+async function toResponse(value, meta) {
+  if (value instanceof Promise) {
+    return toResponse(await value, meta);
+  }
+  const applyMeta = (headers2) => {
+    if (!meta) return;
+    for (const [key, val] of Object.entries(meta.headers)) {
+      headers2.set(key, val);
+    }
+    for (const cookie of meta.setCookies ?? []) {
+      headers2.append("set-cookie", cookie);
+    }
+  };
+  if (value instanceof Response) {
+    if (meta && (meta.status !== void 0 || Object.keys(meta.headers).length > 0 || meta.setCookies.length > 0)) {
+      const headers2 = new Headers(value.headers);
+      applyMeta(headers2);
+      return new Response(value.body, {
+        status: meta.status ?? value.status,
+        headers: headers2
+      });
+    }
+    return value;
+  }
+  if (value === null || value === void 0) {
+    const status = meta?.status ?? 204;
+    const headers2 = new Headers();
+    applyMeta(headers2);
+    return new Response(null, { status, headers: headers2 });
+  }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (value instanceof Uint8Array) {
+    const headers2 = new Headers({ "Content-Type": "application/octet-stream" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (isPlainObject(value) || Array.isArray(value)) {
+    const body2 = JSON.stringify(value);
+    const headers2 = new Headers({ "Content-Type": "application/json" });
+    applyMeta(headers2);
+    return new Response(body2, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (typeof value === "string") {
+    const headers2 = new Headers({ "Content-Type": "text/plain" });
+    applyMeta(headers2);
+    return new Response(value, {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    const headers2 = new Headers({ "Content-Type": "text/plain" });
+    applyMeta(headers2);
+    return new Response(String(value), {
+      status: meta?.status ?? 200,
+      headers: headers2
+    });
+  }
+  const body = JSON.stringify(value);
+  const headers = new Headers({ "Content-Type": "application/json" });
+  applyMeta(headers);
+  return new Response(body, {
+    status: meta?.status ?? 200,
+    headers
+  });
+}
+
+// src/injection/injectParams.ts
+init_resolveInjection();
+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
+  });
 }
-
-// src/runtime/resolveInput.ts
-init_inputType();
-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);
+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");
     }
-    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;
+    index = i;
+    if (i >= middlewares.length) {
+      return await finalHandler();
     }
-    const text = await request.text();
-    if (text.trim() === "") {
-      return null;
+    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);
     }
-    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"
-        }
-      ]);
+    if (innerResponse !== void 0) {
+      return innerResponse;
     }
-    return result.data;
+    throw new Error("\u4E2D\u95F4\u4EF6\u5FC5\u987B await next() \u6216\u8FD4\u56DE Response");
   }
-  const url = new URL(request.url);
-  return queryToObject(url.searchParams);
+  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/response/sendNodeResponse.ts
@@ -3131,6 +2822,94 @@ async function sendNodeResponse(response, res) {
   res.end();
 }
 
+// src/validator/validateInput.ts
+init_schemaName();
+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 path14 = issue.path.map(String).join(".") || "";
+    return {
+      path: path14,
+      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
 init_inputType();
 
@@ -3152,9 +2931,9 @@ function getClientIp(req) {
 }
 
 // src/server/handleWsUpgrade.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path10 from "path";
+import path9 from "path";
 
 // src/errors/formatErrorResponse.ts
 function formatErrorResponse(error) {
@@ -3229,6 +3008,71 @@ function buildErrorResponse(err) {
   }
 }
 
+// src/middleware/loadMiddlewares.ts
+var middlewareCache = /* @__PURE__ */ new Map();
+function invalidateMiddlewareCache() {
+  middlewareCache.clear();
+}
+function getCachedMiddlewares(absPath) {
+  return middlewareCache.get(absPath);
+}
+function setCachedMiddlewares(absPath, bundle) {
+  middlewareCache.set(absPath, bundle);
+}
+async function loadMiddlewaresFile(filePath) {
+  try {
+    const module = await importWithCacheBust(filePath);
+    const middlewares = module.default ?? module.middlewares ?? [];
+    if (!Array.isArray(middlewares)) {
+      console.warn(`[faapi] middlewares.ts \u5E94\u5BFC\u51FA\u6570\u7EC4\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+      return { middlewares: [], injectors: {} };
+    }
+    const validMiddlewares = middlewares.filter((m) => {
+      if (typeof m !== "function") {
+        console.warn(`[faapi] \u65E0\u6548\u7684\u4E2D\u95F4\u4EF6\u9879\uFF08\u5E94\u4E3A\u51FD\u6570\uFF09\uFF0C\u5DF2\u5FFD\u7565: ${typeof m}`);
+        return false;
+      }
+      return true;
+    });
+    const injectors = module.injectors ?? {};
+    if (typeof injectors !== "object" || injectors === null) {
+      console.warn(`[faapi] injectors \u5E94\u5BFC\u51FA\u5BF9\u8C61\uFF0C\u5DF2\u5FFD\u7565: ${filePath}`);
+      return { middlewares: validMiddlewares, injectors: {} };
+    }
+    const validInjectors = {};
+    for (const [name, injector] of Object.entries(injectors)) {
+      if (typeof injector !== "function") {
+        console.warn(`[faapi] \u6CE8\u5165\u5668 ${name} \u5E94\u4E3A\u51FD\u6570\uFF0C\u5DF2\u5FFD\u7565`);
+        continue;
+      }
+      validInjectors[name] = injector;
+    }
+    return { middlewares: validMiddlewares, injectors: validInjectors };
+  } catch {
+    return { middlewares: [], injectors: {} };
+  }
+}
+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/runtime/wsHandler.ts
 function wrapWsSocket(rawSocket) {
   return {
@@ -3256,7 +3100,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 && fs9.existsSync(sourcePath)) {
         await ensureCompiled(sourcePath, rootDir, dist);
       }
     }
@@ -3336,7 +3180,7 @@ function attachWebSocket(options) {
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path10.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path9.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -3435,15 +3279,15 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path15) {
+function findAllowedMethods(routes, path14) {
   const methods = /* @__PURE__ */ new Set();
   for (const route of routes) {
-    if (route.urlPath === path15) {
+    if (route.urlPath === path14) {
       methods.add(route.method);
       continue;
     }
     if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
+      const params = matchDynamicPath(route.urlPath, path14, route.paramNames, route.isCatchAll);
       if (params !== null) {
         methods.add(route.method);
       }
@@ -3529,7 +3373,7 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
     }
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path11.resolve(rootDir, route.filePath);
+    const absoluteFilePath = path10.resolve(rootDir, route.filePath);
     const routeModule = await loadRouteModule(absoluteFilePath, route.method, rootDir);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
@@ -3590,229 +3434,6 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
   }
 }
 
-// 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 ? path12.isAbsolute(dist) ? dist : path12.resolve(rootDir, dist) : await fs11.mkdtemp(path12.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 fs11.rm(schemaDist, { recursive: true, force: true }).catch(() => {
-      });
-      invalidateSchemaCache();
-    }
-  };
-  return testServer;
-}
-function listenOnRandomPort(server) {
-  return new Promise((resolve, reject) => {
-    server.listen(0, () => {
-      const addr = server.address();
-      if (typeof addr === "object" && addr !== null) {
-        resolve(`http://localhost:${addr.port}`);
-      } else {
-        reject(new Error("Failed to get server address"));
-      }
-    });
-    server.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-
-// src/wsTestClient.ts
-import { WebSocket as WebSocket2 } from "ws";
-var MessageQueue = class {
-  queue = [];
-  waiters = [];
-  listener;
-  constructor(ws) {
-    this.listener = (data) => {
-      const msg = normalizeRawData(data);
-      const waiter = this.waiters.shift();
-      if (waiter) {
-        waiter(msg);
-      } else {
-        this.queue.push(msg);
-      }
-    };
-    ws.on("message", this.listener);
-  }
-  /**
-   * 取下一条消息
-   *
-   * 队列有则立即 resolve，无则注册 waiter 等待下一条 'message' 事件。
-   * 超时未到 → reject('WebSocket message timeout')，waiter 被清理。
-   *
-   * @param timeout 超时毫秒，默认 2000
-   */
-  next(timeout = 2e3) {
-    return new Promise((resolve, reject) => {
-      const wrapped = (msg2) => {
-        clearTimeout(timer);
-        resolve(msg2);
-      };
-      const timer = setTimeout(() => {
-        const idx = this.waiters.indexOf(wrapped);
-        if (idx >= 0) this.waiters.splice(idx, 1);
-        reject(new Error("WebSocket message timeout"));
-      }, timeout);
-      const msg = this.queue.shift();
-      if (msg !== void 0) {
-        wrapped(msg);
-      } else {
-        this.waiters.push(wrapped);
-      }
-    });
-  }
-};
-function normalizeRawData(data) {
-  if (Buffer.isBuffer(data)) {
-    return data.toString("utf8");
-  }
-  if (Array.isArray(data)) {
-    return Buffer.concat(data).toString("utf8");
-  }
-  return Buffer.from(data).toString("utf8");
-}
-function waitForWsOpen(ws, timeout = 2e3) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error("WebSocket open timeout"));
-    }, timeout);
-    const cleanup = () => {
-      clearTimeout(timer);
-      ws.removeListener("open", onOpen);
-      ws.removeListener("error", onError);
-      ws.removeListener("close", onClose);
-    };
-    const onOpen = () => {
-      cleanup();
-      resolve();
-    };
-    const onError = (err) => {
-      cleanup();
-      reject(err);
-    };
-    const onClose = () => {
-      cleanup();
-      reject(new Error("WebSocket closed before open"));
-    };
-    ws.once("open", onOpen);
-    ws.once("error", onError);
-    ws.once("close", onClose);
-  });
-}
-async function connectWs(baseUrl, pathname, options = {}) {
-  const { timeout = 2e3, headers, protocols } = options;
-  const wsBaseUrl = baseUrl.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
-  const url = `${wsBaseUrl}${pathname}`;
-  const ws = new WebSocket2(url, protocols, headers ? { headers } : void 0);
-  const queue = new MessageQueue(ws);
-  try {
-    await waitForWsOpen(ws, timeout);
-  } catch (err) {
-    if (ws.readyState === WebSocket2.OPEN || ws.readyState === WebSocket2.CONNECTING) {
-      ws.close();
-    }
-    throw err;
-  }
-  let closed = false;
-  return {
-    ws,
-    queue,
-    async close() {
-      if (closed) return;
-      closed = true;
-      if (ws.readyState === WebSocket2.OPEN || ws.readyState === WebSocket2.CONNECTING) {
-        ws.close();
-      }
-      await new Promise((resolve) => {
-        const timer = setTimeout(resolve, 1e3);
-        ws.once("close", () => {
-          clearTimeout(timer);
-          resolve();
-        });
-      });
-    }
-  };
-}
-
-// src/cli/createAppCore.ts
-import fs13 from "fs";
-import path14 from "path";
-import { PassThrough, Readable as Readable3 } from "stream";
-
-// src/router/detectRouteConflicts.ts
-function detectRouteConflicts(routes) {
-  const map = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    const key = `${route.method} ${route.urlPath}`;
-    const existing = map.get(key);
-    if (existing) {
-      existing.files.push(route.filePath);
-    } else {
-      map.set(key, {
-        method: route.method,
-        urlPath: route.urlPath,
-        files: [route.filePath]
-      });
-    }
-  }
-  const conflicts = [];
-  for (const conflict of map.values()) {
-    if (conflict.files.length > 1) {
-      conflicts.push(conflict);
-    }
-  }
-  return conflicts;
-}
-
 // src/server/startServer.ts
 function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
   if (handlerWrappers.length > 0) {
@@ -3842,8 +3463,8 @@ function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
 }
 
 // src/cli/generateRoutes.ts
-import fs12 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path11 from "path";
 async function hydrateRoutes(manifest) {
   const hydrateRoute = (serialized) => ({
     method: serialized.method,
@@ -3959,8 +3580,8 @@ function isFaapiConfigKey(key) {
 async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
-  const routesPath = path14.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs13.existsSync(routesPath)) {
+  const routesPath = path12.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs11.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -4160,6 +3781,180 @@ async function createAppBase(options) {
   return { app, ctx };
 }
 
+// src/router/scanRoutes.ts
+import fg2 from "fast-glob";
+import path13 from "path";
+import fs12 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(path14) {
+  if (!path14) return "";
+  let result = path14.replace(/\\/g, "/");
+  result = result.replace(/\/+/g, "/");
+  result = result.replace(/\/+$/, "");
+  if (result && !result.startsWith("/")) {
+    result = "/" + result;
+  }
+  return result;
+}
+
+// src/router/parseRouteFile.ts
+function dynamicSegmentToParam(segment) {
+  const match = segment.match(/^\[(.+)\]$/);
+  if (match) {
+    return ":" + match[1];
+  }
+  return segment;
+}
+function extractParamNames(urlPath) {
+  const params = [];
+  const segments = urlPath.split("/");
+  for (const segment of segments) {
+    if (segment.startsWith(":...")) {
+      params.push(segment.slice(4));
+    } else if (segment.startsWith(":")) {
+      params.push(segment.slice(1));
+    }
+  }
+  return params;
+}
+function isCatchAllSegment(segment) {
+  return /^\[\.\.\..+\]$/.test(segment);
+}
+function isRouteGroup(segment) {
+  return /^\(.+\)$/.test(segment);
+}
+function filePathToUrlPath(filePath) {
+  const withoutPrefix = filePath.startsWith("src/") ? filePath.slice(4) : filePath;
+  const lastSlashIndex = withoutPrefix.lastIndexOf("/");
+  const dirPath = lastSlashIndex === -1 ? "" : withoutPrefix.slice(0, lastSlashIndex);
+  if (!dirPath) {
+    return "";
+  }
+  const segments = dirPath.split("/").filter((s) => !isRouteGroup(s)).map(dynamicSegmentToParam);
+  return normalizePath(segments.join("/"));
+}
+
+// src/router/scanRoutes.ts
+var 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 = path13.dirname(routeFilePath);
+  const resolvedRoot = path13.resolve(rootDir);
+  const paths = [];
+  let currentDir = path13.resolve(rootDir, routeDir);
+  while (true) {
+    if (dist) {
+      const mwTsPath = path13.join(currentDir, "middlewares.ts");
+      const mwJsPath = path13.join(currentDir, "middlewares.js");
+      const absTsPath = path13.resolve(rootDir, mwTsPath);
+      const absJsPath = path13.resolve(rootDir, mwJsPath);
+      const absMwPath = fs12.existsSync(absTsPath) ? absTsPath : fs12.existsSync(absJsPath) ? absJsPath : null;
+      if (absMwPath) {
+        const relMwPath = path13.relative(rootDir, absMwPath);
+        const prodAbsPath = path13.resolve(rootDir, toProdFilePath(relMwPath, dist));
+        paths.push(prodAbsPath);
+      }
+    } else {
+      for (const ext of [".ts", ".js"]) {
+        const mwPath = path13.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path13.resolve(rootDir, mwPath);
+        if (fs12.existsSync(absMwPath)) {
+          paths.push(absMwPath);
+          break;
+        }
+      }
+    }
+    if (currentDir === resolvedRoot) break;
+    const parentDir = path13.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 fg2(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 = path13.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 fs12.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/cli/createDevApp.ts
 init_createProgram();
 async function createDevApp(options) {
@@ -4193,31 +3988,25 @@ async function createProdApp(options) {
 export {
   FaapiError,
   InternalError,
-  MessageQueue,
   MethodNotAllowedError,
   ModuleLoadError,
   RouteNotFoundError,
   SchemaExtractionError,
   ValidationError,
   collectRouteSchemaSources,
-  connectWs,
   cors,
   createProdApp as createApp,
-  createContext,
   createDevApp,
   createProdApp,
   createProgram,
-  createTestServer,
   extractTypeInfo,
   getApp,
   getInputTypeForMethod,
   helmet,
   invalidateProgramCache,
-  invokeHandler,
   loadConfig,
   loadEnv,
   logger,
-  resolveTypeNode,
-  waitForWsOpen
+  resolveTypeNode
 };
 //# sourceMappingURL=index.js.map