@forklaunch/core 0.16.1 → 0.17.0

package/lib/http/index.mjs

@@ -22,18 +22,12 @@ function cors(corsOptions) {
 // src/http/router/expressLikeRouter.ts
 import {
   hashString,
-  isRecord as isRecord2,
-  safeStringify as safeStringify2,
+  safeStringify as safeStringify3,
   sanitizePathSlashes,
   toPrettyCamelCase,
   toRecord
 } from "@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/isForklaunchRouter.ts
 function isForklaunchRouter(maybeForklaunchRouter) {
   return maybeForklaunchRouter != null && typeof maybeForklaunchRouter === "object" && "basePath" in maybeForklaunchRouter && "routes" in maybeForklaunchRouter && Array.isArray(maybeForklaunchRouter.routes);
@@ -62,6 +56,197 @@ 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
+import { getEnvVar } from "@forklaunch/common";
+import { context, trace } from "@opentelemetry/api";
+import { v4 } from "uuid";
+
+// src/http/telemetry/constants.ts
+import {
+  ATTR_HTTP_REQUEST_METHOD,
+  ATTR_HTTP_RESPONSE_STATUS_CODE,
+  ATTR_HTTP_ROUTE,
+  ATTR_SERVICE_NAME
+} from "@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 = v4();
+    if (req.headers["x-correlation-id"]) {
+      correlationId = req.headers["x-correlation-id"];
+    }
+    res.setHeader("x-correlation-id", correlationId);
+    req.context = {
+      correlationId
+    };
+    const span = trace.getSpan(context.active());
+    if (span != null) {
+      req.context.span = span;
+      req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
+      req.context.span?.setAttribute(
+        ATTR_SERVICE_NAME,
+        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
+import { isRecord as isRecord2 } from "@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(
@@ -76,23 +261,14 @@ 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
-import { isNever } from "@forklaunch/common";
+import { isNever as isNever2 } from "@forklaunch/common";
 import {
   prettyPrintParseErrors
 } from "@forklaunch/validator";
 
 // src/http/discriminateAuthMethod.ts
+import { safeStringify as safeStringify2 } from "@forklaunch/common";
 import { jwtVerify } from "jose";
 
 // src/http/createHmacToken.ts
@@ -154,7 +330,7 @@ async function getCachedJwks(jwksPublicKeyUrl) {
     return jwks;
   }
 }
-async function discriminateAuthMethod(auth) {
+async function discriminateAuthMethod(auth, openTelemetryCollector) {
   let authMethod;
   if (isBasicAuthMethod(auth)) {
     authMethod = {
@@ -217,37 +393,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 ? safeStringify2(body) : "undefined"
+            });
+          }
+          return isValid;
+        }
+      }
+    };
+  }
+  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
+import { isNever } from "@forklaunch/common";
+import { trace as trace2 } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import pino from "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:
+      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 = pino({
+      level: level || "info",
+      formatters: {
+        level(label) {
+          return { level: label };
+        }
+      },
+      timestamp: pino.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 = trace2.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 {
+      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
+      );
+    }
   }
-  if (authMethod == null) {
-    throw new Error("Invalid auth method");
+  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 });
   }
-  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;
+  getBaseLogger() {
+    return this.pinoLogger;
+  }
+};
+function logger(level, meta2 = {}) {
+  return new PinoLogger(level, meta2);
 }
 
 // src/http/middleware/request/auth.middleware.ts
