@faapi/faapi 3.2.0 → 3.3.0

package/dist/testing.js

@@ -129,14 +129,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path11) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path11}`, 404);
+  constructor(path12) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path12}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path11, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path11}`, 405);
+  constructor(method, path12, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path12}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -266,7 +266,9 @@ function formatSetCookie(name, value, options) {
   return cookie;
 }
 function createContext(request, params, config = {}, ip = "") {
-  const url = new URL(request.url);
+  return createContextFromUrl(request, new URL(request.url), params, config, ip);
+}
+function createContextFromUrl(request, url, params, config = {}, ip = "") {
   const meta = { headers: {}, setCookies: [] };
   const parsedCookies = parseCookies(request.headers.get("cookie") ?? "");
   const cookiesObj = {};
@@ -370,8 +372,8 @@ function createContext(request, params, config = {}, ip = "") {
   return ctx;
 }
 function createTestContext(options) {
-  const { method = "GET", path: path11, query, headers, params = {}, config = {}, ip = "" } = options;
-  const url = new URL(`http://localhost${path11}`);
+  const { method = "GET", path: path12, query, headers, params = {}, config = {}, ip = "" } = options;
+  const url = new URL(`http://localhost${path12}`);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (Array.isArray(value)) {
@@ -756,7 +758,7 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
 }
 
 // src/testServer.ts
-import path10 from "path";
+import path11 from "path";
 import os from "os";
 import fs9 from "fs/promises";
 
@@ -770,9 +772,9 @@ var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var HTTP_METHOD_SET = new Set(HTTP_METHODS);
 
 // src/utils/normalizePath.ts
-function normalizePath(path11) {
-  if (!path11) return "";
-  let result = path11.replace(/\\/g, "/");
+function normalizePath(path12) {
+  if (!path12) return "";
+  let result = path12.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -1045,27 +1047,131 @@ function sortRoutes(routes) {
 }
 
 // src/cli/generateSchemaFiles.ts
-import path3 from "path";
-import fs2 from "fs/promises";
+import path4 from "path";
+import fs3 from "fs/promises";
 
 // src/ast/createProgram.ts
 import ts2 from "typescript";
+import fs2 from "fs";
+import path2 from "path";
 var programCache = /* @__PURE__ */ new Map();
+var tsConfigCache = /* @__PURE__ */ new Map();
+function findTsConfig(filePath) {
+  let dir = path2.dirname(filePath);
+  const root = path2.parse(dir).root;
+  while (true) {
+    const candidate = path2.join(dir, "tsconfig.json");
+    if (fs2.existsSync(candidate)) {
+      return candidate;
+    }
+    if (dir === root) return null;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function parseTsConfig(tsconfigPath) {
+  const cached = tsConfigCache.get(tsconfigPath);
+  if (cached) return cached;
+  const result = { fileNames: [] };
+  try {
+    const configFile = ts2.readConfigFile(tsconfigPath, (p) => fs2.readFileSync(p, "utf-8"));
+    if (configFile.error) {
+      tsConfigCache.set(tsconfigPath, result);
+      return result;
+    }
+    const config = configFile.config ?? {};
+    const basePath = path2.dirname(tsconfigPath);
+    const parsed = ts2.parseJsonConfigFileContent(
+      config,
+      ts2.sys,
+      basePath,
+      /* existingOptions */
+      void 0,
+      tsconfigPath
+    );
+    result.fileNames = parsed.fileNames;
+    if (parsed.options.module !== void 0) {
+      result.module = parsed.options.module;
+    }
+    if (parsed.options.moduleResolution !== void 0) {
+      result.moduleResolution = parsed.options.moduleResolution;
+    }
+  } catch {
+  }
+  tsConfigCache.set(tsconfigPath, result);
+  return result;
+}
 function createProgram(filePath) {
   const cached = programCache.get(filePath);
   if (cached) {
     return cached;
   }
-  const program = ts2.createProgram([filePath], {
+  const program = buildProgram([filePath], findTsConfig(filePath));
+  programCache.set(filePath, program);
+  return program;
+}
+function createPrograms(filePaths) {
+  const unique = [...new Set(filePaths)];
+  const result = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  const noTsconfigFiles = [];
+  for (const filePath of unique) {
+    const tsconfigPath = findTsConfig(filePath);
+    if (!tsconfigPath) {
+      noTsconfigFiles.push(filePath);
+      continue;
+    }
+    const group = groups.get(tsconfigPath);
+    if (group) {
+      group.files.push(filePath);
+    } else {
+      groups.set(tsconfigPath, { tsconfigPath, files: [filePath] });
+    }
+  }
+  for (const { tsconfigPath, files } of groups.values()) {
+    const cacheKey = `shared::${tsconfigPath}::${[...files].sort().join("|")}`;
+    let program = programCache.get(cacheKey);
+    if (!program) {
+      program = buildProgram(files, tsconfigPath);
+      programCache.set(cacheKey, program);
+    }
+    for (const filePath of files) {
+      result.set(filePath, program);
+    }
+  }
+  for (const filePath of noTsconfigFiles) {
+    result.set(filePath, createProgram(filePath));
+  }
+  return result;
+}
+function buildProgram(entryFiles, tsconfigPath) {
+  const options = {
     strict: true,
     target: ts2.ScriptTarget.ES2022,
     module: ts2.ModuleKind.NodeNext,
     moduleResolution: ts2.ModuleResolutionKind.NodeNext,
     skipLibCheck: true,
     noEmit: true
-  });
-  programCache.set(filePath, program);
-  return program;
+  };
+  const rootNames = [...entryFiles];
+  if (tsconfigPath) {
+    const tsOptions = parseTsConfig(tsconfigPath);
+    if (tsOptions.module !== void 0) {
+      options.module = tsOptions.module;
+    }
+    if (tsOptions.moduleResolution !== void 0) {
+      options.moduleResolution = tsOptions.moduleResolution;
+    }
+    if (tsOptions.fileNames.length > 0) {
+      for (const fileName of tsOptions.fileNames) {
+        if (!rootNames.includes(fileName)) {
+          rootNames.push(fileName);
+        }
+      }
+    }
+  }
+  return ts2.createProgram(rootNames, options);
 }
 
 // src/ast/extractHandlerTypes.ts
@@ -1073,6 +1179,10 @@ import ts4 from "typescript";
 
 // src/ast/resolveTypeNode.ts
 import ts3 from "typescript";
+var currentProgram = null;
+function setProgramContext(program) {
+  currentProgram = program;
+}
 var SchemaExtractionError = class extends Error {
   constructor(typeText, reason, options) {
     super(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B "${typeText}": ${reason}`, options);
@@ -1395,11 +1505,69 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
         if (ts3.isEnumDeclaration(declaration)) {
           return resolveEnumDeclaration(declaration);
         }
+        if (ts3.isImportSpecifier(declaration) || ts3.isImportClause(declaration)) {
+          const resolved = resolveImportAlias(typeNode, symbol, checker, visited);
+          if (resolved) return resolved;
+        }
       }
     }
   }
   throw new SchemaExtractionError(typeNode.getText(), `\u65E0\u6CD5\u89E3\u6790\u7684\u5F15\u7528\u7C7B\u578B "${typeName}"`);
 }
+function resolveImportAlias(typeNode, symbol, checker, visited) {
+  const typeName = typeNode.typeName.getText();
+  try {
+    const aliased = checker.getAliasedSymbol(symbol);
+    if (aliased && aliased.declarations && aliased.declarations.length > 0) {
+      const decl = aliased.declarations[0];
+      if (ts3.isInterfaceDeclaration(decl)) {
+        return resolveInterfaceDeclaration(decl, checker, visited);
+      }
+      if (ts3.isTypeAliasDeclaration(decl)) {
+        return resolveTypeNode(decl.type, checker, visited);
+      }
+      if (ts3.isEnumDeclaration(decl)) {
+        return resolveEnumDeclaration(decl);
+      }
+    }
+  } catch {
+  }
+  const program = currentProgram;
+  if (!program) return null;
+  const allSFs = program.getSourceFiles();
+  for (const sourceFile of allSFs) {
+    if (sourceFile.fileName.includes("/node_modules/") || sourceFile.fileName.includes("typescript/lib/")) {
+      continue;
+    }
+    const found = findTopLevelDecl(sourceFile, typeName);
+    if (found) {
+      if (found.kind === "interface") {
+        return resolveInterfaceDeclaration(found.node, checker, visited);
+      }
+      if (found.kind === "typeAlias") {
+        return resolveTypeNode(found.node.type, checker, visited);
+      }
+      if (found.kind === "enum") {
+        return resolveEnumDeclaration(found.node);
+      }
+    }
+  }
+  return null;
+}
+function findTopLevelDecl(sourceFile, typeName) {
+  let found = null;
+  ts3.forEachChild(sourceFile, (node) => {
+    if (found) return;
+    if (ts3.isInterfaceDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "interface", node };
+    } else if (ts3.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "typeAlias", node };
+    } else if (ts3.isEnumDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "enum", node };
+    }
+  });
+  return found;
+}
 function resolveEnumDeclaration(node) {
   const members = [];
   let nextNumericValue = 0;
@@ -1604,80 +1772,90 @@ function extractTypeInfo(program, filePath, typeName) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
   const checker = program.getTypeChecker();
-  let result = null;
-  ts4.forEachChild(sourceFile, (node) => {
-    if (result) return;
-    if (ts4.isInterfaceDeclaration(node) && node.name.text === typeName) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(typeName);
-      const runtimeType = withFileContext(
-        filePath,
-        typeName,
-        () => resolveInterfaceDeclaration(node, checker, visited)
-      );
-      result = {
-        name: typeName,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      };
-      return;
-    }
-    if (ts4.isTypeAliasDeclaration(node) && node.name.text === typeName) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(typeName);
-      const runtimeType = withFileContext(
-        filePath,
-        typeName,
-        () => resolveTypeNode(node.type, checker, visited)
-      );
-      result = {
-        name: typeName,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      };
-      return;
-    }
-  });
-  return result;
+  setProgramContext(program);
+  try {
+    let result = null;
+    ts4.forEachChild(sourceFile, (node) => {
+      if (result) return;
+      if (ts4.isInterfaceDeclaration(node) && node.name.text === typeName) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(typeName);
+        const runtimeType = withFileContext(
+          filePath,
+          typeName,
+          () => resolveInterfaceDeclaration(node, checker, visited)
+        );
+        result = {
+          name: typeName,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        };
+        return;
+      }
+      if (ts4.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(typeName);
+        const runtimeType = withFileContext(
+          filePath,
+          typeName,
+          () => resolveTypeNode(node.type, checker, visited)
+        );
+        result = {
+          name: typeName,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        };
+        return;
+      }
+    });
+    return result;
+  } finally {
+    setProgramContext(null);
+  }
 }
 function extractAllTypes(program, filePath) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return /* @__PURE__ */ new Map();
   const checker = program.getTypeChecker();
-  const result = /* @__PURE__ */ new Map();
-  ts4.forEachChild(sourceFile, (node) => {
-    if (ts4.isInterfaceDeclaration(node)) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(node.name.text);
-      const runtimeType = withFileContext(
-        filePath,
-        node.name.text,
-        () => resolveInterfaceDeclaration(node, checker, visited)
-      );
-      result.set(node.name.text, {
-        name: node.name.text,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      });
-      return;
-    }
-    if (ts4.isTypeAliasDeclaration(node)) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(node.name.text);
-      const runtimeType = withFileContext(
-        filePath,
-        node.name.text,
-        () => resolveTypeNode(node.type, checker, visited)
-      );
-      result.set(node.name.text, {
-        name: node.name.text,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      });
-      return;
-    }
-  });
-  return result;
+  setProgramContext(program);
+  try {
+    const result = /* @__PURE__ */ new Map();
+    ts4.forEachChild(sourceFile, (node) => {
+      if (ts4.isInterfaceDeclaration(node)) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(node.name.text);
+        const runtimeType = withFileContext(
+          filePath,
+          node.name.text,
+          () => resolveInterfaceDeclaration(node, checker, visited)
+        );
+        result.set(node.name.text, {
+          name: node.name.text,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        });
+        return;
+      }
+      if (ts4.isTypeAliasDeclaration(node)) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(node.name.text);
+        const runtimeType = withFileContext(
+          filePath,
+          node.name.text,
+          () => resolveTypeNode(node.type, checker, visited)
+        );
+        result.set(node.name.text, {
+          name: node.name.text,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        });
+        return;
+      }
+    });
+    return result;
+  } finally {
+    setProgramContext(null);
+  }
 }
 function withFileContext(filePath, typeName, fn) {
   try {
@@ -1760,11 +1938,11 @@ function extractSchema(typeNode, sourceFile) {
 }
 
 // src/cli/collectRouteSchemaSources.ts
-import path2 from "path";
+import path3 from "path";
 function collectRouteSchemaSources(routes, rootDir) {
   const methodsByFile = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    const filePath = rootDir ? path2.resolve(rootDir, route.filePath) : route.filePath;
+    const filePath = rootDir ? path3.resolve(rootDir, route.filePath) : route.filePath;
     let entry = methodsByFile.get(filePath);
     if (!entry) {
       entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
@@ -1772,12 +1950,11 @@ function collectRouteSchemaSources(routes, rootDir) {
     }
     entry.methods.add(route.method);
   }
-  const programByFile = /* @__PURE__ */ new Map();
+  const programByFile = createPrograms([...methodsByFile.keys()]);
   const allTypesByFile = /* @__PURE__ */ new Map();
   const mergedAllTypes = /* @__PURE__ */ new Map();
   for (const filePath of methodsByFile.keys()) {
-    const program = createProgram(filePath);
-    programByFile.set(filePath, program);
+    const program = programByFile.get(filePath);
     const allTypes = extractAllTypes(program, filePath);
     allTypesByFile.set(filePath, allTypes);
     for (const [name, info] of allTypes) {
@@ -2115,7 +2292,7 @@ function getSchemaOutputPath(sourceFile, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path3.resolve(rootDir, dist, relDir, "zod.js");
+  return path4.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getRuntimeSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -2126,7 +2303,7 @@ function getRuntimeSchemaPath(filePath, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path3.resolve(rootDir, dist, relDir, "zod.js");
+  return path4.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -2176,7 +2353,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path3.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path4.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
@@ -2191,7 +2368,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path3.resolve(rootDir, dist, HELPERS_FILENAME);
+    const helpersPath = path4.resolve(rootDir, dist, HELPERS_FILENAME);
     await writeSchemaFile(helpersPath, generateHelpersFileSource());
   }
   await Promise.all(
@@ -2199,22 +2376,22 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   );
 }
 async function writeSchemaFile(outputPath, source) {
-  await fs2.mkdir(path3.dirname(outputPath), { recursive: true });
-  await fs2.writeFile(outputPath, source, "utf-8");
+  await fs3.mkdir(path4.dirname(outputPath), { recursive: true });
+  await fs3.writeFile(outputPath, source, "utf-8");
 }
 
 // src/cli/compileOnDemand.ts
-import path7 from "path";
-import fs6 from "fs";
+import path8 from "path";
+import fs7 from "fs";
 
 // src/cli/compileDevRoutes.ts
-import path6 from "path";
-import fs5 from "fs";
+import path7 from "path";
+import fs6 from "fs";
 import fg2 from "fast-glob";
 
 // src/cli/aliasPlugin.ts
-import path5 from "path";
-import fs4 from "fs";
+import path6 from "path";
+import fs5 from "fs";
 
 // src/utils/resolveAlias.ts
 function resolveAlias(specifier, config) {
@@ -2241,11 +2418,11 @@ function resolveAlias(specifier, config) {
 
 // src/utils/readTsconfig.ts
 import ts6 from "typescript";
-import path4 from "path";
-import fs3 from "fs";
+import path5 from "path";
+import fs4 from "fs";
 function readTsconfig(rootDir) {
-  const tsconfigPath = path4.resolve(rootDir, "tsconfig.json");
-  if (!fs3.existsSync(tsconfigPath)) return null;
+  const tsconfigPath = path5.resolve(rootDir, "tsconfig.json");
+  if (!fs4.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);
@@ -2254,7 +2431,7 @@ function readTsconfig(rootDir) {
   if (!rawPaths) return null;
   const paths = {};
   for (const [pattern, targets] of Object.entries(rawPaths)) {
-    paths[pattern] = targets.map((t) => path4.resolve(baseUrl, t));
+    paths[pattern] = targets.map((t) => path5.resolve(baseUrl, t));
   }
   return { baseUrl, paths };
 }
@@ -2267,29 +2444,29 @@ function toProdExtension(filePath) {
   return filePath;
 }
 function toProdImportPath(sourceFile, importer) {
-  const importerDir = path5.dirname(importer);
-  let rel = path5.relative(importerDir, sourceFile);
-  rel = rel.split(path5.sep).join("/");
+  const importerDir = path6.dirname(importer);
+  let rel = path6.relative(importerDir, sourceFile);
+  rel = rel.split(path6.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
 function toRealPath(p) {
   try {
-    return fs4.realpathSync(p);
+    return fs5.realpathSync(p);
   } catch {
     return p;
   }
 }
 function isInsideDir(filePath, dir) {
-  const rel = path5.relative(dir, filePath);
-  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
+  const rel = path6.relative(dir, filePath);
+  return rel !== "" && !rel.startsWith("..") && !path6.isAbsolute(rel);
 }
 var APP_DIR = "src";
 function toStrippedProdImportPath(sourceFile, rootDir) {
-  const appDirAbs = toRealPath(path5.resolve(rootDir, APP_DIR));
+  const appDirAbs = toRealPath(path6.resolve(rootDir, APP_DIR));
   const sourceReal = toRealPath(sourceFile);
-  let rel = path5.relative(appDirAbs, sourceReal);
-  rel = rel.split(path5.sep).join("/");
+  let rel = path6.relative(appDirAbs, sourceReal);
+  rel = rel.split(path6.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
@@ -2304,34 +2481,34 @@ var INDEX_EXTS = [
   "/index.cjs"
 ];
 function resolveRelativeSpecifier(importer, specifier) {
-  const importerDir = path5.dirname(importer);
-  const base = path5.resolve(importerDir, specifier);
+  const importerDir = path6.dirname(importer);
+  const base = path6.resolve(importerDir, specifier);
   if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
-    return fs4.existsSync(base) ? base : null;
+    return fs5.existsSync(base) ? base : null;
   }
   if (/\.(ts|tsx|jsx)$/.test(specifier)) {
-    return fs4.existsSync(base) ? base : null;
+    return fs5.existsSync(base) ? base : null;
   }
   for (const ext of SOURCE_EXTS) {
     const file = base + ext;
-    if (fs4.existsSync(file)) return file;
+    if (fs5.existsSync(file)) return file;
   }
   for (const indexExt of INDEX_EXTS) {
     const file = base + indexExt;
-    if (fs4.existsSync(file)) return file;
+    if (fs5.existsSync(file)) return file;
   }
   return null;
 }
 function createAliasPlugin(config, options) {
   const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
-  const appDirAbs = options?.rootDir ? toRealPath(path5.resolve(options.rootDir, APP_DIR)) : null;
+  const appDirAbs = options?.rootDir ? toRealPath(path6.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");
+          source = fs5.readFileSync(args.path, "utf8");
         } catch {
           return void 0;
         }
@@ -2364,7 +2541,7 @@ function createAliasPlugin(config, options) {
           for (const candidate of candidates) {
             for (const ext of SOURCE_EXTS) {
               const file = candidate + ext;
-              if (fs4.existsSync(file)) {
+              if (fs5.existsSync(file)) {
                 modified = true;
                 if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
                   return `${prefix}${quote}${toStrippedProdImportPath(
@@ -2377,7 +2554,7 @@ function createAliasPlugin(config, options) {
             }
             for (const indexExt of INDEX_EXTS) {
               const file = candidate + indexExt;
-              if (fs4.existsSync(file)) {
+              if (fs5.existsSync(file)) {
                 modified = true;
                 if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
                   return `${prefix}${quote}${toStrippedProdImportPath(
@@ -2415,11 +2592,11 @@ async function compileDevRoutes(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path6.resolve(rootDir, dist);
-  await fs5.promises.mkdir(absDist, { recursive: true });
+  const absDist = path7.resolve(rootDir, dist);
+  await fs6.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path6.resolve(rootDir, APP_DIR2);
+  const outbase = path7.resolve(rootDir, APP_DIR2);
   const result = await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -2436,10 +2613,10 @@ async function compileDevRoutes(options) {
   if (result.outputFiles) {
     await Promise.all(
       result.outputFiles.map(async (file) => {
-        await fs5.promises.mkdir(path6.dirname(file.path), { recursive: true });
+        await fs6.promises.mkdir(path7.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);
+        await fs6.promises.writeFile(tmp, file.contents);
+        await fs6.promises.rename(tmp, file.path);
       })
     );
   }
@@ -2449,8 +2626,8 @@ async function compileDevRoutes(options) {
 // src/cli/compileOnDemand.ts
 function isProductFresh(sourceAbsPath, productAbsPath) {
   try {
-    const srcStat = fs6.statSync(sourceAbsPath);
-    const prodStat = fs6.statSync(productAbsPath);
+    const srcStat = fs7.statSync(sourceAbsPath);
+    const prodStat = fs7.statSync(productAbsPath);
     return prodStat.mtimeMs >= srcStat.mtimeMs;
   } catch {
     return false;
@@ -2477,7 +2654,7 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
-  if (!fs6.existsSync(sourceAbsPath)) {
+  if (!fs7.existsSync(sourceAbsPath)) {
     return false;
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
@@ -2503,11 +2680,11 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
-  const rel = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  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 path7.resolve(rootDir, dist, jsRel);
+  return path8.resolve(rootDir, dist, jsRel);
 }
 async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist) {
   const inFlight = state.inFlightSchemaGenerations.get(schemaPath);
@@ -2519,9 +2696,9 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
-  const prodAbsPath = path7.resolve(rootDir, routeFilePath);
+  const prodAbsPath = path8.resolve(rootDir, routeFilePath);
   const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
-  if (!fs6.existsSync(sourceAbsPath)) {
+  if (!fs7.existsSync(sourceAbsPath)) {
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
@@ -2532,7 +2709,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (fileRoutes.length === 0) {
     return false;
   }
-  const sourceRelPath = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRelPath = path8.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const generatePromise = (async () => {
     await generateSchemaFiles(sourceRoutes, rootDir, dist);
@@ -2546,17 +2723,26 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
     state.inFlightSchemaGenerations.delete(schemaPath);
   }
 }
+var sourcePathCache = /* @__PURE__ */ new Map();
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
-  const rel = path7.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  const cached = sourcePathCache.get(prodAbsPath);
+  if (cached) return cached;
+  const rel = path8.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
   let relWithoutDist = rel;
   if (relWithoutDist.startsWith(`${dist}/`)) {
     relWithoutDist = relWithoutDist.slice(dist.length + 1);
   }
   const srcRel = `src/${relWithoutDist}`;
   const tsRel = srcRel.replace(/\.js$/, ".ts");
-  const tsAbs = path7.resolve(rootDir, tsRel);
-  if (fs6.existsSync(tsAbs)) return tsAbs;
-  return path7.resolve(rootDir, srcRel);
+  const tsAbs = path8.resolve(rootDir, tsRel);
+  let result;
+  if (fs7.existsSync(tsAbs)) {
+    result = tsAbs;
+  } else {
+    result = path8.resolve(rootDir, srcRel);
+  }
+  sourcePathCache.set(prodAbsPath, result);
+  return result;
 }
 function isDevOnDemandEnabled() {
   return state.enabled;
@@ -2609,9 +2795,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue.code, issue.message);
-    const path11 = issue.path.map(String).join(".") || "";
+    const path12 = issue.path.map(String).join(".") || "";
     return {
-      path: path11,
+      path: path12,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -2659,45 +2845,96 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable2 } from "stream";
-import path9 from "path";
+import path10 from "path";
 
 // src/router/matchRoute.ts
-function matchRoute(routes, method, path11) {
+var httpIndexCache = /* @__PURE__ */ new WeakMap();
+var wsIndexCache = /* @__PURE__ */ new WeakMap();
+function getHttpIndex(routes) {
+  let index = httpIndexCache.get(routes);
+  if (index) return index;
+  index = { static: /* @__PURE__ */ new Map(), methodsByStaticPath: /* @__PURE__ */ new Map(), dynamics: [] };
   for (const route of routes) {
-    if (route.method !== method) {
-      continue;
-    }
-    if (!route.isDynamic) {
-      if (route.urlPath === path11) {
-        return { route, params: {} };
+    if (route.isDynamic) {
+      index.dynamics.push(route);
+    } else {
+      index.static.set(`${route.method}|${route.urlPath}`, route);
+      let methods = index.methodsByStaticPath.get(route.urlPath);
+      if (!methods) {
+        methods = /* @__PURE__ */ new Set();
+        index.methodsByStaticPath.set(route.urlPath, methods);
       }
+      methods.add(route.method);
+    }
+  }
+  httpIndexCache.set(routes, index);
+  return index;
+}
+function getWsIndex(routes) {
+  let index = wsIndexCache.get(routes);
+  if (index) return index;
+  index = { static: /* @__PURE__ */ new Map(), dynamics: [] };
+  for (const route of routes) {
+    if (route.isDynamic) {
+      index.dynamics.push(route);
+    } else {
+      index.static.set(route.urlPath, route);
+    }
+  }
+  wsIndexCache.set(routes, index);
+  return index;
+}
+function matchRoute(routes, method, path12) {
+  const index = getHttpIndex(routes);
+  const staticHit = index.static.get(`${method}|${path12}`);
+  if (staticHit) {
+    return { route: staticHit, params: {} };
+  }
+  for (const route of index.dynamics) {
+    if (route.method !== method) {
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path12, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path11) {
-  for (const route of wsRoutes) {
-    if (!route.isDynamic) {
-      if (route.urlPath === path11) {
-        return { route, params: {} };
-      }
-      continue;
-    }
-    const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
+function matchWsRoute(wsRoutes, path12) {
+  const index = getWsIndex(wsRoutes);
+  const staticHit = index.static.get(path12);
+  if (staticHit) {
+    return { route: staticHit, params: {} };
+  }
+  for (const route of index.dynamics) {
+    const params = matchDynamicPath(route.urlPath, path12, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchDynamicPath(pattern, path11, paramNames, isCatchAll) {
+function findAllowedMethods(routes, path12) {
+  const index = getHttpIndex(routes);
+  const methods = /* @__PURE__ */ new Set();
+  const staticMethods = index.methodsByStaticPath.get(path12);
+  if (staticMethods) {
+    for (const method of staticMethods) {
+      methods.add(method);
+    }
+  }
+  for (const route of index.dynamics) {
+    const params = matchDynamicPath(route.urlPath, path12, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      methods.add(route.method);
+    }
+  }
+  return Array.from(methods);
+}
+function matchDynamicPath(pattern, path12, paramNames, isCatchAll) {
   const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path11.split("/").filter(Boolean);
+  const pathSegments = path12.split("/").filter(Boolean);
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -2742,9 +2979,6 @@ function matchDynamicPath(pattern, path11, paramNames, isCatchAll) {
   return params;
 }
 
-// src/loader/loadRouteModule.ts
-import fs7 from "fs";
-
 // src/loader/resolveExports.ts
 function resolveExport(module, exportName) {
   if (exportName in module && typeof module[exportName] !== "undefined") {
@@ -2775,7 +3009,7 @@ async function loadRouteModule(filePath, method, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs7.existsSync(sourcePath)) {
+      if (sourcePath) {
         try {
           await ensureCompiled(sourcePath, rootDir, dist);
         } catch (compileErr) {
@@ -2840,7 +3074,7 @@ async function parseMultipart(request) {
 }
 
 // src/runtime/resolveInput.ts
-async function resolveInput(method, request) {
+async function resolveInputFromUrl(method, request, url) {
   const inputType = getInputTypeForMethod(method);
   if (inputType === "body") {
     const contentType = request.headers.get("content-type") ?? "";
@@ -2875,7 +3109,6 @@ async function resolveInput(method, request) {
     }
     return result.data;
   }
-  const url = new URL(request.url);
   return queryToObject(url.searchParams);
 }
 
@@ -2904,11 +3137,13 @@ async function sendNodeResponse(response, res) {
 }
 
 // src/utils/getClientIp.ts
-function getClientIp(req) {
-  const xff = req.headers["x-forwarded-for"];
-  if (typeof xff === "string" && xff.length > 0) {
-    const first = xff.split(",")[0]?.trim();
-    if (first) return first;
+function getClientIp(req, trustedProxy = false) {
+  if (trustedProxy) {
+    const xff = req.headers["x-forwarded-for"];
+    if (typeof xff === "string" && xff.length > 0) {
+      const first = xff.split(",")[0]?.trim();
+      if (first) return first;
+    }
   }
   const remote = req.socket?.remoteAddress;
   if (remote) {
@@ -3083,7 +3318,7 @@ function logger(options = {}) {
 // src/server/handleWsUpgrade.ts
 import fs8 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path8 from "path";
+import path9 from "path";
 
 // src/server/serverUtils.ts
 function nodeHttpToWebHeaders(req) {
@@ -3197,7 +3432,7 @@ async function sendResponseToSocket(socket, response) {
   socket.destroy();
 }
 function attachWebSocket(options) {
-  const { server, routesRef, rootDir, config, globalMiddlewares } = options;
+  const { server, routesRef, rootDir, config, globalMiddlewares, trustedProxy = false } = options;
   const wss = new WebSocketServer({ noServer: true });
   server.on("upgrade", async (req, socket, head) => {
     const currentWsRoutes = routesRef.wsCurrent;
@@ -3213,13 +3448,13 @@ function attachWebSocket(options) {
     const host = req.headers.host ?? "localhost";
     const url = `http://${host}${req.url ?? "/"}`;
     const request = new Request(url, { method: "GET", headers });
-    const ctx = createContext(request, params, config, getClientIp(req));
+    const ctx = createContext(request, params, config, getClientIp(req, trustedProxy));
     const meta = ctx.meta;
     let upgraded = false;
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path8.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);
@@ -3282,16 +3517,26 @@ function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
   const headers = nodeHttpToWebHeaders(req);
   const method = req.method ?? "GET";
   if (method === "GET" || method === "HEAD") {
-    return new Request(url.toString(), { method, headers });
+    return { request: new Request(url.toString(), { method, headers }), url };
+  }
+  const contentLength = req.headers["content-length"];
+  if (contentLength !== void 0) {
+    const declared = Number(Array.isArray(contentLength) ? contentLength[0] : contentLength);
+    if (Number.isFinite(declared) && declared > bodyLimit) {
+      throw new PayloadTooLargeError(bodyLimit);
+    }
   }
   const stream = Readable2.toWeb(req);
   const limitedStream = limitStreamSize(stream, bodyLimit);
-  return new Request(url.toString(), {
-    method,
-    headers,
-    body: limitedStream,
-    duplex: "half"
-  });
+  return {
+    request: new Request(url.toString(), {
+      method,
+      headers,
+      body: limitedStream,
+      duplex: "half"
+    }),
+    url
+  };
 }
 function limitStreamSize(stream, maxSize) {
   let totalSize = 0;
@@ -3343,22 +3588,6 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path11) {
-  const methods = /* @__PURE__ */ new Set();
-  for (const route of routes) {
-    if (route.urlPath === path11) {
-      methods.add(route.method);
-      continue;
-    }
-    if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path11, route.paramNames, route.isCatchAll);
-      if (params !== null) {
-        methods.add(route.method);
-      }
-    }
-  }
-  return Array.from(methods);
-}
 function createServer(options) {
   const {
     routes,
@@ -3373,7 +3602,8 @@ function createServer(options) {
     helmet: helmetOption,
     logger: loggerOption,
     bodyLimit = DEFAULT_BODY_LIMIT,
-    http2: http2Option
+    http2: http2Option,
+    trustedProxy = false
   } = options;
   const routesRef = { current: routes, wsCurrent: wsRoutes ?? [] };
   const configMiddlewares = [];
@@ -3385,6 +3615,10 @@ function createServer(options) {
   }
   const loggerMiddlewareInst = loggerOption === false ? null : loggerOption === true || loggerOption === void 0 ? logger() : logger(loggerOption);
   if (loggerMiddlewareInst) configMiddlewares.push(loggerMiddlewareInst);
+  const outerMiddlewares = [...configMiddlewares];
+  if (globalMiddlewares && globalMiddlewares.length > 0) {
+    outerMiddlewares.push(...globalMiddlewares);
+  }
   const server = (() => {
     if (http2Option) {
       const h2Opts = typeof http2Option === "object" ? http2Option : {};
@@ -3404,29 +3638,29 @@ function createServer(options) {
       dist,
       req,
       res,
-      configMiddlewares,
+      outerMiddlewares,
       onError,
       config,
-      globalMiddlewares,
       globalInjectors,
-      bodyLimit
+      bodyLimit,
+      trustedProxy
     ).catch(() => {
       res.statusCode = 500;
       res.end();
     });
   });
   if (routesRef.wsCurrent.length > 0) {
-    attachWebSocket({ server, routesRef, rootDir, config, globalMiddlewares });
+    attachWebSocket({ server, routesRef, rootDir, config, globalMiddlewares, trustedProxy });
   }
   return { server, routesRef };
 }
-function prepareRequest(req, config, bodyLimit) {
-  const request = toWebRequest(req, bodyLimit);
+function prepareRequest(req, config, bodyLimit, trustedProxy) {
+  const { request, url } = toWebRequest(req, bodyLimit);
   const method = request.method.toUpperCase();
-  const urlPath = new URL(request.url).pathname;
-  const ctx = createContext(request, {}, config, getClientIp(req));
+  const urlPath = url.pathname;
+  const ctx = createContextFromUrl(request, url, {}, config, getClientIp(req, trustedProxy));
   const meta = ctx.meta;
-  return { request, ctx, meta, method, urlPath };
+  return { request, url, ctx, meta, method, urlPath };
 }
 function resolveRouteOrThrow(routes, method, urlPath) {
   const match = matchRoute(routes, method, urlPath);
@@ -3438,14 +3672,14 @@ function resolveRouteOrThrow(routes, method, urlPath) {
   throw new RouteNotFoundError(urlPath);
 }
 function createRoutePipeline(opts) {
-  const { routes, method, urlPath, ctx, request, rootDir, dist, globalInjectors } = opts;
+  const { routes, method, urlPath, url, ctx, request, rootDir, dist, globalInjectors } = opts;
   return async () => {
     const match = resolveRouteOrThrow(routes, method, urlPath);
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path9.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 input = await resolveInputFromUrl(route.method, request, url);
     const inputType = getInputTypeForMethod(route.method);
     const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
     if (isDevOnDemandEnabled()) {
@@ -3477,33 +3711,33 @@ async function sendSuccessResponse(response, res) {
   await sendNodeResponse(response, res);
 }
 async function sendErrorResponse(err, meta, res, onError, ctx) {
-  await sendNodeResponse(mergeMeta(buildErrorResponse(err, ctx.config), meta), res);
-  if (onError) {
+  await sendNodeResponse(mergeMeta(buildErrorResponse(err, ctx?.config), meta), res);
+  if (onError && ctx) {
     try {
       await onError(err, ctx);
     } catch {
     }
   }
 }
-async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares, onError, config, globalMiddlewares, globalInjectors, bodyLimit) {
-  const { request, ctx, meta, method, urlPath } = prepareRequest(req, config, bodyLimit);
-  const routePipeline = createRoutePipeline({
-    routes,
-    method,
-    urlPath,
-    ctx,
-    request,
-    rootDir,
-    dist,
-    globalMiddlewares,
-    globalInjectors
-  });
-  const outerMiddlewares = [];
-  if (configMiddlewares.length > 0) outerMiddlewares.push(...configMiddlewares);
-  if (globalMiddlewares && globalMiddlewares.length > 0) {
-    outerMiddlewares.push(...globalMiddlewares);
-  }
+async function handleRequest(routes, rootDir, dist, req, res, outerMiddlewares, onError, config, globalInjectors, bodyLimit, trustedProxy) {
+  let meta = { headers: {}, setCookies: [] };
+  let ctx;
   try {
+    const prepared = prepareRequest(req, config, bodyLimit, trustedProxy);
+    ctx = prepared.ctx;
+    meta = prepared.meta;
+    const { request, url, method, urlPath } = prepared;
+    const routePipeline = createRoutePipeline({
+      routes,
+      method,
+      urlPath,
+      url,
+      ctx,
+      request,
+      rootDir,
+      dist,
+      globalInjectors
+    });
     const response = outerMiddlewares.length > 0 ? await compose(outerMiddlewares, ctx, routePipeline) : await routePipeline();
     await sendSuccessResponse(response, res);
   } catch (err) {
@@ -3530,7 +3764,7 @@ async function createTestServer(options) {
   } = options;
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns);
   const sorted = sortRoutes(routes);
-  const schemaDist = dist ? path10.isAbsolute(dist) ? dist : path10.resolve(rootDir, dist) : await fs9.mkdtemp(path10.join(os.tmpdir(), "faapi-test-schema-"));
+  const schemaDist = dist ? path11.isAbsolute(dist) ? dist : path11.resolve(rootDir, dist) : await fs9.mkdtemp(path11.join(os.tmpdir(), "faapi-test-schema-"));
   await generateSchemaFiles(sorted, rootDir, schemaDist);
   const { server } = createServer({
     routes: sorted,