@forklaunch/core 0.16.1 → 0.17.0

package/lib/http/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var http_exports = {};
 __export(http_exports, {
   ATTR_API_NAME: () => ATTR_API_NAME,
+  ATTR_APPLICATION_ID: () => ATTR_APPLICATION_ID,
   ATTR_CORRELATION_ID: () => ATTR_CORRELATION_ID,
   ATTR_HTTP_REQUEST_METHOD: () => import_semantic_conventions.ATTR_HTTP_REQUEST_METHOD,
   ATTR_HTTP_RESPONSE_STATUS_CODE: () => import_semantic_conventions.ATTR_HTTP_RESPONSE_STATUS_CODE,
@@ -42,6 +43,7 @@ __export(http_exports, {
   OPENAPI_DEFAULT_VERSION: () => OPENAPI_DEFAULT_VERSION,
   OpenTelemetryCollector: () => OpenTelemetryCollector,
   PinoLogger: () => PinoLogger,
+  createContext: () => createContext,
   createHmacToken: () => createHmacToken,
   delete_: () => delete_,
   discriminateAuthMethod: () => discriminateAuthMethod,
@@ -49,6 +51,8 @@ __export(http_exports, {
   discriminateResponseBodies: () => discriminateResponseBodies,
   enrichExpressLikeSend: () => enrichExpressLikeSend,
   evaluateTelemetryOptions: () => evaluateTelemetryOptions,
+  extractRouteHandlers: () => extractRouteHandlers,
+  generateHmacAuthHeaders: () => generateHmacAuthHeaders,
   generateMcpServer: () => generateMcpServer,
   generateOpenApiSpecs: () => generateOpenApiSpecs,
   get: () => get,
@@ -103,12 +107,7 @@ function cors(corsOptions) {
 }
 
 // src/http/router/expressLikeRouter.ts
-var import_common9 = require("@forklaunch/common");
-
-// src/http/guards/hasVersionedSchema.ts
-function hasVersionedSchema(contractDetails) {
-  return typeof contractDetails === "object" && contractDetails !== null && "versions" in contractDetails && contractDetails.versions !== null;
-}
+var import_common11 = require("@forklaunch/common");
 
 // src/http/guards/isForklaunchRouter.ts
 function isForklaunchRouter(maybeForklaunchRouter) {
@@ -138,6 +137,192 @@ function isForklaunchExpressLikeRouter(maybeForklaunchExpressLikeRouter) {
   ) && "basePath" in maybeForklaunchExpressLikeRouter && "internal" in maybeForklaunchExpressLikeRouter;
 }
 
+// src/http/guards/isSdkHandler.ts
+function isSdkHandler(handler) {
+  return typeof handler === "object" && handler !== null && "_path" in handler && "_method" in handler && "contractDetails" in handler;
+}
+
+// src/http/guards/isTypedHandler.ts
+function isTypedHandler(maybeTypedHandler) {
+  return maybeTypedHandler != null && typeof maybeTypedHandler === "object" && "_typedHandler" in maybeTypedHandler && maybeTypedHandler._typedHandler === true;
+}
+
+// src/http/middleware/request/createContext.middleware.ts
+var import_common2 = require("@forklaunch/common");
+var import_api = require("@opentelemetry/api");
+var import_uuid = require("uuid");
+
+// src/http/telemetry/constants.ts
+var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
+var ATTR_API_NAME = "api.name";
+var ATTR_CORRELATION_ID = "correlation.id";
+var ATTR_APPLICATION_ID = "application_id";
+
+// src/http/middleware/request/createContext.middleware.ts
+function createContext(schemaValidator) {
+  return function setContext(req, res, next) {
+    req.schemaValidator = schemaValidator;
+    let correlationId = (0, import_uuid.v4)();
+    if (req.headers["x-correlation-id"]) {
+      correlationId = req.headers["x-correlation-id"];
+    }
+    res.setHeader("x-correlation-id", correlationId);
+    req.context = {
+      correlationId
+    };
+    const span = import_api.trace.getSpan(import_api.context.active());
+    if (span != null) {
+      req.context.span = span;
+      req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
+      req.context.span?.setAttribute(
+        import_semantic_conventions.ATTR_SERVICE_NAME,
+        (0, import_common2.getEnvVar)("OTEL_SERVICE_NAME")
+      );
+    }
+    next?.();
+  };
+}
+
+// src/http/router/discriminateBody.ts
+function discriminateBody(schemaValidator, body) {
+  if (body == null) {
+    return void 0;
+  }
+  const maybeTypedBody = body;
+  if ("text" in maybeTypedBody && maybeTypedBody.text != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "text/plain",
+      parserType: "text",
+      schema: maybeTypedBody.text
+    };
+  } else if ("json" in maybeTypedBody && maybeTypedBody.json != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/json",
+      parserType: "json",
+      schema: maybeTypedBody.json
+    };
+  } else if ("file" in maybeTypedBody && maybeTypedBody.file != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/octet-stream",
+      parserType: "file",
+      schema: maybeTypedBody.file
+    };
+  } else if ("multipartForm" in maybeTypedBody && maybeTypedBody.multipartForm != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "multipart/form-data",
+      parserType: "multipart",
+      schema: maybeTypedBody.multipartForm
+    };
+  } else if ("urlEncodedForm" in maybeTypedBody && maybeTypedBody.urlEncodedForm != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/x-www-form-urlencoded",
+      parserType: "urlEncoded",
+      schema: maybeTypedBody.urlEncodedForm
+    };
+  } else if ("schema" in maybeTypedBody && maybeTypedBody.schema != null) {
+    return {
+      contentType: maybeTypedBody.contentType ?? "application/json",
+      parserType: "text",
+      schema: maybeTypedBody.schema
+    };
+  } else if (schemaValidator.isInstanceOf(
+    maybeTypedBody,
+    schemaValidator.string
+  )) {
+    return {
+      contentType: "text/plain",
+      parserType: "text",
+      schema: maybeTypedBody
+    };
+  } else if (schemaValidator.openapi(maybeTypedBody).format === "binary") {
+    return {
+      contentType: "application/octet-stream",
+      parserType: "file",
+      schema: maybeTypedBody
+    };
+  } else {
+    return {
+      contentType: "application/json",
+      parserType: "json",
+      schema: maybeTypedBody
+    };
+  }
+}
+function discriminateResponseBodies(schemaValidator, responses) {
+  const discriminatedResponses = {};
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (response != null && typeof response === "object") {
+      if ("json" in response && response.json != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/json") ?? "application/json",
+          parserType: "json",
+          schema: response.json
+        };
+      } else if ("schema" in response && response.schema != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/json") ?? "application/json",
+          parserType: "text",
+          schema: response.schema
+        };
+      } else if ("text" in response && response.text != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "text/plain") ?? "text/plain",
+          parserType: "text",
+          schema: response.text
+        };
+      } else if ("file" in response && response.file != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/octet-stream") ?? "application/octet-stream",
+          parserType: "file",
+          schema: response.file
+        };
+      } else if ("event" in response && response.event != null) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "text/event-stream") ?? "text/event-stream",
+          parserType: "serverSentEvent",
+          schema: response.event
+        };
+      } else if (schemaValidator.isInstanceOf(
+        response,
+        schemaValidator.string
+      )) {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: "text/plain",
+          parserType: "text",
+          schema: response
+        };
+      } else if (schemaValidator.openapi(response).format === "binary") {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: "application/octet-stream",
+          parserType: "file",
+          schema: response
+        };
+      } else {
+        discriminatedResponses[Number(statusCode)] = {
+          contentType: "application/json",
+          parserType: "json",
+          schema: response
+        };
+      }
+    } else {
+      discriminatedResponses[Number(statusCode)] = {
+        contentType: "application/json",
+        parserType: "json",
+        schema: response
+      };
+    }
+  }
+  return discriminatedResponses;
+}
+
+// src/http/router/routerSharedLogic.ts
+var import_common10 = require("@forklaunch/common");
+
+// src/http/guards/hasVersionedSchema.ts
+function hasVersionedSchema(contractDetails) {
+  return typeof contractDetails === "object" && contractDetails !== null && "versions" in contractDetails && contractDetails.versions !== null;
+}
+
 // src/http/guards/isPathParamContractDetails.ts
 function isPathParamHttpContractDetails(maybePathParamHttpContractDetails) {
   return maybePathParamHttpContractDetails != null && typeof maybePathParamHttpContractDetails === "object" && "name" in maybePathParamHttpContractDetails && "summary" in maybePathParamHttpContractDetails && maybePathParamHttpContractDetails.name != null && maybePathParamHttpContractDetails.summary != null && ("responses" in maybePathParamHttpContractDetails && maybePathParamHttpContractDetails.responses != null || "versions" in maybePathParamHttpContractDetails && typeof maybePathParamHttpContractDetails.versions === "object" && maybePathParamHttpContractDetails.versions != null && Object.values(maybePathParamHttpContractDetails.versions).every(
@@ -152,25 +337,16 @@ function isHttpContractDetails(maybeContractDetails) {
   ));
 }
 
-// src/http/guards/isSdkHandler.ts
-function isSdkHandler(handler) {
-  return typeof handler === "object" && handler !== null && "_path" in handler && "_method" in handler && "contractDetails" in handler;
-}
-
-// src/http/guards/isTypedHandler.ts
-function isTypedHandler(maybeTypedHandler) {
-  return maybeTypedHandler != null && typeof maybeTypedHandler === "object" && "_typedHandler" in maybeTypedHandler && maybeTypedHandler._typedHandler === true;
-}
-
 // src/http/middleware/request/auth.middleware.ts
-var import_common3 = require("@forklaunch/common");
+var import_common6 = require("@forklaunch/common");
 var import_validator = require("@forklaunch/validator");
 
 // src/http/discriminateAuthMethod.ts
+var import_common4 = require("@forklaunch/common");
 var import_jose = require("jose");
 
 // src/http/createHmacToken.ts
-var import_common2 = require("@forklaunch/common");
+var import_common3 = require("@forklaunch/common");
 var import_crypto = require("crypto");
 function createHmacToken({
   method,
@@ -181,7 +357,7 @@ function createHmacToken({
   secretKey
 }) {
   const hmac = (0, import_crypto.createHmac)("sha256", secretKey);
-  const bodyString = body ? `${(0, import_common2.safeStringify)(body)}
+  const bodyString = body ? `${(0, import_common3.safeStringify)(body)}
 ` : void 0;
   hmac.update(
     `${method}
@@ -228,7 +404,7 @@ async function getCachedJwks(jwksPublicKeyUrl) {
     return jwks;
   }
 }
-async function discriminateAuthMethod(auth) {
+async function discriminateAuthMethod(auth, openTelemetryCollector) {
   let authMethod;
   if (isBasicAuthMethod(auth)) {
     authMethod = {
@@ -291,37 +467,219 @@ async function discriminateAuthMethod(auth) {
           signature,
           secretKey
         }) => {
-          return createHmacToken({
+          const computedSignature = createHmacToken({
             method,
             path,
             body,
             timestamp,
             nonce,
             secretKey
-          }) === signature;
+          });
+          const isValid = computedSignature === signature;
+          if (!isValid) {
+            const errorInfo = {
+              method,
+              path,
+              timestamp: timestamp.toISOString(),
+              nonce,
+              receivedSignature: signature,
+              computedSignature
+            };
+            openTelemetryCollector?.debug("[HMAC Verification Failed]", {
+              ...errorInfo,
+              bodyType: body ? typeof body : "undefined",
+              body: body ? (0, import_common4.safeStringify)(body) : "undefined"
+            });
+          }
+          return isValid;
         }
       }
     };
   }
-  if (authMethod == null) {
-    throw new Error("Invalid auth method");
+  if (authMethod == null) {
+    throw new Error("Invalid auth method");
+  }
+  return authMethod;
+}
+
+// src/http/guards/hasPermissionChecks.ts
+function hasPermissionChecks(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 && ("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/telemetry/pinoLogger.ts
+var import_common5 = require("@forklaunch/common");
+var import_api2 = require("@opentelemetry/api");
+var import_api_logs = require("@opentelemetry/api-logs");
+var import_pino = __toESM(require("pino"));
+
+// src/http/guards/isLoggerMeta.ts
+function isLoggerMeta(arg) {
+  return typeof arg === "object" && arg !== null && "_meta" in arg;
+}
+
+// src/http/telemetry/pinoLogger.ts
+function meta(meta2) {
+  return meta2;
+}
+function mapSeverity(level) {
+  switch (level) {
+    case "silent":
+      return 0;
+    case "trace":
+      return 1;
+    case "debug":
+      return 5;
+    case "info":
+      return 9;
+    case "warn":
+      return 13;
+    case "error":
+      return 17;
+    case "fatal":
+      return 21;
+    default:
+      (0, import_common5.isNever)(level);
+      return 0;
+  }
+}
+function normalizeLogArgs(args) {
+  let message = "";
+  const metaObjects = [];
+  for (const arg of args) {
+    if (typeof arg === "string" && message === "") {
+      message = arg;
+    } else if (arg instanceof Error) {
+      metaObjects.push({
+        err: {
+          message: arg.message,
+          name: arg.name,
+          stack: arg.stack,
+          ...Object.keys(arg).length > 0 ? arg : {}
+        }
+      });
+    } else if (arg && typeof arg === "object" && !Array.isArray(arg)) {
+      metaObjects.push(arg);
+    } else {
+      message += ` ${String(arg)}`;
+    }
+  }
+  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;
+  constructor(level, meta2 = {}) {
+    this.pinoLogger = (0, import_pino.default)({
+      level: level || "info",
+      formatters: {
+        level(label) {
+          return { level: label };
+        }
+      },
+      timestamp: import_pino.default.stdTimeFunctions.isoTime,
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          errorLikeObjectKeys: ["err", "error"],
+          ignore: "pid,hostname",
+          translateTime: "SYS:standard"
+        }
+      }
+    });
+    this.meta = meta2;
+  }
+  log(level, ...args) {
+    let meta2 = {};
+    const filteredArgs = args.filter((arg) => {
+      if (isLoggerMeta(arg)) {
+        Object.assign(meta2, arg);
+        return false;
+      }
+      return true;
+    });
+    const [errorMetadata] = normalizeLogArgs(filteredArgs);
+    Object.assign(meta2, errorMetadata);
+    const activeSpan = import_api2.trace.getActiveSpan();
+    if (activeSpan) {
+      const activeSpanContext = activeSpan.spanContext();
+      meta2.trace_id = activeSpanContext.traceId;
+      meta2.span_id = activeSpanContext.spanId;
+      meta2.trace_flags = activeSpanContext.traceFlags;
+      meta2 = {
+        // @ts-expect-error accessing private property
+        ...activeSpan.attributes,
+        ...meta2
+      };
+    }
+    meta2 = {
+      "api.name": "none",
+      "correlation.id": "none",
+      ...meta2
+    };
+    this.pinoLogger[level](...normalizeLogArgs(filteredArgs));
+    const formattedBody = safePrettyFormat(level, filteredArgs);
+    try {
+      import_api_logs.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);
+  debug = (msg, ...args) => this.log("debug", msg, ...args);
+  warn = (msg, ...args) => this.log("warn", msg, ...args);
+  trace = (msg, ...args) => this.log("trace", msg, ...args);
+  child(meta2 = {}) {
+    return new _PinoLogger(this.pinoLogger.level, { ...this.meta, ...meta2 });
+  }
+  getBaseLogger() {
+    return this.pinoLogger;
   }
-  return authMethod;
-}
-
-// src/http/guards/hasPermissionChecks.ts
-function hasPermissionChecks(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 && ("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;
+};
+function logger(level, meta2 = {}) {
+  return new PinoLogger(level, meta2);
 }
 
 // src/http/middleware/request/auth.middleware.ts
@@ -385,7 +743,8 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
   }
   let sessionPayload;
   const { type, auth } = await discriminateAuthMethod(
-    collapsedAuthorizationMethod
+    collapsedAuthorizationMethod,
+    req.openTelemetryCollector
   );
   switch (type) {
     case "hmac": {
@@ -406,7 +765,7 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
       const verificationResult = await auth.verificationFunction({
         method: req?.method ?? "",
         path: req?.path ?? "",
-        body: req?.body,
+        body: req?._rawBody ?? req?.body,
         timestamp: new Date(parsedTimestamp),
         nonce: parsedNonce,
         signature: parsedSignature,
@@ -430,7 +789,15 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
         }
         sessionPayload = decodedJwt;
       } catch (error) {
-        req?.openTelemetryCollector.error(error);
+        req?.openTelemetryCollector?.error(
+          "JWT Verification Failed",
+          meta({
+            error,
+            method: req.method,
+            path: req.path,
+            token
+          })
+        );
         return invalidAuthorizationToken;
       }
       break;
@@ -457,7 +824,7 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
       break;
     }
     default:
-      (0, import_common3.isNever)(type);
+      (0, import_common6.isNever)(type);
       return [401, "Invalid Authorization method."];
   }
   if (isHmacMethod(collapsedAuthorizationMethod) && sessionPayload == null) {
@@ -542,14 +909,18 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
 }
 async function parseRequestAuth(req, res, next) {
   const auth = req.contractDetails.auth;
-  const [error, message] = await checkAuthorizationToken(
-    req,
-    auth,
-    req.headers[auth?.headerName ?? "Authorization"] || req.headers[auth?.headerName ?? "authorization"],
-    req._globalOptions?.()?.auth
-  ) ?? [];
+  const token = req.headers[auth?.headerName ?? "Authorization"] || req.headers[auth?.headerName ?? "authorization"];
+  const [error, message] = await checkAuthorizationToken(req, auth, token, req._globalOptions?.()?.auth) ?? [];
   if (error != null) {
-    req.openTelemetryCollector.error(error, message);
+    req.openTelemetryCollector?.error(
+      message || "Authorization Failed",
+      meta({
+        statusCode: error,
+        method: req.method,
+        path: req.path,
+        token
+      })
+    );
     res.type("text/plain");
     res.status(error).send(message);
     return;
@@ -557,46 +928,11 @@ async function parseRequestAuth(req, res, next) {
   next?.();
 }
 
-// src/http/middleware/request/createContext.middleware.ts
-var import_common4 = require("@forklaunch/common");
-var import_api = require("@opentelemetry/api");
-var import_uuid = require("uuid");
-
-// src/http/telemetry/constants.ts
-var import_semantic_conventions = require("@opentelemetry/semantic-conventions");
-var ATTR_API_NAME = "api.name";
-var ATTR_CORRELATION_ID = "correlation.id";
-
-// src/http/middleware/request/createContext.middleware.ts
-function createContext(schemaValidator) {
-  return function setContext(req, res, next) {
-    req.schemaValidator = schemaValidator;
-    let correlationId = (0, import_uuid.v4)();
-    if (req.headers["x-correlation-id"]) {
-      correlationId = req.headers["x-correlation-id"];
-    }
-    res.setHeader("x-correlation-id", correlationId);
-    req.context = {
-      correlationId
-    };
-    const span = import_api.trace.getSpan(import_api.context.active());
-    if (span != null) {
-      req.context.span = span;
-      req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
-      req.context.span?.setAttribute(
-        import_semantic_conventions.ATTR_SERVICE_NAME,
-        (0, import_common4.getEnvVar)("OTEL_SERVICE_NAME")
-      );
-    }
-    next?.();
-  };
-}
-
 // src/http/middleware/request/enrichDetails.middleware.ts
-var import_common7 = require("@forklaunch/common");
+var import_common8 = require("@forklaunch/common");
 
 // src/http/telemetry/openTelemetryCollector.ts
-var import_common6 = require("@forklaunch/common");
+var import_common7 = require("@forklaunch/common");
 var import_opentelemetry_instrumentation_hyper_express = require("@forklaunch/opentelemetry-instrumentation-hyper-express");
 var import_api3 = require("@opentelemetry/api");
 var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
@@ -616,171 +952,6 @@ function isForklaunchRequest(request) {
   return request != null && typeof request === "object" && "contractDetails" in request;
 }
 
-// src/http/telemetry/pinoLogger.ts
-var import_common5 = require("@forklaunch/common");
-var import_api2 = require("@opentelemetry/api");
-var import_api_logs = require("@opentelemetry/api-logs");
-var import_pino = __toESM(require("pino"));
-
-// src/http/guards/isLoggerMeta.ts
-function isLoggerMeta(arg) {
-  return typeof arg === "object" && arg !== null && "_meta" in arg;
-}
-
-// src/http/telemetry/pinoLogger.ts
-function meta(meta2) {
-  return meta2;
-}
-function mapSeverity(level) {
-  switch (level) {
-    case "silent":
-      return 0;
-    case "trace":
-      return 1;
-    case "debug":
-      return 5;
-    case "info":
-      return 9;
-    case "warn":
-      return 13;
-    case "error":
-      return 17;
-    case "fatal":
-      return 21;
-    default:
-      (0, import_common5.isNever)(level);
-      return 0;
-  }
-}
-function normalizeLogArgs(args) {
-  let message = "";
-  const metaObjects = [];
-  for (const arg of args) {
-    if (typeof arg === "string" && message === "") {
-      message = arg;
-    } else if (arg instanceof Error) {
-      metaObjects.push({
-        err: {
-          message: arg.message,
-          name: arg.name,
-          stack: arg.stack,
-          ...Object.keys(arg).length > 0 ? arg : {}
-        }
-      });
-    } else if (arg && typeof arg === "object" && !Array.isArray(arg)) {
-      metaObjects.push(arg);
-    } else {
-      message += ` ${String(arg)}`;
-    }
-  }
-  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;
-  constructor(level, meta2 = {}) {
-    this.pinoLogger = (0, import_pino.default)({
-      level: level || "info",
-      formatters: {
-        level(label) {
-          return { level: label };
-        }
-      },
-      timestamp: import_pino.default.stdTimeFunctions.isoTime,
-      transport: {
-        target: "pino-pretty",
-        options: {
-          colorize: true,
-          errorLikeObjectKeys: ["err", "error"],
-          ignore: "pid,hostname",
-          translateTime: "SYS:standard"
-        }
-      }
-    });
-    this.meta = meta2;
-  }
-  log(level, ...args) {
-    let meta2 = {};
-    const filteredArgs = args.filter((arg) => {
-      if (isLoggerMeta(arg)) {
-        Object.assign(meta2, arg);
-        return false;
-      }
-      return true;
-    });
-    const [errorMetadata] = normalizeLogArgs(filteredArgs);
-    Object.assign(meta2, errorMetadata);
-    const activeSpan = import_api2.trace.getActiveSpan();
-    if (activeSpan) {
-      const activeSpanContext = activeSpan.spanContext();
-      meta2.trace_id = activeSpanContext.traceId;
-      meta2.span_id = activeSpanContext.spanId;
-      meta2.trace_flags = activeSpanContext.traceFlags;
-      meta2 = {
-        // @ts-expect-error accessing private property
-        ...activeSpan.attributes,
-        ...meta2
-      };
-    }
-    meta2 = {
-      "api.name": "none",
-      "correlation.id": "none",
-      ...meta2
-    };
-    this.pinoLogger[level](...normalizeLogArgs(filteredArgs));
-    const formattedBody = safePrettyFormat(level, filteredArgs);
-    try {
-      import_api_logs.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);
-  debug = (msg, ...args) => this.log("debug", msg, ...args);
-  warn = (msg, ...args) => this.log("warn", msg, ...args);
-  trace = (msg, ...args) => this.log("trace", msg, ...args);
-  child(meta2 = {}) {
-    return new _PinoLogger(this.pinoLogger.level, { ...this.meta, ...meta2 });
-  }
-  getBaseLogger() {
-    return this.pinoLogger;
-  }
-};
-function logger(level, meta2 = {}) {
-  return new PinoLogger(level, meta2);
-}
-
 // src/http/telemetry/openTelemetryCollector.ts
 var OpenTelemetryCollector = class {
   #logger;
@@ -845,24 +1016,40 @@ var OpenTelemetryCollector = class {
     return this.#metrics[metricId];
   }
 };
-import_dotenv.default.config({ path: (0, import_common6.getEnvVar)("DOTENV_FILE_PATH") });
+import_dotenv.default.config({ path: (0, import_common7.getEnvVar)("DOTENV_FILE_PATH") });
+function parseOtelHeaders() {
+  const headersEnv = (0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_HEADERS");
+  if (!headersEnv) return void 0;
+  const headers = {};
+  for (const pair of headersEnv.split(",")) {
+    const [key, ...valueParts] = pair.split("=");
+    if (key && valueParts.length > 0) {
+      headers[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+var otelHeaders = parseOtelHeaders();
 new import_sdk_node.NodeSDK({
   resource: (0, import_resources.resourceFromAttributes)({
-    [import_semantic_conventions2.ATTR_SERVICE_NAME]: (0, import_common6.getEnvVar)("OTEL_SERVICE_NAME")
+    [import_semantic_conventions2.ATTR_SERVICE_NAME]: (0, import_common7.getEnvVar)("OTEL_SERVICE_NAME")
   }),
   traceExporter: new import_exporter_trace_otlp_http.OTLPTraceExporter({
-    url: `${(0, import_common6.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`
+    url: `${(0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`,
+    headers: otelHeaders
   }),
   metricReader: new import_sdk_metrics.PeriodicExportingMetricReader({
     exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-      url: `${(0, import_common6.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`
+      url: `${(0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`,
+      headers: otelHeaders
     }),
     exportIntervalMillis: 5e3
   }),
   logRecordProcessors: [
     new import_sdk_logs.BatchLogRecordProcessor(
       new import_exporter_logs_otlp_http.OTLPLogExporter({
-        url: `${(0, import_common6.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`
+        url: `${(0, import_common7.getEnvVar)("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`,
+        headers: otelHeaders
       })
     )
   ],
@@ -871,7 +1058,7 @@ new import_sdk_node.NodeSDK({
       applyCustomAttributesOnSpan: (span, request) => {
         span.setAttribute(
           import_semantic_conventions2.ATTR_SERVICE_NAME,
-          (0, import_common6.getEnvVar)("OTEL_SERVICE_NAME") ?? "unknown"
+          (0, import_common7.getEnvVar)("OTEL_SERVICE_NAME") ?? "unknown"
         );
         if (isForklaunchRequest(request)) {
           span.setAttribute(ATTR_API_NAME, request.contractDetails?.name);
@@ -883,10 +1070,10 @@ new import_sdk_node.NodeSDK({
     new import_opentelemetry_instrumentation_hyper_express.HyperExpressInstrumentation()
   ]
 }).start();
-var httpRequestsTotalCounter = import_api3.metrics.getMeter((0, import_common6.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
+var httpRequestsTotalCounter = import_api3.metrics.getMeter((0, import_common7.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createCounter("http_requests_total", {
   description: "Number of HTTP requests"
 });
-var httpServerDurationHistogram = import_api3.metrics.getMeter((0, import_common6.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_server_duration", {
+var httpServerDurationHistogram = import_api3.metrics.getMeter((0, import_common7.getEnvVar)("OTEL_SERVICE_NAME") || "unknown").createHistogram("http_server_duration", {
   description: "Duration of HTTP server requests",
   unit: "s"
 });
@@ -899,14 +1086,15 @@ function enrichDetails(path, contractDetails, requestSchema, responseSchemas, op
     req.requestSchema = requestSchema;
     res.responseSchemas = responseSchemas;
     req.openTelemetryCollector = openTelemetryCollector;
-    req._globalOptions = globalOptions;
+    req._globalOptions = globalOptions ?? (() => void 0);
     req.context?.span?.setAttribute(ATTR_API_NAME, req.contractDetails?.name);
     const startTime = process.hrtime();
     res.on("finish", () => {
       const [seconds, nanoseconds] = process.hrtime(startTime);
       const durationMs = seconds + nanoseconds / 1e9;
       httpServerDurationHistogram.record(durationMs, {
-        [import_semantic_conventions.ATTR_SERVICE_NAME]: (0, import_common7.getEnvVar)("OTEL_SERVICE_NAME") || "unknown",
+        [import_semantic_conventions.ATTR_SERVICE_NAME]: (0, import_common8.getEnvVar)("OTEL_SERVICE_NAME") || "unknown",
+        [ATTR_APPLICATION_ID]: (0, import_common8.getEnvVar)("OTEL_APPLICATION_ID"),
         [ATTR_API_NAME]: req.contractDetails?.name || "unknown",
         [import_semantic_conventions.ATTR_HTTP_REQUEST_METHOD]: req.method,
         [import_semantic_conventions.ATTR_HTTP_ROUTE]: req.originalPath || "unknown",
@@ -918,7 +1106,7 @@ function enrichDetails(path, contractDetails, requestSchema, responseSchemas, op
 }
 
 // src/http/middleware/request/parse.middleware.ts
-var import_common8 = require("@forklaunch/common");
+var import_common9 = require("@forklaunch/common");
 var import_validator2 = require("@forklaunch/validator");
 
 // src/http/guards/hasSend.ts
@@ -935,6 +1123,7 @@ function isRequestShape(maybeResponseShape) {
 function parse(req, res, next) {
   const globalOptions = req._globalOptions?.();
   const collapsedOptions = req.contractDetails.options?.requestValidation ?? (globalOptions?.validation === false ? "none" : globalOptions?.validation?.request);
+  req._rawBody = req.body;
   const request = {
     params: req.params,
     query: req.query,
@@ -946,7 +1135,7 @@ function parse(req, res, next) {
   let parsedRequest;
   let collectedParseErrors;
   if (req.contractDetails.versions) {
-    if ((0, import_common8.isRecord)(req.requestSchema)) {
+    if ((0, import_common9.isRecord)(req.requestSchema)) {
       let runningParseErrors = "";
       matchedVersions = [];
       Object.entries(req.requestSchema).forEach(([version, schema]) => {
@@ -1024,7 +1213,7 @@ Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
         }
         return;
       case "warning":
-        req.openTelemetryCollector.warn(
+        req.openTelemetryCollector?.warn(
           collectedParseErrors ?? (0, import_validator2.prettyPrintParseErrors)(parsedRequest.errors, "Request")
         );
         break;
@@ -1032,143 +1221,221 @@ Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
         break;
     }
   }
-  req._parsedVersions = matchedVersions;
-  next?.();
+  req._parsedVersions = matchedVersions;
+  next?.();
+}
+
+// src/http/router/routerSharedLogic.ts
+function resolveContractDetailsAndHandlers(contractDetailsOrMiddlewareOrTypedHandler, middlewareOrMiddlewareAndTypedHandler) {
+  let contractDetails;
+  let handlers = [];
+  if (isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
+    contractDetails = contractDetailsOrMiddlewareOrTypedHandler.contractDetails;
+    handlers = contractDetailsOrMiddlewareOrTypedHandler.handlers;
+  } else {
+    const maybeTypedHandler = middlewareOrMiddlewareAndTypedHandler[middlewareOrMiddlewareAndTypedHandler.length - 1];
+    if (isTypedHandler(maybeTypedHandler)) {
+      contractDetails = maybeTypedHandler.contractDetails;
+      const typedHandlerHandlers = maybeTypedHandler.handlers;
+      const finalHandlers = [];
+      if (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
+        finalHandlers.push(contractDetailsOrMiddlewareOrTypedHandler);
+      }
+      finalHandlers.push(...middlewareOrMiddlewareAndTypedHandler.slice(0, -1));
+      finalHandlers.push(
+        ...typedHandlerHandlers
+      );
+      handlers = finalHandlers.filter(
+        (handler) => isExpressLikeSchemaHandler(handler)
+      );
+    } else {
+      if (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler) || isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
+        throw new Error("Contract details are not defined");
+      }
+      contractDetails = contractDetailsOrMiddlewareOrTypedHandler;
+      handlers = middlewareOrMiddlewareAndTypedHandler.filter(
+        (handler) => isExpressLikeSchemaHandler(handler)
+      );
+    }
+  }
+  return { contractDetails, handlers };
+}
+function validateContractDetails(contractDetails, schemaValidator) {
+  if (!isHttpContractDetails(contractDetails) && !isPathParamHttpContractDetails(contractDetails)) {
+    throw new Error("Contract details are malformed for route definition");
+  }
+  if (contractDetails.versions) {
+    const parserTypes = Object.values(contractDetails.versions).map(
+      (version) => discriminateBody(schemaValidator, version.body)?.parserType
+    );
+    const allParserTypesSame = parserTypes.length === 0 || parserTypes.every((pt) => pt === parserTypes[0]);
+    if (!allParserTypesSame) {
+      throw new Error(
+        "All versioned contractDetails must have the same parsing type for body."
+      );
+    }
+  }
 }
-
-// src/http/router/discriminateBody.ts
-function discriminateBody(schemaValidator, body) {
-  if (body == null) {
-    return void 0;
-  }
-  const maybeTypedBody = body;
-  if ("text" in maybeTypedBody && maybeTypedBody.text != null) {
-    return {
-      contentType: maybeTypedBody.contentType ?? "text/plain",
-      parserType: "text",
-      schema: maybeTypedBody.text
-    };
-  } else if ("json" in maybeTypedBody && maybeTypedBody.json != null) {
-    return {
-      contentType: maybeTypedBody.contentType ?? "application/json",
-      parserType: "json",
-      schema: maybeTypedBody.json
-    };
-  } else if ("file" in maybeTypedBody && maybeTypedBody.file != null) {
-    return {
-      contentType: maybeTypedBody.contentType ?? "application/octet-stream",
-      parserType: "file",
-      schema: maybeTypedBody.file
-    };
-  } else if ("multipartForm" in maybeTypedBody && maybeTypedBody.multipartForm != null) {
-    return {
-      contentType: maybeTypedBody.contentType ?? "multipart/form-data",
-      parserType: "multipart",
-      schema: maybeTypedBody.multipartForm
-    };
-  } else if ("urlEncodedForm" in maybeTypedBody && maybeTypedBody.urlEncodedForm != null) {
-    return {
-      contentType: maybeTypedBody.contentType ?? "application/x-www-form-urlencoded",
-      parserType: "urlEncoded",
-      schema: maybeTypedBody.urlEncodedForm
-    };
-  } else if ("schema" in maybeTypedBody && maybeTypedBody.schema != null) {
-    return {
-      contentType: maybeTypedBody.contentType ?? "application/json",
-      parserType: "text",
-      schema: maybeTypedBody.schema
-    };
-  } else if (schemaValidator.isInstanceOf(
-    maybeTypedBody,
-    schemaValidator.string
-  )) {
-    return {
-      contentType: "text/plain",
-      parserType: "text",
-      schema: maybeTypedBody
-    };
-  } else if (schemaValidator.openapi(maybeTypedBody).format === "binary") {
-    return {
-      contentType: "application/octet-stream",
-      parserType: "file",
-      schema: maybeTypedBody
-    };
+function processContractDetailsIO(schemaValidator, contractDetailsIO, routeParams) {
+  const responseSchemas = {
+    400: schemaValidator.string,
+    401: schemaValidator.string,
+    403: schemaValidator.string,
+    404: schemaValidator.string,
+    500: schemaValidator.string,
+    ...Object.fromEntries(
+      Object.entries(
+        discriminateResponseBodies(schemaValidator, contractDetailsIO.responses)
+      ).map(([key, value]) => [Number(key), value.schema])
+    )
+  };
+  return {
+    requestSchema: schemaValidator.compile(
+      schemaValidator.schemify({
+        ...routeParams != null ? { params: routeParams } : { params: schemaValidator.unknown },
+        ...contractDetailsIO.requestHeaders != null ? { headers: contractDetailsIO.requestHeaders } : { headers: schemaValidator.unknown },
+        ...contractDetailsIO.query != null ? { query: contractDetailsIO.query } : { query: schemaValidator.unknown },
+        ...contractDetailsIO.body != null ? {
+          body: discriminateBody(schemaValidator, contractDetailsIO.body)?.schema
+        } : { body: schemaValidator.unknown }
+      })
+    ),
+    responseSchemas: {
+      ...contractDetailsIO.responseHeaders != null ? {
+        headers: schemaValidator.compile(
+          schemaValidator.schemify(contractDetailsIO.responseHeaders)
+        )
+      } : { headers: schemaValidator.unknown },
+      responses: Object.fromEntries(
+        Object.entries(responseSchemas).map(([key, value]) => [
+          key,
+          schemaValidator.compile(schemaValidator.schemify(value))
+        ])
+      )
+    }
+  };
+}
+function compileRouteSchemas(contractDetails, schemaValidator) {
+  const validator = schemaValidator;
+  let requestSchema;
+  let responseSchemas;
+  if (hasVersionedSchema(contractDetails)) {
+    requestSchema = {};
+    responseSchemas = {};
+    Object.entries(contractDetails.versions ?? {}).forEach(
+      ([version, versionedContractDetails]) => {
+        const {
+          requestSchema: versionedRequestSchema,
+          responseSchemas: versionedResponseSchemas
+        } = processContractDetailsIO(
+          validator,
+          versionedContractDetails,
+          contractDetails.params
+        );
+        if ((0, import_common10.isRecord)(requestSchema)) {
+          requestSchema = {
+            ...requestSchema,
+            [version]: versionedRequestSchema
+          };
+        }
+        if ((0, import_common10.isRecord)(responseSchemas)) {
+          responseSchemas = {
+            ...responseSchemas,
+            [version]: versionedResponseSchemas
+          };
+        }
+      }
+    );
   } else {
-    return {
-      contentType: "application/json",
-      parserType: "json",
-      schema: maybeTypedBody
-    };
+    const {
+      requestSchema: unversionedRequestSchema,
+      responseSchemas: unversionedResponseSchemas
+    } = processContractDetailsIO(
+      validator,
+      {
+        ..."params" in contractDetails && contractDetails.params != null ? { params: contractDetails.params } : { params: validator.unknown },
+        ..."requestHeaders" in contractDetails && contractDetails.requestHeaders != null ? { requestHeaders: contractDetails.requestHeaders } : {
+          requestHeaders: validator.unknown
+        },
+        ..."responseHeaders" in contractDetails && contractDetails.responseHeaders != null ? { responseHeaders: contractDetails.responseHeaders } : {
+          responseHeaders: validator.unknown
+        },
+        ..."query" in contractDetails && contractDetails.query != null ? { query: contractDetails.query } : {
+          query: validator.unknown
+        },
+        ..."body" in contractDetails && contractDetails.body != null ? { body: contractDetails.body } : {
+          body: validator.unknown
+        },
+        responses: "responses" in contractDetails && contractDetails.responses != null ? contractDetails.responses : validator.unknown
+      },
+      contractDetails.params
+    );
+    requestSchema = unversionedRequestSchema;
+    responseSchemas = unversionedResponseSchemas;
   }
+  return { requestSchema, responseSchemas };
 }
-function discriminateResponseBodies(schemaValidator, responses) {
-  const discriminatedResponses = {};
-  for (const [statusCode, response] of Object.entries(responses)) {
-    if (response != null && typeof response === "object") {
-      if ("json" in response && response.json != null) {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/json") ?? "application/json",
-          parserType: "json",
-          schema: response.json
-        };
-      } else if ("schema" in response && response.schema != null) {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/json") ?? "application/json",
-          parserType: "text",
-          schema: response.schema
-        };
-      } else if ("text" in response && response.text != null) {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "text/plain") ?? "text/plain",
-          parserType: "text",
-          schema: response.text
-        };
-      } else if ("file" in response && response.file != null) {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "application/octet-stream") ?? "application/octet-stream",
-          parserType: "file",
-          schema: response.file
-        };
-      } else if ("event" in response && response.event != null) {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: ("contentType" in response && typeof response.contentType === "string" ? response.contentType : "text/event-stream") ?? "text/event-stream",
-          parserType: "serverSentEvent",
-          schema: response.event
-        };
-      } else if (schemaValidator.isInstanceOf(
-        response,
-        schemaValidator.string
-      )) {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: "text/plain",
-          parserType: "text",
-          schema: response
-        };
-      } else if (schemaValidator.openapi(response).format === "binary") {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: "application/octet-stream",
-          parserType: "file",
-          schema: response
-        };
-      } else {
-        discriminatedResponses[Number(statusCode)] = {
-          contentType: "application/json",
-          parserType: "json",
-          schema: response
-        };
-      }
-    } else {
-      discriminatedResponses[Number(statusCode)] = {
-        contentType: "application/json",
-        parserType: "json",
-        schema: response
-      };
-    }
+function resolveRouteMiddlewares(params) {
+  const handlersCopy = [...params.handlers];
+  const controllerHandler = handlersCopy.pop();
+  if (typeof controllerHandler !== "function") {
+    throw new Error(
+      `Last argument must be a handler, received: ${controllerHandler}`
+    );
   }
-  return discriminatedResponses;
+  const middlewares = [
+    ...params.includeCreateContext !== false ? [createContext] : [],
+    enrichDetails(
+      `${params.basePath}${params.path}`,
+      params.contractDetails,
+      params.requestSchema,
+      params.responseSchemas,
+      params.openTelemetryCollector,
+      () => params.routerOptions
+    ),
+    ...params.postEnrichMiddleware,
+    parse,
+    parseRequestAuth,
+    ...handlersCopy
+  ];
+  return {
+    middlewares,
+    controllerHandler
+  };
 }
 
 // src/http/router/expressLikeRouter.ts
+function extractRouteHandlers(params) {
+  const schemaValidator = params.schemaValidator;
+  const { contractDetails, handlers } = resolveContractDetailsAndHandlers(
+    params.contractDetailsOrMiddlewareOrTypedHandler,
+    params.middlewareOrMiddlewareAndTypedHandler
+  );
+  validateContractDetails(contractDetails, schemaValidator);
+  const { requestSchema, responseSchemas } = compileRouteSchemas(
+    contractDetails,
+    schemaValidator
+  );
+  const { middlewares, controllerHandler } = resolveRouteMiddlewares({
+    basePath: params.basePath,
+    path: params.path,
+    contractDetails,
+    requestSchema,
+    responseSchemas,
+    openTelemetryCollector: params.openTelemetryCollector,
+    routerOptions: params.routerOptions,
+    postEnrichMiddleware: params.postEnrichMiddleware ?? [],
+    handlers,
+    includeCreateContext: false
+  });
+  return {
+    middlewares: [
+      createContext(schemaValidator),
+      ...middlewares
+    ],
+    controllerHandler
+  };
+}
 var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   constructor(basePath, schemaValidator, internal, postEnrichMiddleware, openTelemetryCollector, routerOptions) {
     this.basePath = basePath;
@@ -1208,21 +1475,6 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
    * @param {PathParamHttpContractDetails<SV> | HttpContractDetails<SV>} contractDetails - The contract details.
    * @returns {MiddlewareHandler<SV>[]} - The resolved middlewares.
    */
-  #resolveMiddlewares(path, contractDetails, requestSchema, responseSchemas) {
-    return [
-      enrichDetails(
-        `${this.basePath}${path}`,
-        contractDetails,
-        requestSchema,
-        responseSchemas,
-        this.openTelemetryCollector,
-        () => this.routerOptions
-      ),
-      ...this.postEnrichMiddleware,
-      parse,
-      parseRequestAuth
-    ];
-  }
   /**
    * Parses and runs the controller handler with error handling.
    *
@@ -1263,126 +1515,6 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
    * @returns {MiddlewareHandler<SV, P, ResBodyMap, ReqBody, ReqQuery, LocalsObj>} - The extracted controller handler.
    * @throws {Error} - Throws an error if the last argument is not a handler.
    */
-  #extractControllerHandler(handlers) {
-    const controllerHandler = handlers.pop();
-    if (typeof controllerHandler !== "function") {
-      throw new Error(
-        `Last argument must be a handler, received: ${controllerHandler}`
-      );
-    }
-    return controllerHandler;
-  }
-  #processContractDetailsIO(contractDetailsIO, params) {
-    const schemaValidator = this.schemaValidator;
-    const responseSchemas = {
-      400: schemaValidator.string,
-      401: schemaValidator.string,
-      403: schemaValidator.string,
-      404: schemaValidator.string,
-      500: schemaValidator.string,
-      ...Object.fromEntries(
-        Object.entries(
-          discriminateResponseBodies(
-            this.schemaValidator,
-            contractDetailsIO.responses
-          )
-        ).map(([key, value]) => {
-          return [Number(key), value.schema];
-        })
-      )
-    };
-    return {
-      requestSchema: schemaValidator.compile(
-        schemaValidator.schemify({
-          ...params != null ? { params } : { params: schemaValidator.unknown },
-          ...contractDetailsIO.requestHeaders != null ? { headers: contractDetailsIO.requestHeaders } : { headers: schemaValidator.unknown },
-          ...contractDetailsIO.query != null ? { query: contractDetailsIO.query } : { query: schemaValidator.unknown },
-          ...contractDetailsIO.body != null ? {
-            body: discriminateBody(
-              this.schemaValidator,
-              contractDetailsIO.body
-            )?.schema
-          } : { body: schemaValidator.unknown }
-        })
-      ),
-      responseSchemas: {
-        ...contractDetailsIO.responseHeaders != null ? {
-          headers: schemaValidator.compile(
-            schemaValidator.schemify(contractDetailsIO.responseHeaders)
-          )
-        } : { headers: schemaValidator.unknown },
-        responses: Object.fromEntries(
-          Object.entries(responseSchemas).map(([key, value]) => {
-            return [
-              key,
-              schemaValidator.compile(schemaValidator.schemify(value))
-            ];
-          })
-        )
-      }
-    };
-  }
-  #compile(contractDetails) {
-    const schemaValidator = this.schemaValidator;
-    let requestSchema;
-    let responseSchemas;
-    if (hasVersionedSchema(contractDetails)) {
-      requestSchema = {};
-      responseSchemas = {};
-      Object.entries(contractDetails.versions ?? {}).forEach(
-        ([version, versionedContractDetails]) => {
-          const {
-            requestSchema: versionedRequestSchema,
-            responseSchemas: versionedResponseSchemas
-          } = this.#processContractDetailsIO(
-            versionedContractDetails,
-            contractDetails.params
-          );
-          if ((0, import_common9.isRecord)(requestSchema)) {
-            requestSchema = {
-              ...requestSchema,
-              [version]: versionedRequestSchema
-            };
-          }
-          if ((0, import_common9.isRecord)(responseSchemas)) {
-            responseSchemas = {
-              ...responseSchemas,
-              [version]: versionedResponseSchemas
-            };
-          }
-        }
-      );
-    } else {
-      const {
-        requestSchema: unversionedRequestSchema,
-        responseSchemas: unversionedResponseSchemas
-      } = this.#processContractDetailsIO(
-        {
-          ..."params" in contractDetails && contractDetails.params != null ? { params: contractDetails.params } : { params: schemaValidator.unknown },
-          ..."requestHeaders" in contractDetails && contractDetails.requestHeaders != null ? { requestHeaders: contractDetails.requestHeaders } : {
-            requestHeaders: schemaValidator.unknown
-          },
-          ..."responseHeaders" in contractDetails && contractDetails.responseHeaders != null ? { responseHeaders: contractDetails.responseHeaders } : {
-            responseHeaders: schemaValidator.unknown
-          },
-          ..."query" in contractDetails && contractDetails.query != null ? { query: contractDetails.query } : {
-            query: schemaValidator.unknown
-          },
-          ..."body" in contractDetails && contractDetails.body != null ? { body: contractDetails.body } : {
-            body: schemaValidator.unknown
-          },
-          responses: "responses" in contractDetails && contractDetails.responses != null ? contractDetails.responses : schemaValidator.unknown
-        },
-        contractDetails.params
-      );
-      requestSchema = unversionedRequestSchema;
-      responseSchemas = unversionedResponseSchemas;
-    }
-    return {
-      requestSchema,
-      responseSchemas
-    };
-  }
   /**
    * Fetches a route from the route map and executes it with the given parameters.
    *
@@ -1472,92 +1604,71 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
     };
   }
   registerRoute(method, path, registrationMethod, contractDetailsOrMiddlewareOrTypedHandler, ...middlewareOrMiddlewareAndTypedHandler) {
-    if (isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
-      const { contractDetails, handlers } = contractDetailsOrMiddlewareOrTypedHandler;
-      const router = this.registerRoute(method, path, registrationMethod, contractDetails, ...handlers);
-      return router;
-    } else {
-      const maybeTypedHandler = middlewareOrMiddlewareAndTypedHandler[middlewareOrMiddlewareAndTypedHandler.length - 1];
-      if (isTypedHandler(maybeTypedHandler)) {
-        const { contractDetails, handlers } = maybeTypedHandler;
-        const finalHandlers = [];
-        if (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
-          finalHandlers.push(
-            contractDetailsOrMiddlewareOrTypedHandler
-          );
-        }
-        finalHandlers.push(...middlewareOrMiddlewareAndTypedHandler);
-        finalHandlers.push(...handlers);
-        const router = this.registerRoute(method, path, registrationMethod, contractDetails, ...finalHandlers);
-        return router;
-      } else {
-        if (isExpressLikeSchemaHandler(contractDetailsOrMiddlewareOrTypedHandler) || isTypedHandler(contractDetailsOrMiddlewareOrTypedHandler)) {
-          throw new Error("Contract details are not defined");
-        }
-        const contractDetails = contractDetailsOrMiddlewareOrTypedHandler;
-        const handlers = middlewareOrMiddlewareAndTypedHandler.filter(
-          (handler) => isExpressLikeSchemaHandler(handler)
-        );
-        if (!isHttpContractDetails(contractDetails) && !isPathParamHttpContractDetails(contractDetails)) {
-          throw new Error(
-            "Contract details are malformed for route definition"
-          );
-        }
-        if (contractDetails.versions) {
-          const parserTypes = Object.values(contractDetails.versions).map(
-            (version) => discriminateBody(this.schemaValidator, version.body)?.parserType
-          );
-          const allParserTypesSame = parserTypes.length === 0 || parserTypes.every((pt) => pt === parserTypes[0]);
-          if (!allParserTypesSame) {
-            throw new Error(
-              "All versioned contractDetails must have the same parsing type for body."
-            );
-          }
-        }
-        this.routes.push({
-          basePath: this.basePath,
-          path,
-          method,
-          contractDetails
-        });
-        const { requestSchema, responseSchemas } = this.#compile(contractDetails);
-        const controllerHandler = this.#extractControllerHandler(handlers);
-        const resolvedMiddlewares = this.#resolveMiddlewares(
-          path,
-          contractDetails,
-          requestSchema,
-          responseSchemas
-        ).concat(handlers);
-        registrationMethod.bind(this.internal)(
-          path,
-          ...resolvedMiddlewares,
-          this.#parseAndRunControllerHandler(controllerHandler)
-        );
-        (0, import_common9.toRecord)(this._fetchMap)[(0, import_common9.sanitizePathSlashes)(`${this.basePath}${path}`)] = {
-          ...this._fetchMap[(0, import_common9.sanitizePathSlashes)(`${this.basePath}${path}`)] ?? {},
-          [method.toUpperCase()]: contractDetails.versions ? Object.fromEntries(
-            Object.keys(contractDetails.versions).map((version) => [
-              version,
-              this.#localParamRequest(handlers, controllerHandler, version)
-            ])
-          ) : this.#localParamRequest(handlers, controllerHandler)
-        };
-        (0, import_common9.toRecord)(this.sdk)[(0, import_common9.toPrettyCamelCase)(contractDetails.name)] = contractDetails.versions ? Object.fromEntries(
-          Object.keys(contractDetails.versions).map((version) => [
-            version,
-            (req) => this.#localParamRequest(
-              handlers,
-              controllerHandler,
-              version
-            )(`${this.basePath}${path}`, req)
-          ])
-        ) : (req) => this.#localParamRequest(handlers, controllerHandler)(
-          `${this.basePath}${path}`,
-          req
-        );
-        return this;
-      }
+    const { contractDetails, handlers } = resolveContractDetailsAndHandlers(
+      contractDetailsOrMiddlewareOrTypedHandler,
+      middlewareOrMiddlewareAndTypedHandler
+    );
+    validateContractDetails(contractDetails, this.schemaValidator);
+    this.routes.push({
+      basePath: this.basePath,
+      path,
+      method,
+      contractDetails
+    });
+    const { requestSchema, responseSchemas } = compileRouteSchemas(
+      contractDetails,
+      this.schemaValidator
+    );
+    const { middlewares, controllerHandler } = resolveRouteMiddlewares({
+      basePath: this.basePath,
+      path,
+      contractDetails,
+      requestSchema,
+      responseSchemas,
+      openTelemetryCollector: this.openTelemetryCollector,
+      routerOptions: this.routerOptions,
+      postEnrichMiddleware: this.postEnrichMiddleware,
+      includeCreateContext: false,
+      handlers
+    });
+    registrationMethod.bind(this.internal)(
+      path,
+      ...middlewares,
+      this.#parseAndRunControllerHandler(controllerHandler)
+    );
+    (0, import_common11.toRecord)(this._fetchMap)[(0, import_common11.sanitizePathSlashes)(`${this.basePath}${path}`)] = {
+      ...this._fetchMap[(0, import_common11.sanitizePathSlashes)(`${this.basePath}${path}`)] ?? {},
+      [method.toUpperCase()]: contractDetails.versions ? Object.fromEntries(
+        Object.keys(contractDetails.versions).map((version) => [
+          version,
+          this.#localParamRequest(
+            middlewares,
+            controllerHandler,
+            version
+          )
+        ])
+      ) : this.#localParamRequest(
+        middlewares,
+        controllerHandler
+      )
+    };
+    const contractDetailsName = contractDetails.name;
+    if (contractDetailsName) {
+      (0, import_common11.toRecord)(this.sdk)[(0, import_common11.toPrettyCamelCase)(contractDetailsName)] = contractDetails.versions ? Object.fromEntries(
+        Object.keys(contractDetails.versions).map((version) => [
+          version,
+          (req) => this.#localParamRequest(
+            middlewares,
+            controllerHandler,
+            version
+          )(`${this.basePath}${path}`, req)
+        ])
+      ) : (req) => this.#localParamRequest(
+        middlewares,
+        controllerHandler
+      )(`${this.basePath}${path}`, req);
     }
+    return this;
   }
   #extractHandlers(handlers, processMiddleware) {
     const last = handlers.pop();
@@ -1641,10 +1752,10 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   }
   addRouterToSdk(router) {
     Object.entries(router._fetchMap).map(
-      ([key, value]) => (0, import_common9.toRecord)(this._fetchMap)[(0, import_common9.sanitizePathSlashes)(`${this.basePath}${key}`)] = value
+      ([key, value]) => (0, import_common11.toRecord)(this._fetchMap)[(0, import_common11.sanitizePathSlashes)(`${this.basePath}${key}`)] = value
     );
-    const existingSdk = this.sdk[router.sdkName ?? (0, import_common9.toPrettyCamelCase)(router.basePath)];
-    (0, import_common9.toRecord)(this.sdk)[router.sdkName ?? (0, import_common9.toPrettyCamelCase)(router.basePath)] = {
+    const existingSdk = this.sdk[router.sdkName ?? (0, import_common11.toPrettyCamelCase)(router.basePath)];
+    (0, import_common11.toRecord)(this.sdk)[router.sdkName ?? (0, import_common11.toPrettyCamelCase)(router.basePath)] = {
       ...typeof existingSdk === "object" ? existingSdk : {},
       ...router.sdk
     };
@@ -1936,7 +2047,7 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   unpackSdks(sdks, path, routerUniquenessCache) {
     Object.entries(sdks).forEach(([key, maybeHandler]) => {
       if (isSdkHandler(maybeHandler)) {
-        const cacheKey = (0, import_common9.hashString)((0, import_common9.safeStringify)(maybeHandler));
+        const cacheKey = (0, import_common11.hashString)((0, import_common11.safeStringify)(maybeHandler));
         if (routerUniquenessCache.has(cacheKey)) {
           throw new Error(`SDK handler ${key} is already registered`);
         }
@@ -2030,6 +2141,30 @@ function isPortBound(port, host = "localhost") {
   });
 }
 
+// src/http/generateHmacAuthHeaders.ts
+var import_crypto2 = require("crypto");
+function generateHmacAuthHeaders({
+  secretKey,
+  method,
+  path,
+  body,
+  keyId = "default"
+}) {
+  const timestamp = /* @__PURE__ */ new Date();
+  const nonce = (0, import_crypto2.randomUUID)();
+  const signature = createHmacToken({
+    secretKey,
+    method,
+    path,
+    timestamp,
+    nonce,
+    body
+  });
+  return {
+    authorization: `HMAC keyId=${keyId} ts=${timestamp.toISOString()} nonce=${nonce} signature=${signature}`
+  };
+}
+
 // src/http/guards/isPath.ts
 function isPath(path) {
   return path.startsWith("/");
@@ -3100,7 +3235,7 @@ var getCodeForStatus = (status) => {
 var httpStatusCodes_default = HTTPStatuses;
 
 // src/http/mcpGenerator/mcpGenerator.ts
-var import_common10 = require("@forklaunch/common");
+var import_common12 = require("@forklaunch/common");
 var import_fastmcp_fork = require("@forklaunch/fastmcp-fork");
 var import_zod = require("@forklaunch/validator/zod");
 
@@ -3235,7 +3370,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
             if (discriminatedBody) {
               switch (discriminatedBody.parserType) {
                 case "json": {
-                  parsedBody = (0, import_common10.safeStringify)(body);
+                  parsedBody = (0, import_common12.safeStringify)(body);
                   break;
                 }
                 case "text": {
@@ -3243,12 +3378,12 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                   break;
                 }
                 case "file": {
-                  parsedBody = Buffer.from((0, import_common10.safeStringify)(body));
+                  parsedBody = Buffer.from((0, import_common12.safeStringify)(body));
                   break;
                 }
                 case "multipart": {
                   const formData = new FormData();
-                  if ((0, import_common10.isRecord)(body)) {
+                  if ((0, import_common12.isRecord)(body)) {
                     for (const key in body) {
                       if (typeof body[key] === "string") {
                         if (schemaValidator.isInstanceOf(
@@ -3273,11 +3408,11 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                   break;
                 }
                 case "urlEncoded": {
-                  if ((0, import_common10.isRecord)(body)) {
+                  if ((0, import_common12.isRecord)(body)) {
                     parsedBody = new URLSearchParams(
                       Object.entries(body).map(([key, value]) => [
                         key,
-                        (0, import_common10.safeStringify)(value)
+                        (0, import_common12.safeStringify)(value)
                       ])
                     );
                   } else {
@@ -3286,8 +3421,8 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                   break;
                 }
                 default: {
-                  (0, import_common10.isNever)(discriminatedBody.parserType);
-                  parsedBody = (0, import_common10.safeStringify)(body);
+                  (0, import_common12.isNever)(discriminatedBody.parserType);
+                  parsedBody = (0, import_common12.safeStringify)(body);
                   break;
                 }
               }
@@ -3296,7 +3431,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
               const queryString = new URLSearchParams(
                 Object.entries(query).map(([key, value]) => [
                   key,
-                  (0, import_common10.safeStringify)(value)
+                  (0, import_common12.safeStringify)(value)
                 ])
               ).toString();
               url += queryString ? `?${queryString}` : "";
@@ -3329,7 +3464,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                   content: [
                     {
                       type: "text",
-                      text: (0, import_common10.safeStringify)(await response.json())
+                      text: (0, import_common12.safeStringify)(await response.json())
                     }
                   ]
                 };
@@ -3471,7 +3606,7 @@ Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
         }
         return;
       case "warning":
-        req.openTelemetryCollector.warn(
+        req.openTelemetryCollector?.warn(
           `Invalid response:
 ${parseErrors.join("\n\n")}`
         );
@@ -3484,18 +3619,19 @@ ${parseErrors.join("\n\n")}`
 }
 
 // src/http/middleware/response/enrichExpressLikeSend.middleware.ts
-var import_common12 = require("@forklaunch/common");
+var import_common14 = require("@forklaunch/common");
 var import_stream = require("stream");
 
 // src/http/telemetry/recordMetric.ts
-var import_common11 = require("@forklaunch/common");
+var import_common13 = require("@forklaunch/common");
 var import_semantic_conventions3 = require("@opentelemetry/semantic-conventions");
 function recordMetric(req, res) {
   if (res.metricRecorded) {
     return;
   }
   httpRequestsTotalCounter.add(1, {
-    [import_semantic_conventions3.ATTR_SERVICE_NAME]: (0, import_common11.getEnvVar)("OTEL_SERVICE_NAME"),
+    [import_semantic_conventions3.ATTR_SERVICE_NAME]: (0, import_common13.getEnvVar)("OTEL_SERVICE_NAME"),
+    [ATTR_APPLICATION_ID]: (0, import_common13.getEnvVar)("OTEL_APPLICATION_ID"),
     [ATTR_API_NAME]: req.contractDetails?.name,
     [import_semantic_conventions3.ATTR_HTTP_REQUEST_METHOD]: req.method,
     [import_semantic_conventions3.ATTR_HTTP_ROUTE]: req.originalPath,
@@ -3514,7 +3650,7 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
   if (res.statusCode === 404) {
     res.type("text/plain");
     res.status(404);
-    req.openTelemetryCollector.error("Not Found");
+    req.openTelemetryCollector?.error("Not Found");
     originalSend.call(instance, "Not Found");
     errorSent = true;
   }
@@ -3544,8 +3680,8 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
         `attachment; filename="${data.name}"`
       );
     }
-    if ((0, import_common12.isNodeJsWriteableStream)(res)) {
-      import_stream.Readable.from((0, import_common12.readableStreamToAsyncIterable)(data.stream())).pipe(
+    if ((0, import_common14.isNodeJsWriteableStream)(res)) {
+      import_stream.Readable.from((0, import_common14.readableStreamToAsyncIterable)(data.stream())).pipe(
         res
       );
     } else {
@@ -3554,7 +3690,7 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
       originalSend.call(instance, "Not a NodeJS WritableStream");
       errorSent = true;
     }
-  } else if ((0, import_common12.isAsyncGenerator)(data)) {
+  } else if ((0, import_common14.isAsyncGenerator)(data)) {
     let firstPass = true;
     const transformer = new import_stream.Transform({
       objectMode: true,
@@ -3569,7 +3705,7 @@ function enrichExpressLikeSend(instance, req, res, originalOperation, originalSe
 ------------------
 ${res.locals.errorMessage}`;
               }
-              req.openTelemetryCollector.error(errorString);
+              req.openTelemetryCollector?.error(errorString);
               res.type("text/plain");
               res.status(500);
               originalSend.call(instance, errorString);
@@ -3578,7 +3714,7 @@ ${res.locals.errorMessage}`;
             } else {
               let data2 = "";
               for (const [key, value] of Object.entries(chunk)) {
-                data2 += `${key}: ${typeof value === "string" ? value : (0, import_common12.safeStringify)(value)}
+                data2 += `${key}: ${typeof value === "string" ? value : (0, import_common14.safeStringify)(value)}
 `;
               }
               data2 += "\n";
@@ -3589,7 +3725,7 @@ ${res.locals.errorMessage}`;
         } else if (!errorSent) {
           let data2 = "";
           for (const [key, value] of Object.entries(chunk)) {
-            data2 += `${key}: ${typeof value === "string" ? value : (0, import_common12.safeStringify)(value)}
+            data2 += `${key}: ${typeof value === "string" ? value : (0, import_common14.safeStringify)(value)}
 `;
           }
           data2 += "\n";
@@ -3597,7 +3733,7 @@ ${res.locals.errorMessage}`;
         }
       }
     });
-    if ((0, import_common12.isNodeJsWriteableStream)(res)) {
+    if ((0, import_common14.isNodeJsWriteableStream)(res)) {
       import_stream.Readable.from(data).pipe(transformer).pipe(res);
     } else {
       res.type("text/plain");
@@ -3608,7 +3744,7 @@ ${res.locals.errorMessage}`;
   } else {
     const parserType = responseBodies?.[Number(res.statusCode)]?.parserType;
     res.bodyData = data;
-    if ((0, import_common12.isRecord)(data)) {
+    if ((0, import_common14.isRecord)(data)) {
       switch (parserType) {
         case "json":
           res.bodyData = "json" in data ? data.json : data;
@@ -3629,7 +3765,7 @@ ${res.locals.errorMessage}`;
           res.bodyData = data;
           break;
         default:
-          (0, import_common12.isNever)(parserType);
+          (0, import_common14.isNever)(parserType);
           res.bodyData = data;
           break;
       }
@@ -3642,7 +3778,7 @@ ${res.locals.errorMessage}`;
 ------------------
 ${res.locals.errorMessage}`;
         }
-        req.openTelemetryCollector.error(errorString);
+        req.openTelemetryCollector?.error(errorString);
         res.type("text/plain");
         res.status(500);
         originalSend.call(instance, errorString);
@@ -3664,8 +3800,8 @@ ${res.locals.errorMessage}`;
 }
 
 // src/http/openApiV3Generator/openApiV3Generator.ts
-var import_common13 = require("@forklaunch/common");
-var OPENAPI_DEFAULT_VERSION = Symbol("default");
+var import_common15 = require("@forklaunch/common");
+var OPENAPI_DEFAULT_VERSION = /* @__PURE__ */ Symbol("default");
 function toUpperCase(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -3887,7 +4023,7 @@ function generateOpenApiSpecs(schemaValidator, serverUrls, serverDescriptions, a
   ].forEach(({ fullPath, router }) => {
     const controllerName = transformBasePath(fullPath);
     router.routes.forEach((route) => {
-      const openApiPath = (0, import_common13.openApiCompliantPath)(
+      const openApiPath = (0, import_common15.openApiCompliantPath)(
         `${fullPath}${route.path === "/" ? "" : route.path}`
       );
       const { name, summary, params, versions, auth, options: options2 } = route.contractDetails;
@@ -4014,6 +4150,7 @@ function metricsDefinitions(metrics2) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ATTR_API_NAME,
+  ATTR_APPLICATION_ID,
   ATTR_CORRELATION_ID,
   ATTR_HTTP_REQUEST_METHOD,
   ATTR_HTTP_RESPONSE_STATUS_CODE,
@@ -4025,6 +4162,7 @@ function metricsDefinitions(metrics2) {
   OPENAPI_DEFAULT_VERSION,
   OpenTelemetryCollector,
   PinoLogger,
+  createContext,
   createHmacToken,
   delete_,
   discriminateAuthMethod,
@@ -4032,6 +4170,8 @@ function metricsDefinitions(metrics2) {
   discriminateResponseBodies,
   enrichExpressLikeSend,
   evaluateTelemetryOptions,
+  extractRouteHandlers,
+  generateHmacAuthHeaders,
   generateMcpServer,
   generateOpenApiSpecs,
   get,