@faapi/faapi 3.2.0 → 3.3.0

package/dist/cli/index.js

@@ -476,9 +476,9 @@ var init_constants = __esm({
 });
 
 // src/utils/normalizePath.ts
-function normalizePath(path23) {
-  if (!path23) return "";
-  let result = path23.replace(/\\/g, "/");
+function normalizePath(path24) {
+  if (!path24) return "";
+  let result = path24.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -964,35 +964,143 @@ var init_extractToolMetadata = __esm({
 
 // src/ast/createProgram.ts
 import ts3 from "typescript";
+import fs7 from "fs";
+import path7 from "path";
 function invalidateProgramCache() {
   programCache.clear();
+  tsConfigCache.clear();
+}
+function findTsConfig(filePath) {
+  let dir = path7.dirname(filePath);
+  const root = path7.parse(dir).root;
+  while (true) {
+    const candidate = path7.join(dir, "tsconfig.json");
+    if (fs7.existsSync(candidate)) {
+      return candidate;
+    }
+    if (dir === root) return null;
+    const parent = path7.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 = ts3.readConfigFile(tsconfigPath, (p) => fs7.readFileSync(p, "utf-8"));
+    if (configFile.error) {
+      tsConfigCache.set(tsconfigPath, result);
+      return result;
+    }
+    const config = configFile.config ?? {};
+    const basePath = path7.dirname(tsconfigPath);
+    const parsed = ts3.parseJsonConfigFileContent(
+      config,
+      ts3.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 = ts3.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: ts3.ScriptTarget.ES2022,
     module: ts3.ModuleKind.NodeNext,
     moduleResolution: ts3.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 ts3.createProgram(rootNames, options);
 }
-var programCache;
+var programCache, tsConfigCache;
 var init_createProgram = __esm({
   "src/ast/createProgram.ts"() {
     "use strict";
     programCache = /* @__PURE__ */ new Map();
+    tsConfigCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/ast/resolveTypeNode.ts
 import ts4 from "typescript";
+function setProgramContext(program) {
+  currentProgram = program;
+}
 function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
   const kind = typeNode.kind;
   switch (kind) {
@@ -1305,11 +1413,69 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
         if (ts4.isEnumDeclaration(declaration)) {
           return resolveEnumDeclaration(declaration);
         }
+        if (ts4.isImportSpecifier(declaration) || ts4.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 (ts4.isInterfaceDeclaration(decl)) {
+        return resolveInterfaceDeclaration(decl, checker, visited);
+      }
+      if (ts4.isTypeAliasDeclaration(decl)) {
+        return resolveTypeNode(decl.type, checker, visited);
+      }
+      if (ts4.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;
+  ts4.forEachChild(sourceFile, (node) => {
+    if (found) return;
+    if (ts4.isInterfaceDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "interface", node };
+    } else if (ts4.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "typeAlias", node };
+    } else if (ts4.isEnumDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "enum", node };
+    }
+  });
+  return found;
+}
 function resolveEnumDeclaration(node) {
   const members = [];
   let nextNumericValue = 0;
@@ -1488,10 +1654,11 @@ function validateConstraints(constraints, type, fieldName) {
     }
   }
 }
-var SchemaExtractionError, NUMBER_CONSTRAINT_KINDS, LENGTH_CONSTRAINT_KINDS, STRING_FORMAT_CONSTRAINT_KINDS;
+var currentProgram, SchemaExtractionError, NUMBER_CONSTRAINT_KINDS, LENGTH_CONSTRAINT_KINDS, STRING_FORMAT_CONSTRAINT_KINDS;
 var init_resolveTypeNode = __esm({
   "src/ast/resolveTypeNode.ts"() {
     "use strict";
+    currentProgram = null;
     SchemaExtractionError = class extends Error {
       constructor(typeText, reason, options) {
         super(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B "${typeText}": ${reason}`, options);
@@ -1531,80 +1698,90 @@ function extractTypeInfo(program, filePath, typeName) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
   const checker = program.getTypeChecker();
-  let result = null;
-  ts5.forEachChild(sourceFile, (node) => {
-    if (result) return;
-    if (ts5.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 (ts5.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;
+    ts5.forEachChild(sourceFile, (node) => {
+      if (result) return;
+      if (ts5.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 (ts5.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();
-  ts5.forEachChild(sourceFile, (node) => {
-    if (ts5.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 (ts5.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();
+    ts5.forEachChild(sourceFile, (node) => {
+      if (ts5.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 (ts5.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 {
@@ -2110,11 +2287,11 @@ var init_analyzeInjection = __esm({
 });
 
 // src/cli/collectRouteSchemaSources.ts
-import path7 from "path";
+import path8 from "path";
 function collectRouteSchemaSources(routes, rootDir) {
   const methodsByFile = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    const filePath = rootDir ? path7.resolve(rootDir, route.filePath) : route.filePath;
+    const filePath = rootDir ? path8.resolve(rootDir, route.filePath) : route.filePath;
     let entry = methodsByFile.get(filePath);
     if (!entry) {
       entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
@@ -2122,12 +2299,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) {
@@ -2177,8 +2353,8 @@ __export(generateSchemaFiles_exports, {
   getRuntimeSchemaPath: () => getRuntimeSchemaPath,
   getSchemaOutputPath: () => getSchemaOutputPath
 });
-import path8 from "path";
-import fs7 from "fs/promises";
+import path9 from "path";
+import fs8 from "fs/promises";
 function getSchemaOutputPath(sourceFile, dist, rootDir) {
   let rel = sourceFile.replace(/\\/g, "/");
   if (rel.startsWith("src/")) {
@@ -2186,7 +2362,7 @@ function getSchemaOutputPath(sourceFile, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path8.resolve(rootDir, dist, relDir, "zod.js");
+  return path9.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getRuntimeSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -2197,7 +2373,7 @@ function getRuntimeSchemaPath(filePath, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path8.resolve(rootDir, dist, relDir, "zod.js");
+  return path9.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -2247,7 +2423,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path8.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path9.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
@@ -2262,7 +2438,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path8.resolve(rootDir, dist, HELPERS_FILENAME);
+    const helpersPath = path9.resolve(rootDir, dist, HELPERS_FILENAME);
     await writeSchemaFile(helpersPath, generateHelpersFileSource());
   }
   await Promise.all(
@@ -2270,8 +2446,8 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   );
 }
 async function writeSchemaFile(outputPath, source) {
-  await fs7.mkdir(path8.dirname(outputPath), { recursive: true });
-  await fs7.writeFile(outputPath, source, "utf-8");
+  await fs8.mkdir(path9.dirname(outputPath), { recursive: true });
+  await fs8.writeFile(outputPath, source, "utf-8");
 }
 var init_generateSchemaFiles = __esm({
   "src/cli/generateSchemaFiles.ts"() {
@@ -2282,8 +2458,8 @@ var init_generateSchemaFiles = __esm({
 });
 
 // src/cli/generateToolArtifacts.ts
-import path9 from "path";
-import fs8 from "fs/promises";
+import path10 from "path";
+import fs9 from "fs/promises";
 import { existsSync } from "fs";
 function getToolSchemaOutputPath(sourceFile, dist, rootDir) {
   let rel = sourceFile.replace(/\\/g, "/");
@@ -2292,7 +2468,7 @@ function getToolSchemaOutputPath(sourceFile, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path9.resolve(rootDir, dist, relDir, "zod.js");
+  return path10.resolve(rootDir, dist, relDir, "zod.js");
 }
 function toProdFilePath3(filePath, dist) {
   let rel = filePath.replace(/\\/g, "/");
@@ -2312,12 +2488,12 @@ function serializeTools(tools, dist = "dist") {
   }));
 }
 async function writeToolsModule(manifest, outputPath) {
-  const dir = path9.dirname(outputPath);
-  await fs8.mkdir(dir, { recursive: true });
+  const dir = path10.dirname(outputPath);
+  await fs9.mkdir(dir, { recursive: true });
   const content = `// \u81EA\u52A8\u751F\u6210,\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91(faapi build/dev \u4EA7\u7269)
 export const tools = ${JSON.stringify(manifest, null, 2)};
 `;
-  await fs8.writeFile(outputPath, content, "utf-8");
+  await fs9.writeFile(outputPath, content, "utf-8");
 }
 function hydrateTools(manifest) {
   return manifest.map((t) => ({
@@ -2332,7 +2508,7 @@ function collectToolSchemaSources(tools, rootDir) {
   const toolsByFile = /* @__PURE__ */ new Map();
   for (const tool of tools) {
     if (!tool.inputTypeName) continue;
-    const absPath = path9.resolve(rootDir, tool.filePath);
+    const absPath = path10.resolve(rootDir, tool.filePath);
     let list = toolsByFile.get(absPath);
     if (!list) {
       list = [];
@@ -2340,15 +2516,16 @@ function collectToolSchemaSources(tools, rootDir) {
     }
     list.push(tool);
   }
+  const programByFile = createPrograms([...toolsByFile.keys()]);
   const allTypesByFile = /* @__PURE__ */ new Map();
   for (const filePath of toolsByFile.keys()) {
-    const program = createProgram(filePath);
+    const program = programByFile.get(filePath);
     const allTypes = extractAllTypes(program, filePath);
     allTypesByFile.set(filePath, allTypes);
   }
   const sources = [];
   for (const [filePath, fileTools] of toolsByFile) {
-    const program = createProgram(filePath);
+    const program = programByFile.get(filePath);
     for (const tool of fileTools) {
       const inputTypeName = tool.inputTypeName;
       const typeInfo = extractTypeInfo(program, filePath, inputTypeName);
@@ -2394,16 +2571,17 @@ function generateToolSchemaFileSource(sources, allTypes, helpersImportPath) {
 }
 async function maybeGenerateHelpers(allSourceCode, distDir) {
   if (!usesCoerceHelpers(allSourceCode)) return;
-  const helpersPath = path9.resolve(distDir, HELPERS_FILENAME);
+  const helpersPath = path10.resolve(distDir, HELPERS_FILENAME);
   if (existsSync(helpersPath)) return;
-  await fs8.mkdir(path9.dirname(helpersPath), { recursive: true });
-  await fs8.writeFile(helpersPath, generateHelpersFileSource(), "utf-8");
+  await fs9.mkdir(path10.dirname(helpersPath), { recursive: true });
+  await fs9.writeFile(helpersPath, generateHelpersFileSource(), "utf-8");
 }
 async function generateToolArtifacts(tools, rootDir, dist, options) {
   const metadata = [];
+  const programByFile = createPrograms(tools.map((m) => path10.resolve(rootDir, m.filePath)));
   for (const manifest of tools) {
-    const absPath = path9.resolve(rootDir, manifest.filePath);
-    const program = createProgram(absPath);
+    const absPath = path10.resolve(rootDir, manifest.filePath);
+    const program = programByFile.get(absPath);
     const result = extractToolMetadata(program, absPath, manifest.functionName, {
       name: manifest.name,
       filePath: manifest.filePath
@@ -2413,7 +2591,7 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
     }
   }
   const serialized = serializeTools(metadata, dist);
-  const toolsPath = path9.resolve(rootDir, dist, TOOLS_FILE);
+  const toolsPath = path10.resolve(rootDir, dist, TOOLS_FILE);
   await writeToolsModule(serialized, toolsPath);
   if (options?.skipSchema) {
     return metadata;
@@ -2436,7 +2614,7 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path9.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path10.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getToolSchemaOutputPath(relFile, dist, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
@@ -2450,7 +2628,7 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
     fileEntries.push({ outputPath, source });
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
-  const distDir = path9.resolve(rootDir, dist);
+  const distDir = path10.resolve(rootDir, dist);
   await maybeGenerateHelpers(allSourceCode, distDir);
   await Promise.all(
     fileEntries.map(({ outputPath, source }) => writeToolSchemaFile(outputPath, source))
@@ -2458,8 +2636,8 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
   return metadata;
 }
 async function writeToolSchemaFile(outputPath, source) {
-  await fs8.mkdir(path9.dirname(outputPath), { recursive: true });
-  await fs8.writeFile(outputPath, source, "utf-8");
+  await fs9.mkdir(path10.dirname(outputPath), { recursive: true });
+  await fs9.writeFile(outputPath, source, "utf-8");
 }
 var TOOLS_FILE;
 var init_generateToolArtifacts = __esm({
@@ -2476,8 +2654,8 @@ var init_generateToolArtifacts = __esm({
 
 // src/agents/scanAgents.ts
 import fg3 from "fast-glob";
-import path10 from "path";
-import fs9 from "fs";
+import path11 from "path";
+import fs10 from "fs";
 function extractAgentNameFromPath(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
   const match = normalized.match(/(?:^|\/)agents\/([^/]+)\/handler\.ts$/);
@@ -2507,8 +2685,8 @@ async function scanAgents(rootDir, patterns) {
     if (fileName !== "handler.ts" && fileName !== "handler.js") {
       continue;
     }
-    const absPath = path10.resolve(rootDir, normalizedFile);
-    const source = await fs9.promises.readFile(absPath, "utf8").catch(() => "");
+    const absPath = path11.resolve(rootDir, normalizedFile);
+    const source = await fs10.promises.readFile(absPath, "utf8").catch(() => "");
     const { hasRun } = detectAgentExports(source);
     const name = extractAgentNameFromPath(normalizedFile);
     const prevFile = seen.get(name);
@@ -2728,8 +2906,8 @@ var init_extractAgentMetadata = __esm({
 });
 
 // src/cli/generateAgentArtifacts.ts
-import path11 from "path";
-import fs10 from "fs/promises";
+import path12 from "path";
+import fs11 from "fs/promises";
 function toProdFilePath4(filePath, dist) {
   let rel = filePath.replace(/\\/g, "/");
   if (rel.startsWith("src/")) {
@@ -2752,12 +2930,12 @@ function serializeAgents(agents, dist = "dist") {
   }));
 }
 async function writeAgentsModule(manifest, outputPath) {
-  const dir = path11.dirname(outputPath);
-  await fs10.mkdir(dir, { recursive: true });
+  const dir = path12.dirname(outputPath);
+  await fs11.mkdir(dir, { recursive: true });
   const content = `// \u81EA\u52A8\u751F\u6210,\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91(faapi build/dev \u4EA7\u7269)
 export const agents = ${JSON.stringify(manifest, null, 2)};
 `;
-  await fs10.writeFile(outputPath, content, "utf-8");
+  await fs11.writeFile(outputPath, content, "utf-8");
 }
 function hydrateAgents(manifest) {
   return manifest.map((a) => ({
@@ -2774,9 +2952,10 @@ function hydrateAgents(manifest) {
 }
 async function generateAgentArtifacts(agents, rootDir, dist) {
   const metadata = [];
+  const programByFile = createPrograms(agents.map((m) => path12.resolve(rootDir, m.filePath)));
   for (const manifest of agents) {
-    const absPath = path11.resolve(rootDir, manifest.filePath);
-    const program = createProgram(absPath);
+    const absPath = path12.resolve(rootDir, manifest.filePath);
+    const program = programByFile.get(absPath);
     const result = extractAgentMetadata(program, absPath, {
       name: manifest.name,
       filePath: manifest.filePath,
@@ -2787,7 +2966,7 @@ async function generateAgentArtifacts(agents, rootDir, dist) {
     }
   }
   const serialized = serializeAgents(metadata, dist);
-  const agentsPath = path11.resolve(rootDir, dist, AGENTS_FILE);
+  const agentsPath = path12.resolve(rootDir, dist, AGENTS_FILE);
   await writeAgentsModule(serialized, agentsPath);
   return metadata;
 }
@@ -2802,15 +2981,15 @@ var init_generateAgentArtifacts = __esm({
 });
 
 // src/config/loadConfig.ts
-import path12 from "path";
-import fs11 from "fs";
+import path13 from "path";
+import fs12 from "fs";
 async function loadConfig(rootDir, dist) {
-  const configProductPath = path12.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
-  if (fs11.existsSync(configProductPath)) {
+  const configProductPath = path13.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
+  if (fs12.existsSync(configProductPath)) {
     const module = await importWithCacheBust(configProductPath);
     return module.default ?? {};
   }
-  const hasSourceConfig = fs11.existsSync(path12.join(rootDir, "faapi.config.ts")) || fs11.existsSync(path12.join(rootDir, "faapi.config.js"));
+  const hasSourceConfig = fs12.existsSync(path13.join(rootDir, "faapi.config.ts")) || fs12.existsSync(path13.join(rootDir, "faapi.config.js"));
   if (hasSourceConfig) {
     throw new Error(
       `[faapi] ${dist}/${CONFIG_PRODUCT_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
@@ -2828,8 +3007,8 @@ var init_loadConfig = __esm({
 });
 
 // src/cli/loadEnv.ts
-import fs12 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path14 from "path";
 function resolveEnv() {
   return process.env.NODE_ENV || "development";
 }
@@ -2895,9 +3074,9 @@ function loadEnv(rootDir) {
   const files = getEnvFiles(env);
   const merged = {};
   for (const file of files) {
-    const filePath = path13.join(rootDir, file);
-    if (!fs12.existsSync(filePath)) continue;
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const filePath = path14.join(rootDir, file);
+    if (!fs13.existsSync(filePath)) continue;
+    const content = fs13.readFileSync(filePath, "utf-8");
     const parsed = parseEnvFile(content, merged);
     Object.assign(merged, parsed);
   }
@@ -3003,7 +3182,7 @@ var init_esm = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? lstat : stat;
         if (wantBigintFsStats) {
-          this._stat = (path23) => statMethod(path23, { bigint: true });
+          this._stat = (path24) => statMethod(path24, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -3028,8 +3207,8 @@ var init_esm = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path23, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
+              const { path: path24, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path24));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -3069,20 +3248,20 @@ var init_esm = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path23, depth) {
+      async _exploreDir(path24, depth) {
         let files;
         try {
-          files = await readdir(path23, this._rdOptions);
+          files = await readdir(path24, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path23 };
+        return { files, depth, path: path24 };
       }
-      async _formatEntry(dirent, path23) {
+      async _formatEntry(dirent, path24) {
         let entry;
         const basename3 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = presolve(pjoin(path23, basename3));
+          const fullPath = presolve(pjoin(path24, basename3));
           entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -3143,16 +3322,16 @@ import { watchFile, unwatchFile, watch as fs_watch } from "fs";
 import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
-function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path24, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path23);
-    emitRaw(rawEvent, evPath, { watchedPath: path23 });
-    if (evPath && path23 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path23, evPath), KEY_LISTENERS, sysPath.join(path23, evPath));
+    listener(path24);
+    emitRaw(rawEvent, evPath, { watchedPath: path24 });
+    if (evPath && path24 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path24, evPath), KEY_LISTENERS, sysPath.join(path24, evPath));
     }
   };
   try {
-    return fs_watch(path23, {
+    return fs_watch(path24, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -3497,12 +3676,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path23, fullPath, options, handlers) => {
+    setFsWatchListener = (path24, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path24, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -3513,7 +3692,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path23,
+          path24,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -3528,7 +3707,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error.code === "EPERM") {
             try {
-              const fd = await open(path23, "r");
+              const fd = await open(path24, "r");
               await fd.close();
               broadcastErr(error);
             } catch (err) {
@@ -3559,7 +3738,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path23, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path24, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -3581,7 +3760,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path23, curr));
+              foreach(cont.listeners, (listener2) => listener2(path24, curr));
             }
           })
         };
@@ -3609,13 +3788,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path23, listener) {
+      _watchWithNodeFs(path24, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path23);
-        const basename3 = sysPath.basename(path23);
+        const directory = sysPath.dirname(path24);
+        const basename3 = sysPath.basename(path24);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename3);
-        const absolutePath = sysPath.resolve(path23);
+        const absolutePath = sysPath.resolve(path24);
         const options = {
           persistent: opts.persistent
         };
@@ -3625,12 +3804,12 @@ var init_handler = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path23, absolutePath, options, {
+          closer = setFsWatchFileListener(path24, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path23, absolutePath, options, {
+          closer = setFsWatchListener(path24, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -3652,7 +3831,7 @@ var init_handler = __esm({
         let prevStats = stats;
         if (parent.has(basename3))
           return;
-        const listener = async (path23, newStats) => {
+        const listener = async (path24, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -3666,11 +3845,11 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path23);
+                this.fsw._closeFile(path24);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path23, closer2);
+                  this.fsw._addPathCloser(path24, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -3702,7 +3881,7 @@ var init_handler = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path23, item) {
+      async _handleSymlink(entry, directory, path24, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -3712,7 +3891,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await fsrealpath(path23);
+            linkPath = await fsrealpath(path24);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -3722,12 +3901,12 @@ var init_handler = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path23, entry.stats);
+              this.fsw._emit(EV.CHANGE, path24, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path23, entry.stats);
+            this.fsw._emit(EV.ADD, path24, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -3756,9 +3935,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path23 = sysPath.join(directory, item);
+          let path24 = sysPath.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path24, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -3767,8 +3946,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path23 = sysPath.join(dir, sysPath.relative(dir, path23));
-            this._addToNodeFs(path23, initialAdd, wh, depth + 1);
+            path24 = sysPath.join(dir, sysPath.relative(dir, path24));
+            this._addToNodeFs(path24, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve3, reject) => {
@@ -3837,13 +4016,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path24, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path23) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path24) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path23);
+        const wh = this.fsw._getWatchHelpers(path24);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -3859,8 +4038,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path23);
-            const targetPath = follow ? await fsrealpath(path23) : path23;
+            const absPath = sysPath.resolve(path24);
+            const targetPath = follow ? await fsrealpath(path24) : path24;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -3870,29 +4049,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await fsrealpath(path23) : path23;
+            const targetPath = follow ? await fsrealpath(path24) : path24;
             if (this.fsw.closed)
               return;
             const parent = sysPath.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path24, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path23), targetPath);
+              this.fsw._symlinkPaths.set(sysPath.resolve(path24), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path23, closer);
+            this.fsw._addPathCloser(path24, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path23;
+            return path24;
           }
         }
       }
@@ -3931,26 +4110,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path23) {
-  if (typeof path23 !== "string")
+function normalizePath2(path24) {
+  if (typeof path24 !== "string")
     throw new Error("string expected");
-  path23 = sysPath2.normalize(path23);
-  path23 = path23.replace(/\\/g, "/");
+  path24 = sysPath2.normalize(path24);
+  path24 = path24.replace(/\\/g, "/");
   let prepend = false;
-  if (path23.startsWith("//"))
+  if (path24.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path23.match(DOUBLE_SLASH_RE2))
-    path23 = path23.replace(DOUBLE_SLASH_RE2, "/");
+  while (path24.match(DOUBLE_SLASH_RE2))
+    path24 = path24.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path23 = "/" + path23;
-  return path23;
+    path24 = "/" + path24;
+  return path24;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path23 = normalizePath2(testString);
+  const path24 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path23, stats)) {
+    if (pattern(path24, stats)) {
       return true;
     }
   }
@@ -4011,19 +4190,19 @@ var init_esm2 = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path23) => toUnix(sysPath2.normalize(toUnix(path23)));
-    normalizeIgnored = (cwd = "") => (path23) => {
-      if (typeof path23 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path23) ? path23 : sysPath2.join(cwd, path23));
+    normalizePathToUnix = (path24) => toUnix(sysPath2.normalize(toUnix(path24)));
+    normalizeIgnored = (cwd = "") => (path24) => {
+      if (typeof path24 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path24) ? path24 : sysPath2.join(cwd, path24));
       } else {
-        return path23;
+        return path24;
       }
     };
-    getAbsolutePath = (path23, cwd) => {
-      if (sysPath2.isAbsolute(path23)) {
-        return path23;
+    getAbsolutePath = (path24, cwd) => {
+      if (sysPath2.isAbsolute(path24)) {
+        return path24;
       }
-      return sysPath2.join(cwd, path23);
+      return sysPath2.join(cwd, path24);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -4078,10 +4257,10 @@ var init_esm2 = __esm({
     STAT_METHOD_F = "stat";
     STAT_METHOD_L = "lstat";
     WatchHelper = class {
-      constructor(path23, follow, fsw) {
+      constructor(path24, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path23;
-        this.path = path23 = path23.replace(REPLACER_RE, "");
+        const watchPath = path24;
+        this.path = path24 = path24.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sysPath2.resolve(watchPath);
         this.dirParts = [];
@@ -4203,20 +4382,20 @@ var init_esm2 = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path23) => {
-            const absPath = getAbsolutePath(path23, cwd);
+          paths = paths.map((path24) => {
+            const absPath = getAbsolutePath(path24, cwd);
             return absPath;
           });
         }
-        paths.forEach((path23) => {
-          this._removeIgnoredPath(path23);
+        paths.forEach((path24) => {
+          this._removeIgnoredPath(path24);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path23) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path24) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path24, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -4238,17 +4417,17 @@ var init_esm2 = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path23) => {
-          if (!sysPath2.isAbsolute(path23) && !this._closers.has(path23)) {
+        paths.forEach((path24) => {
+          if (!sysPath2.isAbsolute(path24) && !this._closers.has(path24)) {
             if (cwd)
-              path23 = sysPath2.join(cwd, path23);
-            path23 = sysPath2.resolve(path23);
+              path24 = sysPath2.join(cwd, path24);
+            path24 = sysPath2.resolve(path24);
           }
-          this._closePath(path23);
-          this._addIgnoredPath(path23);
-          if (this._watched.has(path23)) {
+          this._closePath(path24);
+          this._addIgnoredPath(path24);
+          if (this._watched.has(path24)) {
             this._addIgnoredPath({
-              path: path23,
+              path: path24,
               recursive: true
             });
           }
@@ -4312,38 +4491,38 @@ var init_esm2 = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path23, stats) {
+      async _emit(event, path24, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path23 = sysPath2.normalize(path23);
+          path24 = sysPath2.normalize(path24);
         if (opts.cwd)
-          path23 = sysPath2.relative(opts.cwd, path23);
-        const args = [path23];
+          path24 = sysPath2.relative(opts.cwd, path24);
+        const args = [path24];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path23))) {
+        if (awf && (pw = this._pendingWrites.get(path24))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path23, [event, ...args]);
+            this._pendingUnlinks.set(path24, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path24) => {
+              this._pendingUnlinks.forEach((entry, path25) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path24);
+                this._pendingUnlinks.delete(path25);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path24)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path23);
+            this._pendingUnlinks.delete(path24);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -4361,16 +4540,16 @@ var init_esm2 = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path24, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path24, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path23) : path23;
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path24) : path24;
           let stats2;
           try {
             stats2 = await stat3(fullPath);
@@ -4401,23 +4580,23 @@ var init_esm2 = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path23, timeout) {
+      _throttle(actionType, path24, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path23);
+        const actionPath = action.get(path24);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path23);
+          const item = action.get(path24);
           const count = item ? item.count : 0;
-          action.delete(path23);
+          action.delete(path24);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -4425,7 +4604,7 @@ var init_esm2 = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path23, thr);
+        action.set(path24, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -4439,44 +4618,44 @@ var init_esm2 = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path23, threshold, event, awfEmit) {
+      _awaitWriteFinish(path24, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path23;
-        if (this.options.cwd && !sysPath2.isAbsolute(path23)) {
-          fullPath = sysPath2.join(this.options.cwd, path23);
+        let fullPath = path24;
+        if (this.options.cwd && !sysPath2.isAbsolute(path24)) {
+          fullPath = sysPath2.join(this.options.cwd, path24);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           statcb(fullPath, (err, curStat) => {
-            if (err || !writes.has(path23)) {
+            if (err || !writes.has(path24)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path23).lastChange = now2;
+              writes.get(path24).lastChange = now2;
             }
-            const pw = writes.get(path23);
+            const pw = writes.get(path24);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path23);
+              writes.delete(path24);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path23)) {
-          writes.set(path23, {
+        if (!writes.has(path24)) {
+          writes.set(path24, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path23);
+              writes.delete(path24);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -4487,8 +4666,8 @@ var init_esm2 = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path23, stats) {
-        if (this.options.atomic && DOT_RE.test(path23))
+      _isIgnored(path24, stats) {
+        if (this.options.atomic && DOT_RE.test(path24))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -4498,17 +4677,17 @@ var init_esm2 = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path23, stats);
+        return this._userIgnored(path24, stats);
       }
-      _isntIgnored(path23, stat4) {
-        return !this._isIgnored(path23, stat4);
+      _isntIgnored(path24, stat4) {
+        return !this._isIgnored(path24, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path23) {
-        return new WatchHelper(path23, this.options.followSymlinks, this);
+      _getWatchHelpers(path24) {
+        return new WatchHelper(path24, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -4540,63 +4719,63 @@ var init_esm2 = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path23 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path23);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path23, 100))
+        const path24 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path24);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path24) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path24, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path23);
+        const wp = this._getWatchedDir(path24);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path24, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path23;
+        let relPath = path24;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path23);
+          relPath = sysPath2.relative(this.options.cwd, path24);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path23);
+        this._watched.delete(path24);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path23))
-          this._emit(eventName, path23);
-        this._closePath(path23);
+        if (wasTracked && !this._isIgnored(path24))
+          this._emit(eventName, path24);
+        this._closePath(path24);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path23) {
-        this._closeFile(path23);
-        const dir = sysPath2.dirname(path23);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path23));
+      _closePath(path24) {
+        this._closeFile(path24);
+        const dir = sysPath2.dirname(path24);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path24));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path23) {
-        const closers = this._closers.get(path23);
+      _closeFile(path24) {
+        const closers = this._closers.get(path24);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path23);
+        this._closers.delete(path24);
       }
-      _addPathCloser(path23, closer) {
+      _addPathCloser(path24, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path23);
+        let list = this._closers.get(path24);
         if (!list) {
           list = [];
-          this._closers.set(path23, list);
+          this._closers.set(path24, list);
         }
         list.push(closer);
       }
@@ -4623,8 +4802,8 @@ var init_esm2 = __esm({
 });
 
 // src/cli/compileDevRoutes.ts
-import path14 from "path";
-import fs13 from "fs";
+import path15 from "path";
+import fs14 from "fs";
 import fg4 from "fast-glob";
 async function compileDevRoutes(options) {
   const { rootDir, dist, files, logLevel = "silent" } = options;
@@ -4637,11 +4816,11 @@ async function compileDevRoutes(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path14.resolve(rootDir, dist);
-  await fs13.promises.mkdir(absDist, { recursive: true });
+  const absDist = path15.resolve(rootDir, dist);
+  await fs14.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path14.resolve(rootDir, APP_DIR2);
+  const outbase = path15.resolve(rootDir, APP_DIR2);
   const result = await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -4658,10 +4837,10 @@ async function compileDevRoutes(options) {
   if (result.outputFiles) {
     await Promise.all(
       result.outputFiles.map(async (file) => {
-        await fs13.promises.mkdir(path14.dirname(file.path), { recursive: true });
+        await fs14.promises.mkdir(path15.dirname(file.path), { recursive: true });
         const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-        await fs13.promises.writeFile(tmp, file.contents);
-        await fs13.promises.rename(tmp, file.path);
+        await fs14.promises.writeFile(tmp, file.contents);
+        await fs14.promises.rename(tmp, file.path);
       })
     );
   }
@@ -4677,7 +4856,7 @@ var init_compileDevRoutes = __esm({
 });
 
 // src/cli/watcher.ts
-import path15 from "path";
+import path16 from "path";
 function startWatcher(options) {
   const { rootDir, app, devDist } = options;
   let rebuildTimer = null;
@@ -4727,11 +4906,11 @@ function startWatcher(options) {
     }
   });
   watcher.on("add", (file) => {
-    pendingFiles.add(path15.resolve(rootDir, file));
+    pendingFiles.add(path16.resolve(rootDir, file));
     scheduleRebuild();
   });
   watcher.on("change", (file) => {
-    pendingFiles.add(path15.resolve(rootDir, file));
+    pendingFiles.add(path16.resolve(rootDir, file));
     scheduleRebuild();
   });
   watcher.on("unlink", () => {
@@ -4788,42 +4967,91 @@ var init_detectRouteConflicts = __esm({
 });
 
 // src/router/matchRoute.ts
-function matchRoute(routes, method, path23) {
+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 === path23) {
-        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, path24) {
+  const index = getHttpIndex(routes);
+  const staticHit = index.static.get(`${method}|${path24}`);
+  if (staticHit) {
+    return { route: staticHit, params: {} };
+  }
+  for (const route of index.dynamics) {
+    if (route.method !== method) {
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path23, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path24, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path23) {
-  for (const route of wsRoutes) {
-    if (!route.isDynamic) {
-      if (route.urlPath === path23) {
-        return { route, params: {} };
-      }
-      continue;
-    }
-    const params = matchDynamicPath(route.urlPath, path23, route.paramNames, route.isCatchAll);
+function matchWsRoute(wsRoutes, path24) {
+  const index = getWsIndex(wsRoutes);
+  const staticHit = index.static.get(path24);
+  if (staticHit) {
+    return { route: staticHit, params: {} };
+  }
+  for (const route of index.dynamics) {
+    const params = matchDynamicPath(route.urlPath, path24, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchDynamicPath(pattern, path23, paramNames, isCatchAll) {
+function findAllowedMethods(routes, path24) {
+  const index = getHttpIndex(routes);
+  const methods = /* @__PURE__ */ new Set();
+  const staticMethods = index.methodsByStaticPath.get(path24);
+  if (staticMethods) {
+    for (const method of staticMethods) {
+      methods.add(method);
+    }
+  }
+  for (const route of index.dynamics) {
+    const params = matchDynamicPath(route.urlPath, path24, route.paramNames, route.isCatchAll);
+    if (params !== null) {
+      methods.add(route.method);
+    }
+  }
+  return Array.from(methods);
+}
+function matchDynamicPath(pattern, path24, paramNames, isCatchAll) {
   const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path23.split("/").filter(Boolean);
+  const pathSegments = path24.split("/").filter(Boolean);
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -4867,9 +5095,12 @@ function matchDynamicPath(pattern, path23, paramNames, isCatchAll) {
   }
   return params;
 }
+var httpIndexCache, wsIndexCache;
 var init_matchRoute = __esm({
   "src/router/matchRoute.ts"() {
     "use strict";
+    httpIndexCache = /* @__PURE__ */ new WeakMap();
+    wsIndexCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -4908,12 +5139,12 @@ var init_validateRouteModule = __esm({
 });
 
 // src/cli/compileOnDemand.ts
-import path16 from "path";
-import fs14 from "fs";
+import path17 from "path";
+import fs15 from "fs";
 function isProductFresh(sourceAbsPath, productAbsPath) {
   try {
-    const srcStat = fs14.statSync(sourceAbsPath);
-    const prodStat = fs14.statSync(productAbsPath);
+    const srcStat = fs15.statSync(sourceAbsPath);
+    const prodStat = fs15.statSync(productAbsPath);
     return prodStat.mtimeMs >= srcStat.mtimeMs;
   } catch {
     return false;
@@ -4932,6 +5163,7 @@ function createDevOnDemandState() {
 function clearCompiledFiles() {
   state.compiledFiles.clear();
   state.inFlightCompilations.clear();
+  sourcePathCache.clear();
 }
 async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   const inFlight = state.inFlightCompilations.get(sourceAbsPath);
@@ -4943,7 +5175,7 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
-  if (!fs14.existsSync(sourceAbsPath)) {
+  if (!fs15.existsSync(sourceAbsPath)) {
     return false;
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
@@ -4969,11 +5201,11 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
-  const rel = path16.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const rel = path17.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   if (!rel.startsWith("src/")) return null;
   const relWithoutSrc = rel.slice(4);
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
-  return path16.resolve(rootDir, dist, jsRel);
+  return path17.resolve(rootDir, dist, jsRel);
 }
 function clearGeneratedSchemas() {
   state.generatedSchemas.clear();
@@ -4989,9 +5221,9 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
-  const prodAbsPath = path16.resolve(rootDir, routeFilePath);
+  const prodAbsPath = path17.resolve(rootDir, routeFilePath);
   const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
-  if (!fs14.existsSync(sourceAbsPath)) {
+  if (!fs15.existsSync(sourceAbsPath)) {
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
@@ -5002,7 +5234,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (fileRoutes.length === 0) {
     return false;
   }
-  const sourceRelPath = path16.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRelPath = path17.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const generatePromise = (async () => {
     await generateSchemaFiles(sourceRoutes, rootDir, dist);
@@ -5023,22 +5255,30 @@ async function deleteSchemaFiles(routes, rootDir, dist) {
     if (deleted.has(schemaPath)) continue;
     deleted.add(schemaPath);
     try {
-      await fs14.promises.unlink(schemaPath);
+      await fs15.promises.unlink(schemaPath);
     } catch {
     }
   }
 }
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
-  const rel = path16.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  const cached = sourcePathCache.get(prodAbsPath);
+  if (cached) return cached;
+  const rel = path17.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 = path16.resolve(rootDir, tsRel);
-  if (fs14.existsSync(tsAbs)) return tsAbs;
-  return path16.resolve(rootDir, srcRel);
+  const tsAbs = path17.resolve(rootDir, tsRel);
+  let result;
+  if (fs15.existsSync(tsAbs)) {
+    result = tsAbs;
+  } else {
+    result = path17.resolve(rootDir, srcRel);
+  }
+  sourcePathCache.set(prodAbsPath, result);
+  return result;
 }
 function setDevOnDemandEnabled(enabled) {
   state.enabled = enabled;
@@ -5052,7 +5292,7 @@ function setDevDist(dist) {
 function getDevDist() {
   return state.distDir;
 }
-var state;
+var state, sourcePathCache;
 var init_compileOnDemand = __esm({
   "src/cli/compileOnDemand.ts"() {
     "use strict";
@@ -5060,17 +5300,17 @@ var init_compileOnDemand = __esm({
     init_generateSchemaFiles();
     init_generateSchemaFiles();
     state = createDevOnDemandState();
+    sourcePathCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/loader/loadRouteModule.ts
-import fs15 from "fs";
 async function loadRouteModule(filePath, method, rootDir) {
   if (isDevOnDemandEnabled() && rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs15.existsSync(sourcePath)) {
+      if (sourcePath) {
         try {
           await ensureCompiled(sourcePath, rootDir, dist);
         } catch (compileErr) {
@@ -5250,14 +5490,14 @@ var init_httpErrors = __esm({
       issues;
     };
     RouteNotFoundError = class extends FaapiError {
-      constructor(path23) {
-        super("ROUTE_NOT_FOUND", `Route not found: ${path23}`, 404);
+      constructor(path24) {
+        super("ROUTE_NOT_FOUND", `Route not found: ${path24}`, 404);
         this.name = "RouteNotFoundError";
       }
     };
     MethodNotAllowedError = class extends FaapiError {
-      constructor(method, path23, allowedMethods) {
-        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path23}`, 405);
+      constructor(method, path24, allowedMethods) {
+        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path24}`, 405);
         this.allowedMethods = allowedMethods;
         this.name = "MethodNotAllowedError";
       }
@@ -5396,7 +5636,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 = {};
@@ -5572,7 +5814,7 @@ var init_parseMultipart = __esm({
 });
 
 // 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") ?? "";
@@ -5607,7 +5849,6 @@ async function resolveInput(method, request) {
     }
     return result.data;
   }
-  const url = new URL(request.url);
   return queryToObject(url.searchParams);
 }
 var init_resolveInput = __esm({
@@ -6031,9 +6272,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue.code, issue.message);
-    const path23 = issue.path.map(String).join(".") || "";
+    const path24 = issue.path.map(String).join(".") || "";
     return {
-      path: path23,
+      path: path24,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -6086,11 +6327,13 @@ var init_validateInput = __esm({
 });
 
 // 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) {
@@ -6349,7 +6592,7 @@ var init_wsHandler = __esm({
 // src/server/handleWsUpgrade.ts
 import fs16 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path17 from "path";
+import path18 from "path";
 function getPathname(req) {
   const url = req.url ?? "/";
   const idx = url.indexOf("?");
@@ -6418,7 +6661,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;
@@ -6434,13 +6677,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 = path17.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path18.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -6514,7 +6757,7 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable3 } from "stream";
-import path18 from "path";
+import path19 from "path";
 function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
   const forwardedProto = req.headers["x-forwarded-proto"];
   const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
@@ -6523,16 +6766,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 = Readable3.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;
@@ -6584,22 +6837,6 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path23) {
-  const methods = /* @__PURE__ */ new Set();
-  for (const route of routes) {
-    if (route.urlPath === path23) {
-      methods.add(route.method);
-      continue;
-    }
-    if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path23, route.paramNames, route.isCatchAll);
-      if (params !== null) {
-        methods.add(route.method);
-      }
-    }
-  }
-  return Array.from(methods);
-}
 function createServer(options) {
   const {
     routes,
@@ -6614,7 +6851,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 = [];
@@ -6626,6 +6864,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 : {};
@@ -6645,29 +6887,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);
@@ -6679,14 +6921,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 = path18.resolve(rootDir, route.filePath);
+    const absoluteFilePath = path19.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()) {
@@ -6718,33 +6960,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) {
@@ -6888,10 +7130,10 @@ var init_skillRegistry = __esm({
 
 // src/cli/createAppCore.ts
 import fs17 from "fs";
-import path19 from "path";
+import path20 from "path";
 import { PassThrough, Readable as Readable4 } from "stream";
 async function loadAndHydrateTools(rootDir, dist) {
-  const toolsPath = path19.resolve(rootDir, dist, TOOLS_FILE2);
+  const toolsPath = path20.resolve(rootDir, dist, TOOLS_FILE2);
   if (!fs17.existsSync(toolsPath)) {
     return [];
   }
@@ -6901,7 +7143,7 @@ async function loadAndHydrateTools(rootDir, dist) {
   return hydrated;
 }
 async function loadAndHydrateAgents(rootDir, dist) {
-  const agentsPath = path19.resolve(rootDir, dist, AGENTS_FILE2);
+  const agentsPath = path20.resolve(rootDir, dist, AGENTS_FILE2);
   if (!fs17.existsSync(agentsPath)) {
     return [];
   }
@@ -6926,7 +7168,7 @@ 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 = path19.resolve(rootDir, dist, ROUTES_FILE);
+  const routesPath = path20.resolve(rootDir, dist, ROUTES_FILE);
   if (!fs17.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`
@@ -6962,7 +7204,8 @@ async function createAppBase(options) {
     helmet: config?.helmet,
     logger: config?.logger,
     bodyLimit: config?.bodyLimit,
-    http2: config?.http2
+    http2: config?.http2,
+    trustedProxy: config?.trustedProxy
   });
   const { handlerWrappers, upgradeWrappers } = await loadPlugins(config?.plugins, {
     rootDir,
@@ -7181,6 +7424,7 @@ var init_createAppCore = __esm({
       "bodyLimit",
       "logger",
       "http2",
+      "trustedProxy",
       "response"
     ]);
   }
@@ -7253,7 +7497,7 @@ __export(devCommand_exports, {
   generateRouteArtifacts: () => generateRouteArtifacts,
   generateToolArtifactsForDev: () => generateToolArtifactsForDev
 });
-import path20 from "path";
+import path21 from "path";
 async function devCommand(options) {
   const rootDir = process.cwd();
   if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
@@ -7280,7 +7524,7 @@ async function devCommand(options) {
 async function generateRouteArtifacts(rootDir, patterns, dist) {
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, dist);
   const sorted = sortRoutes(routes);
-  const routesPath = path20.resolve(rootDir, dist, ROUTES_FILE2);
+  const routesPath = path21.resolve(rootDir, dist, ROUTES_FILE2);
   const serialized = serializeRoutes(sorted, wsRoutes, rootDir, dist);
   await writeRoutesModule(serialized, routesPath);
 }
@@ -7318,7 +7562,7 @@ var init_devCommand = __esm({
 });
 
 // src/cli/compileBuildRoutes.ts
-import path21 from "path";
+import path22 from "path";
 import fs18 from "fs";
 import fg5 from "fast-glob";
 async function compileBuildRoutes(options) {
@@ -7332,11 +7576,11 @@ async function compileBuildRoutes(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path21.resolve(rootDir, dist);
+  const absDist = path22.resolve(rootDir, dist);
   await fs18.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path21.resolve(rootDir, APP_DIR3);
+  const outbase = path22.resolve(rootDir, APP_DIR3);
   await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -7367,7 +7611,7 @@ var buildCommand_exports = {};
 __export(buildCommand_exports, {
   buildCommand: () => buildCommand
 });
-import path22 from "path";
+import path23 from "path";
 import fs19 from "fs";
 async function buildCommand(options) {
   const rootDir = options?.rootDir ?? process.cwd();
@@ -7412,9 +7656,9 @@ async function buildCommand(options) {
   }
   console.log("\n[4/8] Generating schema...");
   await generateSchemaFiles(sorted, rootDir, outdir);
-  console.log(`  Schema: zod.js files under ${path22.resolve(rootDir, outdir)}`);
+  console.log(`  Schema: zod.js files under ${path23.resolve(rootDir, outdir)}`);
   console.log("\n[5/8] Generating routes manifest...");
-  const routesPath = path22.resolve(rootDir, outdir, "faapi-routes.js");
+  const routesPath = path23.resolve(rootDir, outdir, "faapi-routes.js");
   const serialized = serializeRoutes(sorted, wsRoutes, rootDir, outdir);
   await writeRoutesModule(serialized, routesPath);
   console.log(`  Written to ${routesPath}`);
@@ -7422,14 +7666,14 @@ async function buildCommand(options) {
   const tools = await scanTools(rootDir, TOOL_PATTERNS);
   const toolMeta = await generateToolArtifacts(tools, rootDir, outdir);
   console.log(`  Found ${toolMeta.length} tool(s)`);
-  console.log(`  Tool manifest: ${path22.resolve(rootDir, outdir, "faapi-tools.js")}`);
+  console.log(`  Tool manifest: ${path23.resolve(rootDir, outdir, "faapi-tools.js")}`);
   console.log("\n[7/8] Generating agent manifest...");
   const agents = await scanAgents(rootDir, DEFAULT_AGENT_PATTERNS);
   const agentMeta = await generateAgentArtifacts(agents, rootDir, outdir);
   console.log(`  Found ${agentMeta.length} agent(s)`);
-  console.log(`  Agent manifest: ${path22.resolve(rootDir, outdir, "faapi-agents.js")}`);
+  console.log(`  Agent manifest: ${path23.resolve(rootDir, outdir, "faapi-agents.js")}`);
   console.log("\n[8/8] Generating entry file...");
-  const mainPath = path22.resolve(rootDir, outdir, "main.js");
+  const mainPath = path23.resolve(rootDir, outdir, "main.js");
   const createProdAppArgs = options?.dist && options.dist !== DEFAULT_DIST2 ? `{ dist: '${outdir}' }` : "";
   const mainContent = `// \u7531 faapi build \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91
 import { createProdApp, loadEnv } from '@faapi/faapi';