@@ -311,7 +669,8 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
   }
   let sessionPayload;
   const { type, auth } = await discriminateAuthMethod(
-    collapsedAuthorizationMethod
+    collapsedAuthorizationMethod,
+    req.openTelemetryCollector
   );
   switch (type) {
     case "hmac": {
@@ -332,7 +691,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,
@@ -356,7 +715,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;
@@ -383,7 +750,7 @@ async function checkAuthorizationToken(req, authorizationMethod, authorizationTo
       break;
     }
     default:
-      isNever(type);
+      isNever2(type);
       return [401, "Invalid Authorization method."];
   }
   if (isHmacMethod(collapsedAuthorizationMethod) && sessionPayload == null) {
@@ -468,14 +835,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;
@@ -483,46 +854,6 @@ async function parseRequestAuth(req, res, next) {
   next?.();
 }
 
-// src/http/middleware/request/createContext.middleware.ts
-import { getEnvVar } from "@forklaunch/common";
-import { context, trace } from "@opentelemetry/api";
-import { v4 } from "uuid";
-
-// src/http/telemetry/constants.ts
-import {
-  ATTR_HTTP_REQUEST_METHOD,
-  ATTR_HTTP_RESPONSE_STATUS_CODE,
-  ATTR_HTTP_ROUTE,
-  ATTR_SERVICE_NAME
-} from "@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 = v4();
-    if (req.headers["x-correlation-id"]) {
-      correlationId = req.headers["x-correlation-id"];
-    }
-    res.setHeader("x-correlation-id", correlationId);
-    req.context = {
-      correlationId
-    };
-    const span = trace.getSpan(context.active());
-    if (span != null) {
-      req.context.span = span;
-      req.context.span?.setAttribute(ATTR_CORRELATION_ID, correlationId);
-      req.context.span?.setAttribute(
-        ATTR_SERVICE_NAME,
-        getEnvVar("OTEL_SERVICE_NAME")
-      );
-    }
-    next?.();
-  };
-}
-
 // src/http/middleware/request/enrichDetails.middleware.ts
 import { getEnvVar as getEnvVar3 } from "@forklaunch/common";
 
@@ -551,171 +882,6 @@ function isForklaunchRequest(request) {
   return request != null && typeof request === "object" && "contractDetails" in request;
 }
 
