@faapi/faapi 3.2.1 → 3.3.0

package/dist/cli/index.js

@@ -1021,6 +1021,45 @@ function createProgram(filePath) {
   if (cached) {
     return cached;
   }
+  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,
@@ -1029,8 +1068,7 @@ function createProgram(filePath) {
     skipLibCheck: true,
     noEmit: true
   };
-  let rootNames = [filePath];
-  const tsconfigPath = findTsConfig(filePath);
+  const rootNames = [...entryFiles];
   if (tsconfigPath) {
     const tsOptions = parseTsConfig(tsconfigPath);
     if (tsOptions.module !== void 0) {
@@ -1040,16 +1078,14 @@ function createProgram(filePath) {
       options.moduleResolution = tsOptions.moduleResolution;
     }
     if (tsOptions.fileNames.length > 0) {
-      if (!tsOptions.fileNames.includes(filePath)) {
-        rootNames = [filePath, ...tsOptions.fileNames];
-      } else {
-        rootNames = tsOptions.fileNames;
+      for (const fileName of tsOptions.fileNames) {
+        if (!rootNames.includes(fileName)) {
+          rootNames.push(fileName);
+        }
       }
     }
   }
-  const program = ts3.createProgram(rootNames, options);
-  programCache.set(filePath, program);
-  return program;
+  return ts3.createProgram(rootNames, options);
 }
 var programCache, tsConfigCache;
 var init_createProgram = __esm({
@@ -2263,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) {
@@ -2481,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);
@@ -2542,9 +2578,10 @@ async function maybeGenerateHelpers(allSourceCode, distDir) {
 }
 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 = path10.resolve(rootDir, manifest.filePath);
-    const program = createProgram(absPath);
+    const program = programByFile.get(absPath);
     const result = extractToolMetadata(program, absPath, manifest.functionName, {
       name: manifest.name,
       filePath: manifest.filePath
@@ -2915,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 = path12.resolve(rootDir, manifest.filePath);
-    const program = createProgram(absPath);
+    const program = programByFile.get(absPath);
     const result = extractAgentMetadata(program, absPath, {
       name: manifest.name,
       filePath: manifest.filePath,
@@ -4929,15 +4967,48 @@ var init_detectRouteConflicts = __esm({
 });
 
 // src/router/matchRoute.ts
-function matchRoute(routes, method, path24) {
+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 === path24) {
-        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, path24, route.paramNames, route.isCatchAll);
@@ -4948,13 +5019,12 @@ function matchRoute(routes, method, path24) {
   return null;
 }
 function matchWsRoute(wsRoutes, path24) {
-  for (const route of wsRoutes) {
-    if (!route.isDynamic) {
-      if (route.urlPath === path24) {
-        return { route, params: {} };
-      }
-      continue;
-    }
+  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 };
@@ -4962,6 +5032,23 @@ function matchWsRoute(wsRoutes, path24) {
   }
   return null;
 }
+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 = path24.split("/").filter(Boolean);
@@ -5008,9 +5095,12 @@ function matchDynamicPath(pattern, path24, 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();
   }
 });
 
@@ -5073,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);
@@ -5170,6 +5261,8 @@ async function deleteSchemaFiles(routes, rootDir, dist) {
   }
 }
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
+  const cached = sourcePathCache.get(prodAbsPath);
+  if (cached) return cached;
   const rel = path17.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
   let relWithoutDist = rel;
   if (relWithoutDist.startsWith(`${dist}/`)) {
@@ -5178,8 +5271,14 @@ function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   const srcRel = `src/${relWithoutDist}`;
   const tsRel = srcRel.replace(/\.js$/, ".ts");
   const tsAbs = path17.resolve(rootDir, tsRel);
-  if (fs15.existsSync(tsAbs)) return tsAbs;
-  return path17.resolve(rootDir, srcRel);
+  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;
@@ -5193,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";
@@ -5201,17 +5300,17 @@ var init_compileOnDemand = __esm({
     init_generateSchemaFiles();
     init_generateSchemaFiles();
     state = createDevOnDemandState();
+    sourcePathCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/loader/loadRouteModule.ts
-import fs16 from "fs";
 async function loadRouteModule(filePath, method, rootDir) {
   if (isDevOnDemandEnabled() && rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs16.existsSync(sourcePath)) {
+      if (sourcePath) {
         try {
           await ensureCompiled(sourcePath, rootDir, dist);
         } catch (compileErr) {
@@ -5537,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 = {};
@@ -5713,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") ?? "";
@@ -5748,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({
@@ -6227,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) {
@@ -6488,7 +6590,7 @@ var init_wsHandler = __esm({
 });
 
 // src/server/handleWsUpgrade.ts
-import fs17 from "fs";
+import fs16 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
 import path18 from "path";
 function getPathname(req) {
@@ -6501,7 +6603,7 @@ async function loadWsHandler(filePath, ctx, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs17.existsSync(sourcePath)) {
+      if (sourcePath && fs16.existsSync(sourcePath)) {
         await ensureCompiled(sourcePath, rootDir, dist);
       }
     }
@@ -6559,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;
@@ -6575,7 +6677,7 @@ 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 () => {
@@ -6664,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;
@@ -6725,22 +6837,6 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path24) {
-  const methods = /* @__PURE__ */ new Set();
-  for (const route of routes) {
-    if (route.urlPath === path24) {
-      methods.add(route.method);
-      continue;
-    }
-    if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path24, route.paramNames, route.isCatchAll);
-      if (params !== null) {
-        methods.add(route.method);
-      }
-    }
-  }
-  return Array.from(methods);
-}
 function createServer(options) {
   const {
     routes,
@@ -6755,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 = [];
@@ -6767,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 : {};
@@ -6786,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);
@@ -6820,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 = 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()) {
@@ -6859,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) {
@@ -7028,12 +7129,12 @@ var init_skillRegistry = __esm({
 });
 
 // src/cli/createAppCore.ts
-import fs18 from "fs";
+import fs17 from "fs";
 import path20 from "path";
 import { PassThrough, Readable as Readable4 } from "stream";
 async function loadAndHydrateTools(rootDir, dist) {
   const toolsPath = path20.resolve(rootDir, dist, TOOLS_FILE2);
-  if (!fs18.existsSync(toolsPath)) {
+  if (!fs17.existsSync(toolsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(toolsPath);
@@ -7043,7 +7144,7 @@ async function loadAndHydrateTools(rootDir, dist) {
 }
 async function loadAndHydrateAgents(rootDir, dist) {
   const agentsPath = path20.resolve(rootDir, dist, AGENTS_FILE2);
-  if (!fs18.existsSync(agentsPath)) {
+  if (!fs17.existsSync(agentsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(agentsPath);
@@ -7068,7 +7169,7 @@ async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
   const routesPath = path20.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs18.existsSync(routesPath)) {
+  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`
     );
@@ -7103,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,
@@ -7322,6 +7424,7 @@ var init_createAppCore = __esm({
       "bodyLimit",
       "logger",
       "http2",
+      "trustedProxy",
       "response"
     ]);
   }
@@ -7460,7 +7563,7 @@ var init_devCommand = __esm({
 
 // src/cli/compileBuildRoutes.ts
 import path22 from "path";
-import fs19 from "fs";
+import fs18 from "fs";
 import fg5 from "fast-glob";
 async function compileBuildRoutes(options) {
   const { rootDir, dist, files, logLevel = "silent" } = options;
@@ -7474,7 +7577,7 @@ async function compileBuildRoutes(options) {
     return { compiledFiles: [] };
   }
   const absDist = path22.resolve(rootDir, dist);
-  await fs19.promises.mkdir(absDist, { recursive: true });
+  await fs18.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
   const outbase = path22.resolve(rootDir, APP_DIR3);
@@ -7509,7 +7612,7 @@ __export(buildCommand_exports, {
   buildCommand: () => buildCommand
 });
 import path23 from "path";
-import fs20 from "fs";
+import fs19 from "fs";
 async function buildCommand(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const outdir = options?.dist ?? DEFAULT_DIST2;
@@ -7582,7 +7685,7 @@ loadEnv(process.cwd());
 const app = await createProdApp(${createProdAppArgs});
 await app.listen();
 `;
-  await fs20.promises.writeFile(mainPath, mainContent, "utf-8");
+  await fs19.promises.writeFile(mainPath, mainContent, "utf-8");
   console.log(`  Written to ${mainPath}`);
   console.log("\nfaapi build completed");
 }