@forklaunch/core 0.12.3 → 0.13.0

package/lib/http/index.mjs

@@ -81,10 +81,10 @@ function isTypedHandler(maybeTypedHandler) {
 
 // src/http/middleware/request/auth.middleware.ts
 import { isNever } from "@forklaunch/common";
-import { jwtVerify } from "jose";
 
 // src/http/discriminateAuthMethod.ts
-function discriminateAuthMethod(auth) {
+import { jwtVerify } from "jose";
+async function discriminateAuthMethod(auth) {
   if ("basic" in auth) {
     return {
       type: "basic",
@@ -93,18 +93,59 @@ function discriminateAuthMethod(auth) {
         login: auth.basic.login
       }
     };
-  } else if ("jwt" in auth) {
+  } else if ("jwt" in auth && auth.jwt != null) {
+    const jwt = auth.jwt;
+    let verificationFunction;
+    if ("privateKey" in jwt) {
+      verificationFunction = async (token) => {
+        const { payload } = await jwtVerify(token, Buffer.from(jwt.privateKey));
+        return payload;
+      };
+    } else {
+      let jwks;
+      if ("jwksPublicKeyUrl" in jwt) {
+        const jwksResponse = await fetch(jwt.jwksPublicKeyUrl);
+        jwks = (await jwksResponse.json()).keys;
+      } else {
+        jwks = [jwt.jwksPublicKey];
+      }
+      verificationFunction = async (token) => {
+        for (const key of jwks) {
+          try {
+            const { payload } = await jwtVerify(token, key);
+            return payload;
+          } catch {
+            continue;
+          }
+        }
+      };
+    }
     return {
       type: "jwt",
       auth: {
-        decodeResource: auth.decodeResource
+        decodeResource: auth.decodeResource,
+        verificationFunction
+      }
+    };
+  } else if ("secretKey" in auth) {
+    return {
+      type: "system",
+      auth: {
+        secretKey: auth.secretKey
       }
     };
   } else {
     return {
       type: "jwt",
       auth: {
-        decodeResource: auth.decodeResource
+        decodeResource: auth.decodeResource,
+        verificationFunction: async (token) => {
+          const { payload } = await jwtVerify(
+            token,
+            Buffer.from(process.env.JWT_SECRET_KEY)
+          );
+          return payload;
+        }
       }
     };
   }
@@ -112,12 +153,22 @@ function discriminateAuthMethod(auth) {
 
 // src/http/guards/hasPermissionChecks.ts
 function hasPermissionChecks(maybePermissionedAuth) {
-  return typeof maybePermissionedAuth === "object" && maybePermissionedAuth !== null && "mapPermissions" in maybePermissionedAuth && ("allowedPermissions" in maybePermissionedAuth || "forbiddenPermissions" in maybePermissionedAuth);
+  return typeof maybePermissionedAuth === "object" && maybePermissionedAuth !== null && ("allowedPermissions" in maybePermissionedAuth || "forbiddenPermissions" in maybePermissionedAuth);
 }
 
 // src/http/guards/hasRoleChecks.ts
 function hasRoleChecks(maybeRoledAuth) {
-  return typeof maybeRoledAuth === "object" && maybeRoledAuth !== null && "mapRoles" in maybeRoledAuth && ("allowedRoles" in maybeRoledAuth || "forbiddenRoles" in maybeRoledAuth);
+  return typeof maybeRoledAuth === "object" && maybeRoledAuth !== null && ("allowedRoles" in maybeRoledAuth || "forbiddenRoles" in maybeRoledAuth);
+}
+
+// src/http/guards/hasScopeChecks.ts
+function hasScopeChecks(maybePermissionedAuth) {
+  return typeof maybePermissionedAuth === "object" && maybePermissionedAuth !== null && "requiredScope" in maybePermissionedAuth && maybePermissionedAuth.requiredScope != null;
+}
+
+// src/http/guards/isSystemAuthMethod.ts
+function isSystemAuthMethod(maybeSystemAuthMethod) {
+  return typeof maybeSystemAuthMethod === "object" && maybeSystemAuthMethod !== null && "secretKey" in maybeSystemAuthMethod;
 }
 
 // src/http/middleware/request/auth.middleware.ts
@@ -145,23 +196,45 @@ var invalidAuthorizationLogin = [
   403,
   "Invalid Authorization login."
 ];
-async function checkAuthorizationToken(authorizationMethod, authorizationToken, req) {
+var invalidScope = [403, "Invalid scope for operation."];
+var invalidAuthorizationMethod = [
+  401,
+  "Invalid Authorization method."
+];
+var authorizationTokenRequired = [
+  401,
+  "Authorization token required."
+];
+async function checkAuthorizationToken(authorizationMethod, globalOptions, authorizationToken, req) {
+  if (authorizationMethod == null) {
+    return void 0;
+  }
+  const collapsedAuthorizationMethod = {
+    ...globalOptions,
+    ...authorizationMethod
+  };
   if (authorizationToken == null) {
-    return [401, "No Authorization token provided."];
+    return authorizationTokenRequired;
   }
   const [tokenPrefix, token] = authorizationToken.split(" ");
   let resourceId;
-  const { type, auth } = discriminateAuthMethod(authorizationMethod);
+  const { type, auth } = await discriminateAuthMethod(
+    collapsedAuthorizationMethod
+  );
   switch (type) {
+    case "system": {
+      if (token !== auth.secretKey || tokenPrefix !== collapsedAuthorizationMethod.tokenPrefix) {
+        return invalidAuthorizationToken;
+      }
+      resourceId = null;
+      break;
+    }
     case "jwt": {
-      if (tokenPrefix !== (authorizationMethod.tokenPrefix ?? "Bearer")) {
+      if (tokenPrefix !== (collapsedAuthorizationMethod.tokenPrefix ?? "Bearer")) {
         return invalidAuthorizationTokenFormat;
       }
       try {
-        const decodedJwt = await auth?.decodeResource?.(token) ?? (await jwtVerify(
-          token,
-          new TextEncoder().encode(process.env.JWT_SECRET)
-        )).payload;
+        const decodedJwt = "decodeResource" in auth && auth.decodeResource ? await auth.decodeResource(token) : "verificationFunction" in auth && auth.verificationFunction ? await auth.verificationFunction(token) : void 0;
         if (!decodedJwt) {
           return invalidAuthorizationSubject;
         }
@@ -173,7 +246,7 @@ async function checkAuthorizationToken(authorizationMethod, authorizationToken,
       break;
     }
     case "basic": {
-      if (tokenPrefix !== (authorizationMethod.tokenPrefix ?? "Basic")) {
+      if (tokenPrefix !== (collapsedAuthorizationMethod.tokenPrefix ?? "Basic")) {
         return invalidAuthorizationTokenFormat;
       }
       if (auth.decodeResource) {
@@ -196,62 +269,82 @@ async function checkAuthorizationToken(authorizationMethod, authorizationToken,
       isNever(type);
       return [401, "Invalid Authorization method."];
   }
-  if (hasPermissionChecks(authorizationMethod)) {
-    if (!authorizationMethod.mapPermissions) {
-      return [500, "No permission mapping function provided."];
+  if (isSystemAuthMethod(collapsedAuthorizationMethod) || resourceId == null) {
+    return;
+  }
+  if (hasScopeChecks(collapsedAuthorizationMethod)) {
+    if (collapsedAuthorizationMethod.surfaceScopes) {
+      const resourceScopes = await collapsedAuthorizationMethod.surfaceScopes(
+        resourceId,
+        req
+      );
+      if (collapsedAuthorizationMethod.scopeHeirarchy) {
+        if (collapsedAuthorizationMethod.requiredScope) {
+          if (!resourceScopes.has(collapsedAuthorizationMethod.requiredScope) || Array.from(resourceScopes).every(
+            (scope) => collapsedAuthorizationMethod.scopeHeirarchy?.indexOf(scope) ?? -1 > -1
+          )) {
+            return invalidScope;
+          }
+        }
+      }
     }
-    const resourcePermissions = await authorizationMethod.mapPermissions(
+  }
+  if (hasPermissionChecks(collapsedAuthorizationMethod)) {
+    if (!collapsedAuthorizationMethod.surfacePermissions) {
+      return [500, "No permission surfacing function provided."];
+    }
+    const resourcePermissions = await collapsedAuthorizationMethod.surfacePermissions(
       resourceId,
       req
     );
-    if ("allowedPermissions" in authorizationMethod && authorizationMethod.allowedPermissions) {
-      if (resourcePermissions.intersection(authorizationMethod.allowedPermissions).size === 0) {
+    if ("allowedPermissions" in collapsedAuthorizationMethod && collapsedAuthorizationMethod.allowedPermissions) {
+      if (resourcePermissions.intersection(
+        collapsedAuthorizationMethod.allowedPermissions
+      ).size === 0) {
         return invalidAuthorizationTokenPermissions;
       }
     }
-    if ("forbiddenPermissions" in authorizationMethod && authorizationMethod.forbiddenPermissions) {
+    if ("forbiddenPermissions" in collapsedAuthorizationMethod && collapsedAuthorizationMethod.forbiddenPermissions) {
       if (resourcePermissions.intersection(
-        authorizationMethod.forbiddenPermissions
+        collapsedAuthorizationMethod.forbiddenPermissions
       ).size !== 0) {
         return invalidAuthorizationTokenPermissions;
       }
     }
-  } else if (hasRoleChecks(authorizationMethod)) {
-    if (!authorizationMethod.mapRoles) {
-      return [500, "No role mapping function provided."];
+  } else if (hasRoleChecks(collapsedAuthorizationMethod)) {
+    if (!collapsedAuthorizationMethod.surfaceRoles) {
+      return [500, "No role surfacing function provided."];
     }
-    const resourceRoles = await authorizationMethod.mapRoles(
+    const resourceRoles = await collapsedAuthorizationMethod.surfaceRoles(
       resourceId,
       req
     );
-    if ("allowedRoles" in authorizationMethod && authorizationMethod.allowedRoles) {
-      if (resourceRoles.intersection(authorizationMethod.allowedRoles).size === 0) {
+    if ("allowedRoles" in collapsedAuthorizationMethod && collapsedAuthorizationMethod.allowedRoles) {
+      if (resourceRoles.intersection(collapsedAuthorizationMethod.allowedRoles).size === 0) {
         return invalidAuthorizationTokenRoles;
       }
     }
-    if ("forbiddenRoles" in authorizationMethod && authorizationMethod.forbiddenRoles) {
-      if (resourceRoles.intersection(authorizationMethod.forbiddenRoles).size !== 0) {
+    if ("forbiddenRoles" in collapsedAuthorizationMethod && collapsedAuthorizationMethod.forbiddenRoles) {
+      if (resourceRoles.intersection(collapsedAuthorizationMethod.forbiddenRoles).size !== 0) {
         return invalidAuthorizationTokenRoles;
       }
     }
   } else {
-    return [401, "Invalid Authorization method."];
+    return invalidAuthorizationMethod;
   }
 }
 async function parseRequestAuth(req, res, next) {
   const auth = req.contractDetails.auth;
-  if (auth) {
-    const [error, message] = await checkAuthorizationToken(
-      auth,
-      req.headers[auth.headerName ?? "Authorization"] || req.headers[auth.headerName ?? "authorization"],
-      // we can safely cast here because we know that the user will supply resolution for the request
-      req
-    ) ?? [];
-    if (error != null) {
-      res.type("text/plain");
-      res.status(error).send(message);
-      return;
-    }
+  const [error, message] = await checkAuthorizationToken(
+    auth,
+    req._globalOptions?.auth,
+    req.headers[auth?.headerName ?? "Authorization"] || req.headers[auth?.headerName ?? "authorization"],
+    req
+  ) ?? [];
+  if (error != null) {
+    res.type("text/plain");
+    res.status(error).send(message);
+    return;
   }
   next?.();
 }
@@ -330,7 +423,7 @@ import { isNever as isNever2 } from "@forklaunch/common";
 import { trace as trace2 } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import pino from "pino";
-import PinoPretty from "pino-pretty";
+import * as PinoPretty from "pino-pretty";
 
 // src/http/guards/isLoggerMeta.ts
 function isLoggerMeta(arg) {
@@ -377,11 +470,35 @@ function normalizeLogArgs(args) {
   const metadata = Object.assign({}, ...metaObjects);
   return [metadata, message.trim()];
 }
+function safePrettyFormat(level, args, timestamp) {
+  try {
+    const [metadata, message] = normalizeLogArgs(args);
+    const formattedTimestamp = timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    return `[${formattedTimestamp}] ${level.toUpperCase()}: ${message}${Object.keys(metadata).length > 0 ? `
+${JSON.stringify(metadata, null, 2)}` : ""}`;
+  } catch (error) {
+    const fallbackMessage = args.map((arg) => {
+      try {
+        if (typeof arg === "string") return arg;
+        if (arg === null) return "null";
+        if (arg === void 0) return "undefined";
+        return JSON.stringify(arg);
+      } catch {
+        return "[Circular/Non-serializable Object]";
+      }
+    }).join(" ");
+    return `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()}: ${fallbackMessage} [Pretty Print Error: ${error instanceof Error ? error.message : "Unknown error"}]`;
+  }
+}
 var PinoLogger = class _PinoLogger {
   pinoLogger;
   meta;
   prettyPrinter = PinoPretty.prettyFactory({
-    colorize: true
+    colorize: true,
+    // Add error handling options
+    errorLikeObjectKeys: ["err", "error"],
+    ignore: "pid,hostname",
+    translateTime: "SYS:standard"
   });
   constructor(level, meta2 = {}) {
     this.pinoLogger = pino({
@@ -394,7 +511,12 @@ var PinoLogger = class _PinoLogger {
       timestamp: pino.stdTimeFunctions.isoTime,
       transport: {
         target: "pino-pretty",
-        options: { colorize: true }
+        options: {
+          colorize: true,
+          errorLikeObjectKeys: ["err", "error"],
+          ignore: "pid,hostname",
+          translateTime: "SYS:standard"
+        }
       }
     });
     this.meta = meta2;
@@ -426,12 +548,21 @@ var PinoLogger = class _PinoLogger {
       ...meta2
     };
     this.pinoLogger[level](...normalizeLogArgs(filteredArgs));
-    logs.getLogger(process.env.OTEL_SERVICE_NAME ?? "unknown").emit({
-      severityText: level,
-      severityNumber: mapSeverity(level),
-      body: this.prettyPrinter(filteredArgs),
-      attributes: { ...this.meta, ...meta2 }
-    });
+    const formattedBody = safePrettyFormat(level, filteredArgs);
+    try {
+      logs.getLogger(process.env.OTEL_SERVICE_NAME ?? "unknown").emit({
+        severityText: level,
+        severityNumber: mapSeverity(level),
+        body: formattedBody,
+        attributes: { ...this.meta, ...meta2 }
+      });
+    } catch (error) {
+      console.error("Failed to emit OpenTelemetry log:", error);
+      console.log(
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] ${level.toUpperCase()}:`,
+        ...filteredArgs
+      );
+    }
   }
   error = (msg, ...args) => this.log("error", msg, ...args);
   info = (msg, ...args) => this.log("info", msg, ...args);
@@ -560,13 +691,14 @@ var httpServerDurationHistogram = metrics.getMeter(getEnvVar2("OTEL_SERVICE_NAME
 });
 
 // src/http/middleware/request/enrichDetails.middleware.ts
-function enrichDetails(path, contractDetails, requestSchema, responseSchemas, openTelemetryCollector) {
+function enrichDetails(path, contractDetails, requestSchema, responseSchemas, openTelemetryCollector, globalOptions) {
   return (req, res, next) => {
     req.originalPath = path;
     req.contractDetails = contractDetails;
     req.requestSchema = requestSchema;
     res.responseSchemas = responseSchemas;
     req.openTelemetryCollector = openTelemetryCollector;
+    req._globalOptions = globalOptions;
     req.context?.span?.setAttribute(ATTR_API_NAME, req.contractDetails?.name);
     const startTime = process.hrtime();
     res.on("finish", () => {
@@ -602,6 +734,7 @@ function isRequestShape(maybeResponseShape) {
 
 // src/http/middleware/request/parse.middleware.ts
 function parse(req, res, next) {
+  const collapsedOptions = req.contractDetails.options?.requestValidation ?? (req._globalOptions?.validation === false ? "none" : req._globalOptions?.validation?.request);
   const request = {
     params: req.params,
     query: req.query,
@@ -674,8 +807,9 @@ function parse(req, res, next) {
     );
   }
   if (!parsedRequest.ok) {
-    switch (req.contractDetails.options?.requestValidation) {
+    switch (collapsedOptions) {
       default:
+      case void 0:
       case "error":
         res.type("application/json");
         res.status(400);
@@ -836,12 +970,13 @@ function discriminateResponseBodies(schemaValidator, responses) {
 
 // src/http/router/expressLikeRouter.ts
 var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
-  constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector) {
+  constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector, routerOptions) {
     this.basePath = basePath;
     this.schemaValidator = schemaValidator;
     this.internal = internal;
     this.postEnrichMiddleware = postEnrichMiddleware;
     this.openTelemetryCollector = openTelemetryCollector;
+    this.routerOptions = routerOptions;
     if (process.env.NODE_ENV !== "test" && !process.env.VITEST) {
       process.on("uncaughtException", (err) => {
         this.openTelemetryCollector.error(`Uncaught exception: ${err}`);
@@ -880,7 +1015,8 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
         contractDetails,
         requestSchema,
         responseSchemas,
-        this.openTelemetryCollector
+        this.openTelemetryCollector,
+        this.routerOptions
       ),
       ...this.postEnrichMiddleware,
       parse,
@@ -1573,7 +1709,8 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
       this.schemaValidator,
       this.internal,
       this.postEnrichMiddleware,
-      this.openTelemetryCollector
+      this.openTelemetryCollector,
+      this.routerOptions
     );
     this.cloneInternals(clone);
     return clone;
@@ -1593,7 +1730,12 @@ var ForklaunchExpressLikeApplication = class extends ForklaunchExpressLikeRouter
       schemaValidator,
       internal,
       postEnrichMiddleware,
-      openTelemetryCollector
+      openTelemetryCollector,
+      {
+        ...appOptions,
+        openapi: appOptions?.openapi !== false,
+        mcp: appOptions?.mcp !== false
+      }
     );
     this.schemaValidator = schemaValidator;
     this.internal = internal;
@@ -1604,6 +1746,27 @@ var ForklaunchExpressLikeApplication = class extends ForklaunchExpressLikeRouter
   }
 };
 
+// src/http/cluster/isPortBound.ts
+import * as net from "net";
+function isPortBound(port, host = "localhost") {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(1e3);
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.on("error", () => {
+      resolve(false);
+    });
+    socket.connect(port, host);
+  });
+}
+
 // src/http/guards/isPath.ts
 function isPath(path) {
   return path.startsWith("/");
@@ -2726,7 +2889,7 @@ function generateInputSchema(schemaValidator, body, params, query, requestHeader
     } : {}
   });
 }
-function generateMcpServer(schemaValidator, protocol, host, port, version, application, options2, contentTypeMap) {
+function generateMcpServer(schemaValidator, protocol, host, port, version, application, appOptions, options2, contentTypeMap) {
   if (!(schemaValidator instanceof ZodSchemaValidator)) {
     throw new Error(
       "Schema validator must be an instance of ZodSchemaValidator"
@@ -2747,6 +2910,9 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
     ])
   ].forEach(({ fullPath, router }) => {
     router.routes.forEach((route) => {
+      if (!(route.contractDetails.options?.mcp ?? router.routerOptions?.mcp ?? appOptions !== false)) {
+        return;
+      }
       const inputSchemas = [];
       if (route.contractDetails.versions) {
         Object.values(route.contractDetails.versions).forEach((version2) => {
@@ -2950,6 +3116,11 @@ function isResponseCompiledSchema(schema) {
 function parse2(req, res, next) {
   let headers;
   let responses;
+  const collapsedOptions = req.contractDetails.options?.responseValidation ?? (req._globalOptions?.validation === false ? "none" : req._globalOptions?.validation?.response);
+  if (collapsedOptions === "none") {
+    next?.();
+    return;
+  }
   const responseSchemas = res.responseSchemas;
   const schemaValidator = req.schemaValidator;
   if (!isResponseCompiledSchema(responseSchemas)) {
@@ -3011,6 +3182,7 @@ function parse2(req, res, next) {
   if (parseErrors.length > 0) {
     switch (req.contractDetails.options?.responseValidation) {
       default:
+      case void 0:
       case "error":
         res.type("text/plain");
         res.status(500);
@@ -3239,13 +3411,16 @@ function transformBasePath(basePath) {
   }
   return `/${basePath}`;
 }
-function generateOpenApiDocument(serverUrls, serverDescriptions, versionedTags, versionedPaths, versionedSecuritySchemes, otherServers) {
+function generateOpenApiDocument(serverUrls, serverDescriptions, versionedTags, versionedPaths, versionedSecuritySchemes, appOptions) {
+  const { title, description, contact } = appOptions !== false ? appOptions ?? {} : {};
   return {
     [OPENAPI_DEFAULT_VERSION]: {
       openapi: "3.1.0",
       info: {
-        title: process.env.API_TITLE || "API Definition",
-        version: process.env.VERSION || "latest"
+        title: title || process.env.API_TITLE || "API Definition",
+        version: "latest",
+        description,
+        contact
       },
       components: {
         securitySchemes: versionedSecuritySchemes[OPENAPI_DEFAULT_VERSION]
@@ -3255,8 +3430,7 @@ function generateOpenApiDocument(serverUrls, serverDescriptions, versionedTags,
         ...serverUrls.map((url, index) => ({
           url,
           description: serverDescriptions?.[index]
-        })),
-        ...otherServers || []
+        }))
       ],
       paths: versionedPaths[OPENAPI_DEFAULT_VERSION]
     },
@@ -3266,8 +3440,10 @@ function generateOpenApiDocument(serverUrls, serverDescriptions, versionedTags,
         {
           openapi: "3.1.0",
           info: {
-            title: process.env.API_TITLE || "API Definition",
-            version
+            title: title || process.env.API_TITLE || "API Definition",
+            version,
+            description,
+            contact
           },
           components: {
             securitySchemes: versionedSecuritySchemes[version]
@@ -3277,8 +3453,7 @@ function generateOpenApiDocument(serverUrls, serverDescriptions, versionedTags,
             ...serverUrls.map((url, index) => ({
               url,
               description: serverDescriptions?.[index]
-            })),
-            ...otherServers || []
+            }))
           ],
           paths
         }
@@ -3382,11 +3557,11 @@ function generateOperationObject(schemaValidator, path, method, controllerName,
     }
   }
   if (auth) {
-    responses[401] = {
+    coercedResponses[401] = {
       description: httpStatusCodes_default[401],
       content: contentResolver(schemaValidator, schemaValidator.string)
     };
-    responses[403] = {
+    coercedResponses[403] = {
       description: httpStatusCodes_default[403],
       content: contentResolver(schemaValidator, schemaValidator.string)
     };
@@ -3427,7 +3602,7 @@ function generateOperationObject(schemaValidator, path, method, controllerName,
   }
   return operationObject;
 }
-function generateOpenApiSpecs(schemaValidator, serverUrls, serverDescriptions, application, otherServers) {
+function generateOpenApiSpecs(schemaValidator, serverUrls, serverDescriptions, application, appOptions) {
   const versionedPaths = {
     [OPENAPI_DEFAULT_VERSION]: {}
   };
@@ -3451,7 +3626,10 @@ function generateOpenApiSpecs(schemaValidator, serverUrls, serverDescriptions, a
       const openApiPath = openApiCompliantPath(
         `${fullPath}${route.path === "/" ? "" : route.path}`
       );
-      const { name, summary, params, versions, auth } = route.contractDetails;
+      const { name, summary, params, versions, auth, options: options2 } = route.contractDetails;
+      if (!(options2?.openapi ?? router.routerOptions?.openapi ?? appOptions !== false)) {
+        return;
+      }
       if (versions) {
         for (const version of Object.keys(versions)) {
           if (!versionedPaths[version]) {
@@ -3545,7 +3723,7 @@ function generateOpenApiSpecs(schemaValidator, serverUrls, serverDescriptions, a
     versionedTags,
     versionedPaths,
     versionedSecuritySchemes,
-    otherServers
+    appOptions
   );
 }
 
@@ -3613,11 +3791,11 @@ function mapToFetch(schemaValidator, routerMap) {
     schemaValidator,
     routerMap
   );
-  return (path, ...reqInit) => {
+  return ((path, ...reqInit) => {
     const method = reqInit[0]?.method;
     const version = reqInit[0] != null && "version" in reqInit[0] ? reqInit[0].version : void 0;
     return (version ? toRecord2(toRecord2(flattenedFetchMap[path])[method ?? "GET"])[version] : toRecord2(flattenedFetchMap[path])[method ?? "GET"])(path, reqInit[0]);
-  };
+  });
 }
 function sdkClient(schemaValidator, routerMap) {
   return {
@@ -3700,6 +3878,7 @@ export {
   isForklaunchRequest,
   isForklaunchRouter,
   isInformational,
+  isPortBound,
   isRedirection,
   isServerError,
   isSuccessful,