-// src/http/telemetry/pinoLogger.ts
-import { isNever as isNever2 } from "@forklaunch/common";
-import { trace as trace2 } from "@opentelemetry/api";
-import { logs } from "@opentelemetry/api-logs";
-import pino from "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:
-      isNever2(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 = pino({
-      level: level || "info",
-      formatters: {
-        level(label) {
-          return { level: label };
-        }
-      },
-      timestamp: pino.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 = trace2.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 {
-      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;
@@ -781,23 +947,39 @@ var OpenTelemetryCollector = class {
   }
 };
 dotenv.config({ path: getEnvVar2("DOTENV_FILE_PATH") });
+function parseOtelHeaders() {
+  const headersEnv = getEnvVar2("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 NodeSDK({
   resource: resourceFromAttributes({
     [ATTR_SERVICE_NAME2]: getEnvVar2("OTEL_SERVICE_NAME")
   }),
   traceExporter: new OTLPTraceExporter({
-    url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`
+    url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/traces`,
+    headers: otelHeaders
   }),
   metricReader: new PeriodicExportingMetricReader({
     exporter: new OTLPMetricExporter({
-      url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`
+      url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/metrics`,
+      headers: otelHeaders
     }),
     exportIntervalMillis: 5e3
   }),
   logRecordProcessors: [
     new BatchLogRecordProcessor(
       new OTLPLogExporter({
-        url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`
+        url: `${getEnvVar2("OTEL_EXPORTER_OTLP_ENDPOINT") ?? "http://localhost:4318"}/v1/logs`,
+        headers: otelHeaders
       })
     )
   ],
@@ -834,7 +1016,7 @@ 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", () => {
@@ -842,6 +1024,7 @@ function enrichDetails(path, contractDetails, requestSchema, responseSchemas, op
       const durationMs = seconds + nanoseconds / 1e9;
       httpServerDurationHistogram.record(durationMs, {
         [ATTR_SERVICE_NAME]: getEnvVar3("OTEL_SERVICE_NAME") || "unknown",
+        [ATTR_APPLICATION_ID]: getEnvVar3("OTEL_APPLICATION_ID"),
         [ATTR_API_NAME]: req.contractDetails?.name || "unknown",
         [ATTR_HTTP_REQUEST_METHOD]: req.method,
         [ATTR_HTTP_ROUTE]: req.originalPath || "unknown",
@@ -872,6 +1055,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,
@@ -961,7 +1145,7 @@ Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
         }
         return;
       case "warning":
-        req.openTelemetryCollector.warn(
+        req.openTelemetryCollector?.warn(
           collectedParseErrors ?? prettyPrintParseErrors2(parsedRequest.errors, "Request")
         );
         break;
@@ -969,143 +1153,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 };
 }
-
-// src/http/router/discriminateBody.ts
-function discriminateBody(schemaValidator, body) {
-  if (body == null) {
-    return void 0;
+function validateContractDetails(contractDetails, schemaValidator) {
+  if (!isHttpContractDetails(contractDetails) && !isPathParamHttpContractDetails(contractDetails)) {
+    throw new Error("Contract details are malformed for route definition");
   }
-  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
-    };
+  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."
+      );
+    }
   }
 }
-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 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 (isRecord2(requestSchema)) {
+          requestSchema = {
+            ...requestSchema,
+            [version]: versionedRequestSchema
+          };
+        }
+        if (isRecord2(responseSchemas)) {
+          responseSchemas = {
+            ...responseSchemas,
+            [version]: versionedResponseSchemas
+          };
+        }
+      }
+    );
+  } else {
+    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 discriminatedResponses;
+  return { requestSchema, responseSchemas };
+}
+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}`
+    );
+  }
+  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;
@@ -1145,21 +1407,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.
    *
@@ -1200,126 +1447,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 (isRecord2(requestSchema)) {
-            requestSchema = {
-              ...requestSchema,
-              [version]: versionedRequestSchema
-            };
-          }
-          if (isRecord2(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.
    *
@@ -1409,92 +1536,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)
-        );
-        toRecord(this._fetchMap)[sanitizePathSlashes(`${this.basePath}${path}`)] = {
-          ...this._fetchMap[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)
-        };
-        toRecord(this.sdk)[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)
+    );
+    toRecord(this._fetchMap)[sanitizePathSlashes(`${this.basePath}${path}`)] = {
+      ...this._fetchMap[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) {
+      toRecord(this.sdk)[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();
@@ -1873,7 +1979,7 @@ var ForklaunchExpressLikeRouter = class _ForklaunchExpressLikeRouter {
   unpackSdks(sdks, path, routerUniquenessCache) {
     Object.entries(sdks).forEach(([key, maybeHandler]) => {
       if (isSdkHandler(maybeHandler)) {
-        const cacheKey = hashString(safeStringify2(maybeHandler));
+        const cacheKey = hashString(safeStringify3(maybeHandler));
         if (routerUniquenessCache.has(cacheKey)) {
           throw new Error(`SDK handler ${key} is already registered`);
         }
@@ -1967,6 +2073,30 @@ function isPortBound(port, host = "localhost") {
   });
 }
 
+// src/http/generateHmacAuthHeaders.ts
+import { randomUUID } from "crypto";
+function generateHmacAuthHeaders({
+  secretKey,
+  method,
+  path,
+  body,
+  keyId = "default"
+}) {
+  const timestamp = /* @__PURE__ */ new Date();
+  const nonce = 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("/");
@@ -3037,7 +3167,7 @@ var getCodeForStatus = (status) => {
 var httpStatusCodes_default = HTTPStatuses;
 
 // src/http/mcpGenerator/mcpGenerator.ts
-import { isNever as isNever3, isRecord as isRecord3, safeStringify as safeStringify3 } from "@forklaunch/common";
+import { isNever as isNever3, isRecord as isRecord3, safeStringify as safeStringify4 } from "@forklaunch/common";
 import { FastMCP } from "@forklaunch/fastmcp-fork";
 import { string, ZodSchemaValidator } from "@forklaunch/validator/zod";
 
@@ -3172,7 +3302,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
             if (discriminatedBody) {
               switch (discriminatedBody.parserType) {
                 case "json": {
-                  parsedBody = safeStringify3(body);
+                  parsedBody = safeStringify4(body);
                   break;
                 }
                 case "text": {
@@ -3180,7 +3310,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                   break;
                 }
                 case "file": {
-                  parsedBody = Buffer.from(safeStringify3(body));
+                  parsedBody = Buffer.from(safeStringify4(body));
                   break;
                 }
                 case "multipart": {
@@ -3214,7 +3344,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                     parsedBody = new URLSearchParams(
                       Object.entries(body).map(([key, value]) => [
                         key,
-                        safeStringify3(value)
+                        safeStringify4(value)
                       ])
                     );
                   } else {
@@ -3224,7 +3354,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                 }
                 default: {
                   isNever3(discriminatedBody.parserType);
-                  parsedBody = safeStringify3(body);
+                  parsedBody = safeStringify4(body);
                   break;
                 }
               }
@@ -3233,7 +3363,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
               const queryString = new URLSearchParams(
                 Object.entries(query).map(([key, value]) => [
                   key,
-                  safeStringify3(value)
+                  safeStringify4(value)
                 ])
               ).toString();
               url += queryString ? `?${queryString}` : "";
@@ -3266,7 +3396,7 @@ function generateMcpServer(schemaValidator, protocol, host, port, version, appli
                   content: [
                     {
                       type: "text",
-                      text: safeStringify3(await response.json())
+                      text: safeStringify4(await response.json())
                     }
                   ]
                 };
@@ -3410,7 +3540,7 @@ Correlation id: ${req.context.correlationId ?? "No correlation ID"}`
         }
         return;
       case "warning":
-        req.openTelemetryCollector.warn(
+        req.openTelemetryCollector?.warn(
           `Invalid response:
 ${parseErrors.join("\n\n")}`
         );
@@ -3429,7 +3559,7 @@ import {
   isNodeJsWriteableStream,
   isRecord as isRecord4,
   readableStreamToAsyncIterable,
-  safeStringify as safeStringify4
+  safeStringify as safeStringify5
 } from "@forklaunch/common";
 import { Readable, Transform } from "stream";
 
@@ -3447,6 +3577,7 @@ function recordMetric(req, res) {
   }
   httpRequestsTotalCounter.add(1, {
     [ATTR_SERVICE_NAME3]: getEnvVar4("OTEL_SERVICE_NAME"),
+    [ATTR_APPLICATION_ID]: getEnvVar4("OTEL_APPLICATION_ID"),
     [ATTR_API_NAME]: req.contractDetails?.name,
     [ATTR_HTTP_REQUEST_METHOD3]: req.method,
     [ATTR_HTTP_ROUTE3]: req.originalPath,
@@ -3465,7 +3596,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;
   }
@@ -3520,7 +3651,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);
@@ -3529,7 +3660,7 @@ ${res.locals.errorMessage}`;
             } else {
               let data2 = "";
               for (const [key, value] of Object.entries(chunk)) {
-                data2 += `${key}: ${typeof value === "string" ? value : safeStringify4(value)}
+                data2 += `${key}: ${typeof value === "string" ? value : safeStringify5(value)}
 `;
               }
               data2 += "\n";
@@ -3540,7 +3671,7 @@ ${res.locals.errorMessage}`;
         } else if (!errorSent) {
           let data2 = "";
           for (const [key, value] of Object.entries(chunk)) {
-            data2 += `${key}: ${typeof value === "string" ? value : safeStringify4(value)}
+            data2 += `${key}: ${typeof value === "string" ? value : safeStringify5(value)}
 `;
           }
           data2 += "\n";
@@ -3593,7 +3724,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);
@@ -3616,7 +3747,7 @@ ${res.locals.errorMessage}`;
 
 // src/http/openApiV3Generator/openApiV3Generator.ts
 import { openApiCompliantPath } from "@forklaunch/common";
-var OPENAPI_DEFAULT_VERSION = Symbol("default");
+var OPENAPI_DEFAULT_VERSION = /* @__PURE__ */ Symbol("default");
 function toUpperCase(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -3964,6 +4095,7 @@ function metricsDefinitions(metrics2) {
 }
 export {
   ATTR_API_NAME,
+  ATTR_APPLICATION_ID,
   ATTR_CORRELATION_ID,
   ATTR_HTTP_REQUEST_METHOD,
   ATTR_HTTP_RESPONSE_STATUS_CODE,
@@ -3975,6 +4107,7 @@ export {
   OPENAPI_DEFAULT_VERSION,
   OpenTelemetryCollector,
   PinoLogger,
+  createContext,
   createHmacToken,
   delete_,
   discriminateAuthMethod,
@@ -3982,6 +4115,8 @@ export {
   discriminateResponseBodies,
   enrichExpressLikeSend,
   evaluateTelemetryOptions,
+  extractRouteHandlers,
+  generateHmacAuthHeaders,
   generateMcpServer,
   generateOpenApiSpecs,
   get,