@blyp/core 0.1.2

package/dist/nestjs.mjs

@@ -0,0 +1,4621 @@
+import { z } from 'zod';
+import fs, { existsSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { createJiti } from 'jiti';
+import path, { resolve, dirname } from 'path';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';
+import { PostHog } from 'posthog-node';
+import { gzipSync } from 'fflate';
+import pino from 'pino';
+import { AsyncLocalStorage } from 'async_hooks';
+import { randomUUID } from 'crypto';
+import * as Sentry from '@sentry/node';
+import { Logtail } from '@logtail/node';
+import { Catch, Inject, Injectable, Global, Module, RequestMethod, HttpException } from '@nestjs/common';
+import { APP_INTERCEPTOR, APP_FILTER, BaseExceptionFilter } from '@nestjs/core';
+import { tap } from 'rxjs';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/colors.ts
+function getMethodColor(method) {
+  const colors = {
+    GET: "\x1B[32m",
+    POST: "\x1B[36m",
+    PUT: "\x1B[33m",
+    PATCH: "\x1B[34m",
+    DELETE: "\x1B[31m"
+  };
+  const reset = "\x1B[0m";
+  return `${colors[method.toUpperCase()] || ""}${method}${reset}`;
+}
+function getStatusColor(statusCode) {
+  const reset = "\x1B[0m";
+  if (statusCode >= 500) return `\x1B[31m${statusCode}${reset}`;
+  if (statusCode >= 400) return `\x1B[33m${statusCode}${reset}`;
+  if (statusCode >= 300) return `\x1B[36m${statusCode}${reset}`;
+  if (statusCode >= 200) return `\x1B[32m${statusCode}${reset}`;
+  return `\x1B[37m${statusCode}${reset}`;
+}
+function getArrowForMethod(method) {
+  const arrows = {
+    GET: "\u2192",
+    POST: "\u2191",
+    PUT: "\u21D1",
+    PATCH: "\u2197",
+    DELETE: "\u2715"
+  };
+  return arrows[method.toUpperCase()] || "\u2022";
+}
+function getResponseTimeColor(ms) {
+  const reset = "\x1B[0m";
+  if (ms < 100) return `\x1B[32m${ms}ms${reset}`;
+  if (ms < 300) return `\x1B[33m${ms}ms${reset}`;
+  if (ms < 1e3) return `\x1B[31m${ms}ms${reset}`;
+  return `\x1B[41m\x1B[37m${ms}ms${reset}`;
+}
+
+// src/frameworks/shared/http.ts
+function getHeaderValue(headers, name) {
+  if (!headers) {
+    return void 0;
+  }
+  if (headers instanceof Headers) {
+    return headers.get(name) ?? headers.get(name.toLowerCase()) ?? void 0;
+  }
+  if (typeof headers.get === "function") {
+    const direct2 = headers.get(name);
+    return direct2 ?? headers.get(name.toLowerCase()) ?? void 0;
+  }
+  const record = headers;
+  const direct = record[name] ?? record[name.toLowerCase()];
+  if (Array.isArray(direct)) {
+    return direct[0];
+  }
+  return direct;
+}
+function parseForwardedHeader(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+    const match = entry.match(/for="?(\[[^\]]+\]|[^;,\s"]+)/i);
+    return match?.[1]?.replace(/^"|"$/g, "") ?? "";
+  }).map((entry) => entry.replace(/^\[|\]$/g, "")).filter(Boolean);
+}
+function parseForwardedFor(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function stripPort(host) {
+  if (host.startsWith("[")) {
+    const endIndex = host.indexOf("]");
+    return endIndex >= 0 ? host.slice(1, endIndex) : host;
+  }
+  return host.replace(/:\d+$/, "");
+}
+function detectBrowser(userAgent) {
+  if (/edg\//i.test(userAgent)) return "Edge";
+  if (/opr\//i.test(userAgent) || /opera/i.test(userAgent)) return "Opera";
+  if (/chrome\//i.test(userAgent) && !/edg\//i.test(userAgent)) return "Chrome";
+  if (/firefox\//i.test(userAgent)) return "Firefox";
+  if (/safari\//i.test(userAgent) && !/chrome\//i.test(userAgent)) return "Safari";
+  if (/curl\//i.test(userAgent)) return "curl";
+  if (/postmanruntime/i.test(userAgent)) return "Postman";
+  return "Unknown";
+}
+function detectOperatingSystem(userAgent) {
+  if (/windows/i.test(userAgent)) return "Windows";
+  if (/android/i.test(userAgent)) return "Android";
+  if (/iphone|ipad|ipod/i.test(userAgent)) return "iOS";
+  if (/mac os x|macintosh/i.test(userAgent)) return "macOS";
+  if (/linux/i.test(userAgent)) return "Linux";
+  return "Unknown";
+}
+function detectDeviceType(userAgent) {
+  if (!userAgent) return "unknown";
+  if (/bot|crawler|spider|curl|wget|postmanruntime/i.test(userAgent)) return "bot";
+  if (/ipad|tablet/i.test(userAgent)) return "tablet";
+  if (/mobi|iphone|android/i.test(userAgent)) return "mobile";
+  return "desktop";
+}
+function extractPathname(requestUrl, fallbackPath = "/") {
+  if (!requestUrl) {
+    return fallbackPath;
+  }
+  if (requestUrl.startsWith("http://") || requestUrl.startsWith("https://")) {
+    try {
+      return new URL(requestUrl).pathname || fallbackPath;
+    } catch {
+      return fallbackPath;
+    }
+  }
+  if (requestUrl.startsWith("/")) {
+    const queryIndex = requestUrl.indexOf("?");
+    return queryIndex >= 0 ? requestUrl.slice(0, queryIndex) : requestUrl;
+  }
+  try {
+    return new URL(requestUrl, "http://localhost").pathname || fallbackPath;
+  } catch {
+    return fallbackPath;
+  }
+}
+function createRequestLike(method, url, headers) {
+  return { method, url, headers };
+}
+function buildClientDetails(request, fallbackPath) {
+  const pathname = fallbackPath ?? extractPathname(request.url);
+  const urlObject = (() => {
+    try {
+      return new URL(request.url);
+    } catch {
+      try {
+        return new URL(pathname, "http://localhost");
+      } catch {
+        return null;
+      }
+    }
+  })();
+  const hostHeader = getHeaderValue(request.headers, "x-forwarded-host") ?? getHeaderValue(request.headers, "host") ?? urlObject?.host ?? void 0;
+  const hostname = hostHeader ? stripPort(hostHeader) : urlObject?.hostname;
+  const port = hostHeader?.match(/:(\d+)$/)?.[1] ?? (urlObject?.port || void 0);
+  const xForwardedFor = parseForwardedFor(getHeaderValue(request.headers, "x-forwarded-for"));
+  const forwardedFor = parseForwardedHeader(getHeaderValue(request.headers, "forwarded"));
+  const ipCandidates = [
+    getHeaderValue(request.headers, "cf-connecting-ip"),
+    getHeaderValue(request.headers, "true-client-ip"),
+    getHeaderValue(request.headers, "fly-client-ip"),
+    getHeaderValue(request.headers, "x-real-ip"),
+    getHeaderValue(request.headers, "x-client-ip"),
+    xForwardedFor[0],
+    forwardedFor[0]
+  ].filter((value) => Boolean(value));
+  const userAgent = getHeaderValue(request.headers, "user-agent");
+  const platform = getHeaderValue(request.headers, "sec-ch-ua-platform")?.replace(/^"|"$/g, "") ?? void 0;
+  const deviceType = detectDeviceType(userAgent ?? "");
+  return {
+    hostname,
+    ip: ipCandidates[0],
+    forwardedFor: [...xForwardedFor, ...forwardedFor].filter((value, index, values) => {
+      return values.indexOf(value) === index;
+    }),
+    protocol: getHeaderValue(request.headers, "x-forwarded-proto") ?? (urlObject?.protocol ? urlObject.protocol.replace(/:$/, "") : void 0),
+    port,
+    userAgent,
+    origin: getHeaderValue(request.headers, "origin"),
+    referer: getHeaderValue(request.headers, "referer"),
+    acceptLanguage: getHeaderValue(request.headers, "accept-language"),
+    client: {
+      ip: ipCandidates[0],
+      hostname,
+      browser: userAgent ? detectBrowser(userAgent) : void 0,
+      os: userAgent ? detectOperatingSystem(userAgent) : void 0,
+      deviceType,
+      platform,
+      isMobile: deviceType === "mobile"
+    }
+  };
+}
+function buildRequestLogData(request, type, path3, statusCode, responseTime, extra = {}) {
+  return {
+    type,
+    method: request.method,
+    url: path3,
+    statusCode,
+    responseTime,
+    ...buildClientDetails(request, path3),
+    ...extra
+  };
+}
+function buildInfoLogMessage(method, statusCode, url, responseTime) {
+  const methodColor = getMethodColor(method);
+  const statusColor = getStatusColor(statusCode);
+  const timeColor = getResponseTimeColor(responseTime);
+  const arrow = getArrowForMethod(method);
+  return `${methodColor} ${arrow} ${statusColor} ${url} ${timeColor}`;
+}
+function toErrorLike(error, fallbackStatusCode) {
+  if (error === void 0 || error === null) {
+    return fallbackStatusCode === void 0 ? void 0 : { statusCode: fallbackStatusCode, message: `HTTP ${fallbackStatusCode}` };
+  }
+  if (error instanceof Error) {
+    const errorWithStatus = error;
+    return {
+      status: errorWithStatus.status,
+      statusCode: errorWithStatus.statusCode ?? fallbackStatusCode,
+      code: errorWithStatus.code,
+      message: error.message,
+      stack: error.stack,
+      why: errorWithStatus.why,
+      fix: errorWithStatus.fix,
+      link: errorWithStatus.link,
+      details: errorWithStatus.details,
+      cause: errorWithStatus.cause
+    };
+  }
+  if (typeof error === "object") {
+    const record = error;
+    return {
+      status: typeof record.status === "number" ? record.status : void 0,
+      statusCode: typeof record.statusCode === "number" ? record.statusCode : fallbackStatusCode,
+      code: typeof record.code === "string" || typeof record.code === "number" ? record.code : void 0,
+      message: typeof record.message === "string" ? record.message : `HTTP ${fallbackStatusCode ?? 500}`,
+      stack: typeof record.stack === "string" ? record.stack : void 0,
+      why: typeof record.why === "string" ? record.why : void 0,
+      fix: typeof record.fix === "string" ? record.fix : void 0,
+      link: typeof record.link === "string" ? record.link : void 0,
+      details: record.details !== null && typeof record.details === "object" && !Array.isArray(record.details) ? record.details : void 0,
+      cause: record.cause
+    };
+  }
+  return {
+    statusCode: fallbackStatusCode,
+    message: typeof error === "string" ? error : `HTTP ${fallbackStatusCode ?? 500}`
+  };
+}
+function isErrorStatus(statusCode) {
+  return statusCode >= 400;
+}
+
+// src/shared/log-value.ts
+function normalizeError(error) {
+  const normalized = {
+    name: error.name,
+    message: error.message
+  };
+  if (error.stack) {
+    normalized.stack = error.stack;
+  }
+  const errorWithCause = error;
+  if (errorWithCause.cause !== void 0) {
+    normalized.cause = normalizeLogValue(errorWithCause.cause);
+  }
+  return normalized;
+}
+function normalizeLogValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value instanceof Error) {
+    return normalizeError(value);
+  }
+  if (typeof value === "function") {
+    return `[Function: ${value.name || "anonymous"}]`;
+  }
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeLogValue(entry, seen));
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+      normalized[key] = normalizeLogValue(entry, seen);
+    }
+    seen.delete(value);
+    return normalized;
+  }
+  return value;
+}
+function serializeLogMessage(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message instanceof Error) {
+    return message.message || message.name;
+  }
+  const normalized = normalizeLogValue(message);
+  if (typeof normalized === "string") {
+    return normalized;
+  }
+  try {
+    const serialized = JSON.stringify(normalized, null, 2);
+    return serialized ?? String(normalized);
+  } catch {
+    return String(normalized);
+  }
+}
+var absoluteHttpUrlSchema = z.string().url().refine((value) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}, {
+  message: "Expected an absolute http(s) URL"
+});
+var plainObjectSchema = z.custom(
+  (value) => {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  },
+  {
+    message: "Expected a plain object"
+  }
+);
+var nonEmptyStringSchema = z.string().trim().min(1);
+function isAbsoluteHttpUrl(value) {
+  return absoluteHttpUrlSchema.safeParse(value).success;
+}
+function isPlainObject(value) {
+  return plainObjectSchema.safeParse(value).success;
+}
+function hasNonEmptyString(value) {
+  return nonEmptyStringSchema.safeParse(value).success;
+}
+
+// src/shared/client-log.ts
+var DEFAULT_CLIENT_LOG_ENDPOINT = "/inngest";
+var CLIENT_LOG_LEVELS = [
+  "debug",
+  "info",
+  "warning",
+  "error",
+  "critical",
+  "success",
+  "table"
+];
+var clientConnectorRequestSchema = z.union([
+  z.literal("betterstack"),
+  z.literal("posthog"),
+  z.literal("sentry"),
+  z.undefined(),
+  z.object({
+    type: z.literal("otlp"),
+    name: nonEmptyStringSchema
+  })
+]);
+function isClientLogLevel(value) {
+  return typeof value === "string" && CLIENT_LOG_LEVELS.includes(value);
+}
+function isClientConnectorRequest(value) {
+  return clientConnectorRequestSchema.safeParse(value).success;
+}
+function isClientLogEvent(payload) {
+  if (!isPlainObject(payload)) {
+    return false;
+  }
+  if (payload.type !== "client_log" || payload.source !== "client" || !isClientLogLevel(payload.level) || typeof payload.id !== "string" || typeof payload.message !== "string" || typeof payload.clientTimestamp !== "string") {
+    return false;
+  }
+  const pageResult = plainObjectSchema.safeParse(payload.page);
+  const browserResult = plainObjectSchema.safeParse(payload.browser);
+  const sessionResult = plainObjectSchema.safeParse(payload.session);
+  if (!pageResult.success || !browserResult.success || !sessionResult.success) {
+    return false;
+  }
+  if (!isClientConnectorRequest(payload.connector)) {
+    return false;
+  }
+  return typeof sessionResult.data.pageId === "string" && typeof sessionResult.data.sessionId === "string";
+}
+function normalizeEndpointPath(path3) {
+  if (!path3) {
+    return DEFAULT_CLIENT_LOG_ENDPOINT;
+  }
+  return path3.startsWith("/") ? path3 : `/${path3}`;
+}
+
+// src/shared/once.ts
+function createConsoleOnceLogger(method, warnedKeys6 = /* @__PURE__ */ new Set()) {
+  return (key, message, error) => {
+    if (warnedKeys6.has(key) || typeof console === "undefined") {
+      return;
+    }
+    const writer = console[method];
+    if (typeof writer !== "function") {
+      return;
+    }
+    warnedKeys6.add(key);
+    if (error === void 0) {
+      writer.call(console, message);
+      return;
+    }
+    writer.call(console, message, error);
+  };
+}
+function createWarnOnceLogger(warnedKeys6) {
+  return createConsoleOnceLogger("warn", warnedKeys6);
+}
+function createErrorOnceLogger(warnedKeys6) {
+  return createConsoleOnceLogger("error", warnedKeys6);
+}
+
+// src/core/config.ts
+var PACKAGE_NAME = "@blyp/core";
+var GITIGNORE_FILE_NAME = ".gitignore";
+var CONFIG_FILE_NAMES = [
+  "blyp.config.ts",
+  "blyp.config.mts",
+  "blyp.config.cts",
+  "blyp.config.js",
+  "blyp.config.mjs",
+  "blyp.config.cjs",
+  "blyp.config.json"
+];
+var CONFIG_FILE_NAME = "blyp.config.json";
+var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
+var DEFAULT_CONNECTOR_SERVICE_NAME = "blyp-app";
+var DEFAULT_POSTHOG_SERVICE_NAME = DEFAULT_CONNECTOR_SERVICE_NAME;
+var warnedKeys = /* @__PURE__ */ new Set();
+var warnOnce = createWarnOnceLogger(warnedKeys);
+var DEFAULT_ROTATION_CONFIG = {
+  enabled: true,
+  maxSizeBytes: 10 * 1024 * 1024,
+  maxArchives: 5,
+  compress: true
+};
+var DEFAULT_FILE_CONFIG = {
+  enabled: true,
+  dir: "",
+  archiveDir: "",
+  format: "ndjson",
+  rotation: DEFAULT_ROTATION_CONFIG
+};
+var DEFAULT_CLIENT_LOGGING_CONFIG = {
+  enabled: true,
+  path: DEFAULT_CLIENT_LOG_ENDPOINT
+};
+var DEFAULT_DATABASE_RETRY_CONFIG = {
+  maxRetries: 1,
+  backoffMs: 100
+};
+var DEFAULT_DATABASE_DELIVERY_CONFIG = {
+  strategy: "immediate",
+  batchSize: 1,
+  flushIntervalMs: 250,
+  maxQueueSize: 1e3,
+  overflowStrategy: "drop-oldest",
+  flushTimeoutMs: 5e3,
+  retry: DEFAULT_DATABASE_RETRY_CONFIG
+};
+var DEFAULT_CONFIG = {
+  pretty: true,
+  level: "info",
+  destination: "file",
+  file: DEFAULT_FILE_CONFIG,
+  clientLogging: DEFAULT_CLIENT_LOGGING_CONFIG,
+  connectors: {}
+};
+var cachedConfig = null;
+function findNearestPackageName(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const packageJsonPath = resolve(currentDir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (hasNonEmptyString(packageJson.name)) {
+          return packageJson.name;
+        }
+      } catch {
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveDefaultConnectorServiceName(cwd = process.cwd()) {
+  return findNearestPackageName(cwd) ?? DEFAULT_POSTHOG_SERVICE_NAME;
+}
+function getBootstrapConfig() {
+  return {
+    pretty: true,
+    level: "info",
+    destination: "file",
+    file: {
+      enabled: true,
+      format: "ndjson",
+      rotation: {
+        enabled: true,
+        maxSizeBytes: 10 * 1024 * 1024,
+        maxArchives: 5,
+        compress: true
+      }
+    },
+    clientLogging: {
+      enabled: true,
+      path: DEFAULT_CLIENT_LOG_ENDPOINT
+    },
+    connectors: {}
+  };
+}
+function shouldBootstrapProjectFiles(cwd) {
+  const packageJsonPath = resolve(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return true;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.name !== PACKAGE_NAME;
+  } catch {
+    return true;
+  }
+}
+function ensureConfigFile(cwd) {
+  if (CONFIG_FILE_NAMES.some((fileName) => existsSync(resolve(cwd, fileName)))) {
+    return;
+  }
+  const configPath = resolve(cwd, CONFIG_FILE_NAME);
+  if (existsSync(configPath)) {
+    return;
+  }
+  try {
+    writeFileSync(configPath, `${JSON.stringify(getBootstrapConfig(), null, 2)}
+`);
+  } catch (error) {
+    console.error("[Blyp] Warning: Failed to create blyp.config.json:", error);
+  }
+}
+function ensureLogsIgnored(cwd) {
+  const gitignorePath = resolve(cwd, GITIGNORE_FILE_NAME);
+  if (!existsSync(gitignorePath)) {
+    try {
+      writeFileSync(gitignorePath, "logs\n");
+    } catch (error) {
+      console.error("[Blyp] Warning: Failed to create .gitignore:", error);
+    }
+    return;
+  }
+  try {
+    const currentContent = readFileSync(gitignorePath, "utf-8");
+    if (/^(?:\/?logs\/?)\s*$/m.test(currentContent)) {
+      return;
+    }
+    const separator = currentContent.endsWith("\n") ? "" : "\n";
+    appendFileSync(gitignorePath, `${separator}logs
+`);
+  } catch (error) {
+    console.error("[Blyp] Warning: Failed to update .gitignore:", error);
+  }
+}
+function bootstrapProjectFiles() {
+  const cwd = process.cwd();
+  if (!shouldBootstrapProjectFiles(cwd)) {
+    return;
+  }
+  ensureConfigFile(cwd);
+  ensureLogsIgnored(cwd);
+}
+function findConfigFile() {
+  const cwd = process.cwd();
+  const matches = CONFIG_FILE_NAMES.map((fileName) => resolve(cwd, fileName)).filter((filePath) => existsSync(filePath));
+  if (matches.length === 0) {
+    return null;
+  }
+  if (matches.length > 1) {
+    const preferred = matches[0];
+    warnOnce(
+      `config-multiple:${preferred}`,
+      `[Blyp] Warning: Multiple config files found. Using ${preferred} and ignoring ${matches.slice(1).join(", ")}.`
+    );
+  }
+  const selectedPath = matches[0];
+  return {
+    path: selectedPath,
+    type: selectedPath.endsWith(".json") ? "json" : "jiti"
+  };
+}
+function normalizeLoadedConfig(value, configPath) {
+  const normalized = value && typeof value === "object" && "default" in value && value.default !== void 0 ? value.default : value;
+  if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
+    warnOnce(
+      `config-invalid:${configPath}`,
+      `[Blyp] Warning: Config file ${configPath} did not export an object. Falling back to defaults.`
+    );
+    return {};
+  }
+  return normalized;
+}
+function parseJsonConfigFile(configPath) {
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return normalizeLoadedConfig(JSON.parse(content), configPath);
+  } catch (error) {
+    console.error("[Blyp] Warning: Failed to parse blyp.config.json:", error);
+    return {};
+  }
+}
+function parseExecutableConfigFile(configPath) {
+  try {
+    const jiti = createJiti(process.cwd(), {
+      interopDefault: true,
+      moduleCache: false,
+      fsCache: false
+    });
+    return normalizeLoadedConfig(jiti(configPath), configPath);
+  } catch (error) {
+    console.error(`[Blyp] Warning: Failed to load ${configPath}:`, error);
+    return {};
+  }
+}
+function parseConfigFile(config) {
+  return config.type === "json" ? parseJsonConfigFile(config.path) : parseExecutableConfigFile(config.path);
+}
+function isPrismaAdapter(value) {
+  return !!value && typeof value === "object" && value.type === "prisma";
+}
+function isDrizzleAdapter(value) {
+  return !!value && typeof value === "object" && value.type === "drizzle";
+}
+function mergeDatabaseRetryConfig(base, override) {
+  return {
+    ...DEFAULT_DATABASE_RETRY_CONFIG,
+    ...base,
+    ...override
+  };
+}
+function mergeDatabaseDeliveryConfig(base, override) {
+  return {
+    ...DEFAULT_DATABASE_DELIVERY_CONFIG,
+    ...base,
+    ...override,
+    retry: mergeDatabaseRetryConfig(base?.retry, override?.retry)
+  };
+}
+function hasPrismaDelegate(adapter) {
+  const model = adapter.model ?? "blypLog";
+  const client = adapter.client;
+  const delegate = client?.[model];
+  return !!delegate && typeof delegate.create === "function";
+}
+function hasDrizzleAdapterShape(adapter) {
+  const db = adapter.db;
+  return !!db && typeof db.insert === "function" && adapter.table !== void 0;
+}
+function resolveDatabaseLoggerConfig(config, sourceType) {
+  if (!config) {
+    return void 0;
+  }
+  const adapter = config.adapter;
+  let ready = false;
+  if (sourceType === "json") {
+    warnOnce(
+      "database-json-config",
+      "[Blyp] Warning: Database logging requires an executable blyp config file. Database destination remains disabled until you move this config to blyp.config.ts/js."
+    );
+  } else if (config.dialect !== "postgres" && config.dialect !== "mysql") {
+    warnOnce(
+      `database-dialect:${String(config.dialect)}`,
+      `[Blyp] Warning: Unsupported database dialect "${String(config.dialect)}". Database logging is disabled.`
+    );
+  } else if (!adapter) {
+    warnOnce(
+      "database-adapter-missing",
+      "[Blyp] Warning: Database logging is enabled without an adapter. Database logging is disabled."
+    );
+  } else if (isPrismaAdapter(adapter)) {
+    ready = hasPrismaDelegate({
+      ...adapter,
+      model: adapter.model ?? "blypLog"
+    });
+    if (!ready) {
+      warnOnce(
+        "database-prisma-missing",
+        `[Blyp] Warning: Prisma database adapter is missing the "${adapter.model ?? "blypLog"}" delegate or its create method. Database logging is disabled.`
+      );
+    }
+  } else if (isDrizzleAdapter(adapter)) {
+    ready = hasDrizzleAdapterShape(adapter);
+    if (!ready) {
+      warnOnce(
+        "database-drizzle-missing",
+        "[Blyp] Warning: Drizzle database adapter is missing a db.insert function or table reference. Database logging is disabled."
+      );
+    }
+  }
+  const normalizedAdapter = isPrismaAdapter(adapter) ? {
+    ...adapter,
+    model: adapter.model ?? "blypLog"
+  } : adapter;
+  return {
+    dialect: config.dialect,
+    adapter: normalizedAdapter,
+    delivery: mergeDatabaseDeliveryConfig(void 0, config.delivery),
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeRotationConfig(base, override) {
+  return {
+    ...DEFAULT_ROTATION_CONFIG,
+    ...base,
+    ...override
+  };
+}
+function mergeFileConfig(base, override) {
+  return {
+    ...DEFAULT_FILE_CONFIG,
+    ...base,
+    ...override,
+    rotation: mergeRotationConfig(base?.rotation, override?.rotation)
+  };
+}
+function mergeClientLoggingConfig(base, override) {
+  return {
+    ...DEFAULT_CLIENT_LOGGING_CONFIG,
+    ...base,
+    ...override,
+    path: override?.path ?? base?.path ?? DEFAULT_CLIENT_LOGGING_CONFIG.path
+  };
+}
+function mergeDatabaseLoggerConfig(base, override, sourceType) {
+  if (!base && !override) {
+    return void 0;
+  }
+  return resolveDatabaseLoggerConfig(
+    {
+      dialect: override?.dialect ?? base?.dialect,
+      adapter: override?.adapter ?? base?.adapter,
+      delivery: {
+        ...base?.delivery ?? {},
+        ...override?.delivery ?? {},
+        retry: {
+          ...base?.delivery?.retry ?? {},
+          ...override?.delivery?.retry ?? {}
+        }
+      }
+    },
+    sourceType
+  );
+}
+function mergePostHogConnectorConfig(base, override) {
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const projectKey = override?.projectKey ?? base?.projectKey;
+  const baseErrorTracking = base?.enabled === true ? base?.errorTracking : void 0;
+  const errorTrackingMode = override?.errorTracking?.mode ?? baseErrorTracking?.mode ?? "auto";
+  const errorTrackingEnabled = override?.errorTracking?.enabled ?? baseErrorTracking?.enabled ?? enabled;
+  const errorTrackingReady = enabled && errorTrackingEnabled && typeof projectKey === "string" && projectKey.trim().length > 0;
+  return {
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    projectKey,
+    host: override?.host ?? base?.host ?? DEFAULT_POSTHOG_HOST,
+    serviceName: override?.serviceName ?? base?.serviceName ?? resolveDefaultConnectorServiceName(),
+    errorTracking: {
+      enabled: errorTrackingEnabled,
+      mode: errorTrackingMode,
+      enableExceptionAutocapture: override?.errorTracking?.enableExceptionAutocapture ?? baseErrorTracking?.enableExceptionAutocapture ?? errorTrackingMode === "auto",
+      ready: errorTrackingReady,
+      status: errorTrackingReady ? "enabled" : "missing"
+    }
+  };
+}
+function mergeBetterStackConnectorConfig(base, override) {
+  const sourceToken = override?.sourceToken ?? base?.sourceToken;
+  const ingestingHost = override?.ingestingHost ?? base?.ingestingHost;
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const baseErrorTracking = base?.enabled === true ? base?.errorTracking : void 0;
+  const errorTracking = mergeBetterStackErrorTrackingConfig(
+    enabled,
+    baseErrorTracking,
+    override?.errorTracking
+  );
+  const ready = enabled && hasNonEmptyString(sourceToken) && isAbsoluteHttpUrl(ingestingHost);
+  return {
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    sourceToken,
+    ingestingHost,
+    serviceName: override?.serviceName ?? base?.serviceName ?? resolveDefaultConnectorServiceName(),
+    errorTracking,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeBetterStackErrorTrackingConfig(connectorEnabled, base, override) {
+  const dsn = override?.dsn ?? base?.dsn;
+  const enabled = override?.enabled ?? base?.enabled ?? connectorEnabled;
+  const ready = enabled && hasNonEmptyString(dsn);
+  return {
+    enabled,
+    dsn,
+    tracesSampleRate: override?.tracesSampleRate ?? base?.tracesSampleRate ?? 1,
+    environment: override?.environment ?? base?.environment,
+    release: override?.release ?? base?.release,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeSentryConnectorConfig(base, override) {
+  const dsn = override?.dsn ?? base?.dsn;
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const ready = enabled && typeof dsn === "string" && dsn.trim().length > 0;
+  return {
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    dsn,
+    environment: override?.environment ?? base?.environment,
+    release: override?.release ?? base?.release,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeOTLPConnectorConfig(base, override) {
+  const endpoint = override?.endpoint ?? base?.endpoint;
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const resolvedHeaders = {
+    ...{},
+    ...override?.headers ?? {}
+  };
+  const ready = enabled && isAbsoluteHttpUrl(endpoint);
+  return {
+    name: override?.name ?? base?.name ?? "",
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    endpoint,
+    headers: resolvedHeaders,
+    auth: override?.auth ?? base?.auth,
+    serviceName: override?.serviceName ?? base?.serviceName ?? resolveDefaultConnectorServiceName(),
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeOTLPConnectorsConfig(base, override) {
+  const source = override ?? base ?? [];
+  const deduped = /* @__PURE__ */ new Map();
+  for (const connector of source) {
+    if (!connector || typeof connector.name !== "string" || connector.name.length === 0) {
+      continue;
+    }
+    if (deduped.has(connector.name)) {
+      warnOnce(
+        `otlp-duplicate:${connector.name}`,
+        `[Blyp] Warning: Duplicate OTLP connector name "${connector.name}" found. Using the last definition.`
+      );
+    }
+    deduped.set(connector.name, mergeOTLPConnectorConfig(void 0, connector));
+  }
+  return Array.from(deduped.values());
+}
+function mergeConnectorsConfig(base, override) {
+  return {
+    betterstack: mergeBetterStackConnectorConfig(base?.betterstack, override?.betterstack),
+    posthog: mergePostHogConnectorConfig(base?.posthog, override?.posthog),
+    sentry: mergeSentryConnectorConfig(base?.sentry, override?.sentry),
+    otlp: mergeOTLPConnectorsConfig(base?.otlp, override?.otlp)
+  };
+}
+function mergeBlypConfig(base, override = {}, options = {}) {
+  return {
+    ...base,
+    ...override,
+    destination: override.destination ?? base.destination ?? "file",
+    file: mergeFileConfig(base.file, override.file),
+    database: mergeDatabaseLoggerConfig(base.database, override.database, options.configFileType),
+    clientLogging: mergeClientLoggingConfig(base.clientLogging, override.clientLogging),
+    connectors: mergeConnectorsConfig(base.connectors, override.connectors)
+  };
+}
+function loadConfig() {
+  if (cachedConfig !== null) {
+    return cachedConfig;
+  }
+  bootstrapProjectFiles();
+  const configFile = findConfigFile();
+  if (configFile) {
+    const userConfig = parseConfigFile(configFile);
+    cachedConfig = mergeBlypConfig(DEFAULT_CONFIG, userConfig, {
+      configFileType: configFile.type
+    });
+  } else {
+    cachedConfig = mergeBlypConfig(DEFAULT_CONFIG);
+  }
+  return cachedConfig;
+}
+function resolveConfig(overrides = {}) {
+  return mergeBlypConfig(loadConfig(), overrides);
+}
+
+// src/core/helpers.ts
+function normalizePath(path3) {
+  const queryIndex = path3.indexOf("?");
+  let withoutQuery = queryIndex >= 0 ? path3.substring(0, queryIndex) : path3;
+  if (withoutQuery.endsWith("/") && withoutQuery.length > 1) {
+    withoutQuery = withoutQuery.slice(0, -1);
+  }
+  if (!withoutQuery.startsWith("/")) {
+    withoutQuery = "/" + withoutQuery;
+  }
+  return withoutQuery;
+}
+function normalizePattern(pattern) {
+  const queryIndex = pattern.indexOf("?");
+  let withoutQuery = queryIndex >= 0 ? pattern.substring(0, queryIndex) : pattern;
+  if (withoutQuery.endsWith("/") && withoutQuery.length > 1) {
+    withoutQuery = withoutQuery.slice(0, -1);
+  }
+  if (!withoutQuery.startsWith("/")) {
+    withoutQuery = "/" + withoutQuery;
+  }
+  return withoutQuery;
+}
+function shouldIgnorePath(path3, ignorePaths) {
+  if (!ignorePaths || ignorePaths.length === 0) {
+    return false;
+  }
+  const normalizedPath = normalizePath(path3);
+  return ignorePaths.some((ignoredPattern) => {
+    const normalizedPattern = normalizePattern(ignoredPattern);
+    if (normalizedPattern === normalizedPath) {
+      return true;
+    }
+    if (normalizedPattern === "/**" || normalizedPattern === "**") {
+      return true;
+    }
+    if (normalizedPattern === "/*") {
+      const segments = normalizedPath.split("/").filter((s) => s.length > 0);
+      return segments.length === 1;
+    }
+    if (normalizedPattern.endsWith("/*") && !normalizedPattern.includes("**")) {
+      const prefix = normalizedPattern.slice(0, -1);
+      if (normalizedPath.startsWith(prefix)) {
+        const rest = normalizedPath.slice(prefix.length);
+        const restSegments = rest.split("/").filter((s) => s.length > 0);
+        return restSegments.length === 1;
+      }
+      return false;
+    }
+    if (normalizedPattern.includes("**")) {
+      if (normalizedPattern === "/**") {
+        return true;
+      }
+      if (normalizedPattern.startsWith("/") && normalizedPattern.endsWith("**")) {
+        let prefix2 = normalizedPattern.slice(0, -2);
+        if (prefix2.endsWith("/") && prefix2.length > 1) {
+          prefix2 = prefix2.slice(0, -1);
+        }
+        if (prefix2 === normalizedPath) {
+          return true;
+        }
+        return normalizedPath.startsWith(prefix2 + "/");
+      }
+      const starIndex = normalizedPattern.indexOf("**");
+      let prefix = normalizedPattern.substring(0, starIndex);
+      const suffix = normalizedPattern.substring(starIndex + 2);
+      if (prefix.endsWith("/") && prefix.length > 1) {
+        prefix = prefix.slice(0, -1);
+      }
+      if (prefix === "" && suffix === "") {
+        return true;
+      }
+      if (prefix !== "" && suffix === "") {
+        return normalizedPath.startsWith(prefix + "/");
+      }
+      if (prefix === "" && suffix !== "") {
+        return normalizedPath.endsWith(suffix) || normalizedPath.includes(suffix + "/");
+      }
+      if (prefix !== "" && suffix !== "") {
+        return normalizedPath.startsWith(prefix) && (normalizedPath.endsWith(suffix) || normalizedPath.includes(suffix + "/"));
+      }
+      return false;
+    }
+    if (normalizedPattern.includes("*")) {
+      const lastDotIndex = normalizedPattern.lastIndexOf(".");
+      const lastStarIndex = normalizedPattern.lastIndexOf("*");
+      if (lastDotIndex > lastStarIndex && lastStarIndex > 0) {
+        const charBeforeStar = normalizedPattern[lastStarIndex - 1];
+        if (charBeforeStar === "/") {
+          const extPattern = normalizedPattern.slice(lastStarIndex);
+          const filePart = normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1);
+          const extIndex = filePart.lastIndexOf(".");
+          if (extIndex > 0) {
+            const actualExt = filePart.slice(extIndex);
+            return actualExt === extPattern;
+          }
+        }
+      }
+      const regexPattern = normalizedPattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
+      const regex = new RegExp("^" + regexPattern + "$");
+      return regex.test(normalizedPath);
+    }
+    return false;
+  });
+}
+function gzipBuffer(buf) {
+  return Buffer.from(gzipSync(buf));
+}
+function warnWithConsole(message, error) {
+  console.warn(`[Blyp] Warning: ${message}`, error);
+}
+function ensureDirectory(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+function getFileSize(filePath) {
+  try {
+    return fs.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function formatArchiveTimestamp(timestamp) {
+  const year = timestamp.getUTCFullYear();
+  const month = String(timestamp.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(timestamp.getUTCDate()).padStart(2, "0");
+  const hours = String(timestamp.getUTCHours()).padStart(2, "0");
+  const minutes = String(timestamp.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(timestamp.getUTCSeconds()).padStart(2, "0");
+  return `${year}${month}${day}T${hours}${minutes}${seconds}Z`;
+}
+function getUniqueArchivePath(basePath, extension) {
+  let candidate = `${basePath}${extension}`;
+  let suffix = 1;
+  while (fs.existsSync(candidate)) {
+    candidate = `${basePath}-${suffix}${extension}`;
+    suffix += 1;
+  }
+  return candidate;
+}
+function pruneArchives(archiveDir, archivePrefix, maxArchives, warn) {
+  const prefix = `${archivePrefix}.`;
+  try {
+    const archivePaths = fs.readdirSync(archiveDir).filter(
+      (name) => name.startsWith(prefix) && (name.endsWith(".ndjson") || name.endsWith(".ndjson.gz"))
+    ).map((name) => path.join(archiveDir, name)).sort((left, right) => {
+      return fs.statSync(left).mtimeMs - fs.statSync(right).mtimeMs;
+    });
+    const deleteCount = Math.max(archivePaths.length - maxArchives, 0);
+    for (let index = 0; index < deleteCount; index += 1) {
+      fs.rmSync(archivePaths[index]);
+    }
+  } catch (error) {
+    warn(`Failed to prune archives for ${archivePrefix}`, error);
+  }
+}
+function createSafeReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "function") {
+      return `[Function: ${value.name || "anonymous"}]`;
+    }
+    if (value === void 0) {
+      return "[undefined]";
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (value !== null && typeof value === "object") {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+}
+function serializeLogRecord(record) {
+  return JSON.stringify(record, createSafeReplacer());
+}
+function resolveFileLoggerConfig(config) {
+  const fileConfig = config.file;
+  const dir = fileConfig?.dir || config.logDir || path.join(process.cwd(), "logs");
+  const archiveDir = fileConfig?.archiveDir || path.join(dir, "archive");
+  const rotation = fileConfig?.rotation;
+  return {
+    enabled: fileConfig?.enabled ?? true,
+    dir,
+    archiveDir,
+    rotationEnabled: rotation?.enabled ?? true,
+    maxSizeBytes: rotation?.maxSizeBytes ?? 10 * 1024 * 1024,
+    maxArchives: rotation?.maxArchives ?? 5,
+    compress: rotation?.compress ?? true
+  };
+}
+var RotatingFileLogger = class {
+  constructor(config, dependencies = {}) {
+    __publicField(this, "config");
+    __publicField(this, "gzip");
+    __publicField(this, "warn");
+    __publicField(this, "combined");
+    __publicField(this, "error");
+    this.config = resolveFileLoggerConfig(config);
+    this.gzip = dependencies.gzip ?? gzipBuffer;
+    this.warn = dependencies.warn ?? warnWithConsole;
+    this.combined = {
+      activePath: path.join(this.config.dir, "log.ndjson"),
+      archivePrefix: "log",
+      bytes: 0,
+      queue: [],
+      processing: false
+    };
+    this.error = {
+      activePath: path.join(this.config.dir, "log.error.ndjson"),
+      archivePrefix: "log.error",
+      bytes: 0,
+      queue: [],
+      processing: false
+    };
+    if (!this.config.enabled) {
+      return;
+    }
+    ensureDirectory(this.config.dir);
+    ensureDirectory(this.config.archiveDir);
+    this.seedStream(this.combined);
+    this.seedStream(this.error);
+  }
+  write(record) {
+    if (!this.config.enabled) {
+      return;
+    }
+    const line = `${serializeLogRecord(record)}
+`;
+    this.enqueue(this.combined, line);
+    if (record.level === "error" || record.level === "critical") {
+      this.enqueue(this.error, line);
+    }
+  }
+  enqueue(stream, line) {
+    stream.queue.push(line);
+    this.processQueue(stream);
+  }
+  processQueue(stream) {
+    if (stream.processing) {
+      return;
+    }
+    stream.processing = true;
+    try {
+      while (stream.queue.length > 0) {
+        const queuedLine = stream.queue.shift();
+        if (queuedLine === void 0) {
+          continue;
+        }
+        try {
+          this.append(stream, queuedLine);
+        } catch (error) {
+          this.warn(`Failed writing log line for ${stream.archivePrefix}`, error);
+        }
+      }
+    } finally {
+      stream.processing = false;
+    }
+  }
+  seedStream(stream) {
+    stream.bytes = getFileSize(stream.activePath);
+    if (this.config.rotationEnabled && stream.bytes > this.config.maxSizeBytes && stream.bytes > 0) {
+      this.rotate(stream);
+      fs.closeSync(fs.openSync(stream.activePath, "a"));
+      stream.bytes = 0;
+    }
+  }
+  append(stream, line) {
+    ensureDirectory(this.config.dir);
+    const lineBytes = Buffer.byteLength(line, "utf8");
+    if (this.config.rotationEnabled && stream.bytes > 0 && stream.bytes + lineBytes > this.config.maxSizeBytes) {
+      this.rotate(stream);
+    }
+    fs.appendFileSync(stream.activePath, line, "utf8");
+    stream.bytes += lineBytes;
+  }
+  rotate(stream) {
+    ensureDirectory(this.config.archiveDir);
+    if (!fs.existsSync(stream.activePath) || stream.bytes === 0) {
+      stream.bytes = 0;
+      return;
+    }
+    const archiveTimestamp = formatArchiveTimestamp(/* @__PURE__ */ new Date());
+    const archiveBasePath = path.join(
+      this.config.archiveDir,
+      `${stream.archivePrefix}.${archiveTimestamp}`
+    );
+    const archivePath = getUniqueArchivePath(archiveBasePath, ".ndjson");
+    fs.renameSync(stream.activePath, archivePath);
+    if (this.config.compress) {
+      try {
+        const compressedPath = `${archivePath}.gz`;
+        const gzipped = this.gzip(fs.readFileSync(archivePath));
+        fs.writeFileSync(compressedPath, gzipped);
+        fs.rmSync(archivePath);
+      } catch (error) {
+        this.warn(`Failed to gzip archive ${archivePath}`, error);
+      }
+    }
+    stream.bytes = 0;
+    pruneArchives(this.config.archiveDir, stream.archivePrefix, this.config.maxArchives, this.warn);
+  }
+};
+function createFileLogger(config) {
+  return new RotatingFileLogger(config);
+}
+
+// src/connectors/shared.ts
+function isBlypConfig(config) {
+  return isPlainObject(config) && ("connectors" in config || "pretty" in config || "level" in config);
+}
+function getPrimaryPayload(record) {
+  return isPlainObject(record.data) ? record.data : record;
+}
+function getField(record, key) {
+  if (key in record) {
+    const direct = record[key];
+    if (typeof direct === "string" || typeof direct === "number") {
+      return direct;
+    }
+  }
+  const payload = getPrimaryPayload(record);
+  const nested = payload[key];
+  if (typeof nested === "string" || typeof nested === "number") {
+    return nested;
+  }
+  return void 0;
+}
+function getClientPageField(record, key) {
+  const payload = getPrimaryPayload(record);
+  const page = isPlainObject(payload.page) ? payload.page : void 0;
+  const value = page?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getClientSessionField(record, key) {
+  const payload = getPrimaryPayload(record);
+  const session = isPlainObject(payload.session) ? payload.session : void 0;
+  const value = session?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getRecordType(record) {
+  return getField(record, "type");
+}
+
+// src/connectors/posthog/sender.ts
+var PREVIOUSLY_CAPTURED_ERROR_KEY = "__posthog_previously_captured_error";
+var warnedKeys2 = /* @__PURE__ */ new Set();
+var testHooks = {};
+var warnOnce2 = createErrorOnceLogger(warnedKeys2);
+function normalizeHost(host) {
+  const trimmed = (host || "https://us.i.posthog.com").trim();
+  return trimmed.replace(/\/+$/, "");
+}
+function buildRecordAttributes(record, source) {
+  const recordType = getRecordType(record);
+  const caller = typeof record.caller === "string" ? record.caller : void 0;
+  const groupId = getField(record, "groupId");
+  const method = getField(record, "method");
+  const path3 = getField(record, "path");
+  const status = getField(record, "status");
+  const duration = getField(record, "duration");
+  const pagePath = getClientPageField(record, "pathname");
+  const pageUrl = getClientPageField(record, "url");
+  const sessionId = getClientSessionField(record, "sessionId");
+  const pageId = getClientSessionField(record, "pageId");
+  const attributes = {
+    "blyp.level": record.level,
+    "blyp.source": source,
+    "blyp.payload": serializeLogRecord(record)
+  };
+  const ifTruthy = [
+    ["blyp.type", recordType],
+    ["blyp.caller", caller],
+    ["blyp.group_id", groupId],
+    ["http.method", method],
+    ["url.path", path3],
+    ["client.page_path", pagePath],
+    ["client.page_url", pageUrl],
+    ["client.session_id", sessionId],
+    ["client.page_id", pageId]
+  ];
+  const ifDefined = [
+    ["http.status_code", status],
+    ["blyp.duration_ms", duration]
+  ];
+  for (const [k, v] of ifTruthy) if (v) attributes[k] = v;
+  for (const [k, v] of ifDefined) if (v !== void 0) attributes[k] = v;
+  return attributes;
+}
+function normalizeExceptionProperties(value) {
+  if (!isPlainObject(value)) {
+    return {};
+  }
+  return normalizeLogValue(value);
+}
+function assignExceptionField(target, key, value) {
+  if (value === void 0) {
+    return;
+  }
+  try {
+    target[key] = value;
+  } catch {
+  }
+}
+function createSyntheticError(message, source) {
+  const error = new Error(message);
+  const name = hasNonEmptyString(source.name) ? source.name : "Error";
+  error.name = name;
+  if (hasNonEmptyString(source.stack)) {
+    error.stack = source.stack;
+  }
+  assignExceptionField(error, "cause", source.cause);
+  assignExceptionField(error, "status", source.status);
+  assignExceptionField(error, "statusCode", source.statusCode);
+  assignExceptionField(error, "code", source.code);
+  assignExceptionField(error, "why", source.why);
+  assignExceptionField(error, "fix", source.fix);
+  assignExceptionField(error, "link", source.link);
+  assignExceptionField(error, "details", source.details);
+  return error;
+}
+function normalizeExceptionInput(input, fallbackMessage = "Unknown error") {
+  if (input instanceof Error) {
+    return {
+      error: input,
+      properties: normalizeExceptionProperties(input)
+    };
+  }
+  if (isPlainObject(input)) {
+    const message = hasNonEmptyString(input.message) ? input.message : hasNonEmptyString(input.error) ? input.error : fallbackMessage;
+    return {
+      error: createSyntheticError(message, input),
+      properties: normalizeExceptionProperties(input)
+    };
+  }
+  if (typeof input === "string") {
+    return {
+      error: new Error(input),
+      properties: {
+        message: input
+      }
+    };
+  }
+  return {
+    error: new Error(fallbackMessage),
+    properties: {
+      value: normalizeLogValue(input)
+    }
+  };
+}
+function createExceptionPropertiesFromRecord(record, source) {
+  return buildRecordAttributes(record, source);
+}
+function isPreviouslyCapturedPostHogError(value) {
+  return isPlainObject(value) && value[PREVIOUSLY_CAPTURED_ERROR_KEY] === true;
+}
+function markPostHogCapturedError(value) {
+  if (!isPlainObject(value) || isPreviouslyCapturedPostHogError(value)) {
+    return;
+  }
+  try {
+    Object.defineProperty(value, PREVIOUSLY_CAPTURED_ERROR_KEY, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+  } catch {
+    try {
+      value[PREVIOUSLY_CAPTURED_ERROR_KEY] = true;
+    } catch {
+    }
+  }
+}
+function isClientLogRecord(record) {
+  return getRecordType(record) === "client_log";
+}
+function normalizePostHogRecord(record, connector, source = "server") {
+  const severity = resolveSeverity(record.level);
+  const body = typeof record.message === "string" ? record.message : String(record.message);
+  return {
+    body,
+    severityText: severity.text,
+    severityNumber: severity.number,
+    attributes: buildRecordAttributes(record, source),
+    resourceAttributes: {
+      "service.name": connector.serviceName
+    }
+  };
+}
+function resolveSeverity(level) {
+  switch (level) {
+    case "debug":
+      return { text: "debug", number: SeverityNumber.DEBUG };
+    case "warning":
+    case "warn":
+      return { text: "warn", number: SeverityNumber.WARN };
+    case "error":
+      return { text: "error", number: SeverityNumber.ERROR };
+    case "critical":
+      return { text: "fatal", number: SeverityNumber.FATAL };
+    case "success":
+    case "table":
+    case "info":
+    default:
+      return { text: "info", number: SeverityNumber.INFO };
+  }
+}
+function registerShutdownHooks(key, shutdown) {
+  const handlers = ["beforeExit", "SIGINT", "SIGTERM"];
+  for (const event of handlers) {
+    process.once(event, () => {
+      void shutdown().catch((error) => {
+        warnOnce2(
+          `${key}:shutdown`,
+          "[Blyp] Failed to flush PostHog telemetry during shutdown.",
+          error
+        );
+      });
+    });
+  }
+}
+function createDefaultTransport(connector) {
+  const exporter = new OTLPLogExporter({
+    url: `${normalizeHost(connector.host)}/i/v1/logs`,
+    headers: {
+      Authorization: `Bearer ${connector.projectKey}`
+    }
+  });
+  const provider = new LoggerProvider({
+    resource: resourceFromAttributes({
+      "service.name": connector.serviceName
+    }),
+    processors: [new BatchLogRecordProcessor(exporter)]
+  });
+  const logger3 = provider.getLogger("blyp-posthog");
+  return {
+    emit(payload) {
+      logger3.emit({
+        body: payload.body,
+        severityText: payload.severityText,
+        severityNumber: payload.severityNumber,
+        attributes: payload.attributes
+      });
+    },
+    flush() {
+      return provider.forceFlush();
+    },
+    shutdown() {
+      return provider.shutdown();
+    }
+  };
+}
+function createDefaultExceptionClient(connector) {
+  const client = new PostHog(connector.projectKey ?? "", {
+    host: connector.host,
+    enableExceptionAutocapture: connector.errorTracking.enableExceptionAutocapture
+  });
+  return {
+    captureException(error, distinctId, additionalProperties) {
+      return client.captureExceptionImmediate(error, distinctId, additionalProperties);
+    },
+    shutdown() {
+      return client._shutdown();
+    }
+  };
+}
+function resolveConnectorConfig(config) {
+  const connector = isBlypConfig(config) ? config.connectors?.posthog : config;
+  const enabled = connector?.enabled ?? false;
+  const projectKey = connector?.projectKey;
+  const errorTrackingEnabled = connector?.errorTracking?.enabled ?? enabled;
+  const errorTrackingMode = connector?.errorTracking?.mode ?? "auto";
+  const errorTrackingReady = enabled && errorTrackingEnabled && hasNonEmptyString(projectKey);
+  return {
+    enabled,
+    mode: connector?.mode ?? "auto",
+    projectKey,
+    host: normalizeHost(connector?.host),
+    serviceName: connector?.serviceName ?? "blyp-app",
+    errorTracking: {
+      enabled: errorTrackingEnabled,
+      mode: errorTrackingMode,
+      enableExceptionAutocapture: connector?.errorTracking?.enableExceptionAutocapture ?? errorTrackingMode === "auto",
+      ready: errorTrackingReady,
+      status: errorTrackingReady ? "enabled" : "missing"
+    }
+  };
+}
+function createPostHogSender(config) {
+  const connector = resolveConnectorConfig(config);
+  const key = `${connector.serviceName}:${connector.host}:${connector.mode}`;
+  const ready = connector.enabled === true && hasNonEmptyString(connector.projectKey);
+  const transport = ready ? testHooks.createTransport?.(connector) ?? createDefaultTransport(connector) : void 0;
+  const exceptionClient = connector.errorTracking.ready ? testHooks.createExceptionClient?.(connector) ?? createDefaultExceptionClient(connector) : void 0;
+  const shutdown = async () => {
+    if (transport?.shutdown) {
+      await transport.shutdown();
+    } else if (transport?.flush) {
+      await transport.flush();
+    }
+    if (exceptionClient?.shutdown) {
+      await exceptionClient.shutdown();
+    }
+  };
+  if (transport || exceptionClient) {
+    registerShutdownHooks(key, shutdown);
+  }
+  const emitUnavailableWarning = () => {
+    warnOnce2(
+      `posthog-unavailable:${key}`,
+      "[Blyp] PostHog connector is not configured. Skipping PostHog delivery."
+    );
+  };
+  const emitExceptionUnavailableWarning = () => {
+    warnOnce2(
+      `posthog-exception-unavailable:${key}`,
+      "[Blyp] PostHog error tracking is not configured. Skipping PostHog exception capture."
+    );
+  };
+  return {
+    enabled: connector.enabled,
+    ready,
+    mode: connector.mode,
+    serviceName: connector.serviceName,
+    host: connector.host,
+    status: ready ? "enabled" : "missing",
+    errorTracking: {
+      enabled: connector.errorTracking.enabled,
+      ready: connector.errorTracking.ready,
+      mode: connector.errorTracking.mode,
+      status: connector.errorTracking.status,
+      enableExceptionAutocapture: connector.errorTracking.enableExceptionAutocapture
+    },
+    shouldAutoForwardServerLogs() {
+      return ready && connector.mode === "auto";
+    },
+    shouldAutoCaptureExceptions() {
+      return connector.errorTracking.ready && connector.errorTracking.mode === "auto";
+    },
+    send(record, options = {}) {
+      const source = options.source ?? "server";
+      if (!ready || !transport) {
+        if (options.warnIfUnavailable) {
+          emitUnavailableWarning();
+        }
+        return;
+      }
+      const normalized = normalizePostHogRecord(record, connector, source);
+      try {
+        const result = transport.emit(normalized);
+        if (result && typeof result.catch === "function") {
+          void result.catch((error) => {
+            warnOnce2(
+              `posthog-emit:${key}`,
+              "[Blyp] Failed to deliver log to PostHog.",
+              error
+            );
+          });
+        }
+      } catch (error) {
+        warnOnce2(
+          `posthog-emit:${key}`,
+          "[Blyp] Failed to deliver log to PostHog.",
+          error
+        );
+      }
+    },
+    captureException(error, options = {}) {
+      if (!connector.errorTracking.ready || !exceptionClient) {
+        if (options.warnIfUnavailable) {
+          emitExceptionUnavailableWarning();
+        }
+        return;
+      }
+      if (isPreviouslyCapturedPostHogError(error)) {
+        return;
+      }
+      const normalized = normalizeExceptionInput(
+        error,
+        options.source === "client" ? "Client error" : "Server error"
+      );
+      const properties = {
+        ...normalized.properties,
+        ...options.properties ?? {},
+        "blyp.source": options.source ?? "server"
+      };
+      try {
+        const result = exceptionClient.captureException(
+          normalized.error,
+          options.distinctId,
+          properties
+        );
+        markPostHogCapturedError(error);
+        markPostHogCapturedError(normalized.error);
+        if (result && typeof result.catch === "function") {
+          void result.catch((captureError) => {
+            warnOnce2(
+              `posthog-capture:${key}`,
+              "[Blyp] Failed to capture exception in PostHog.",
+              captureError
+            );
+          });
+        }
+      } catch (captureError) {
+        warnOnce2(
+          `posthog-capture:${key}`,
+          "[Blyp] Failed to capture exception in PostHog.",
+          captureError
+        );
+      }
+    },
+    async flush() {
+      try {
+        if (transport?.flush) {
+          await transport.flush();
+        }
+      } catch (error) {
+        warnOnce2(
+          `posthog-flush:${key}`,
+          "[Blyp] Failed to flush PostHog telemetry.",
+          error
+        );
+      }
+    }
+  };
+}
+function buildPostHogExceptionProperties(record, source, properties = {}) {
+  return {
+    ...createExceptionPropertiesFromRecord(record, source),
+    ...properties
+  };
+}
+var requestContextStorage = new AsyncLocalStorage();
+function createStore() {
+  return {
+    requestScopedLoggerActive: true,
+    structuredCollectorActive: false,
+    structuredLogEmitted: false,
+    mixedLoggerWarningShown: false
+  };
+}
+function enterRequestContext() {
+  const store = createStore();
+  requestContextStorage.enterWith(store);
+  return store;
+}
+function getRequestContextStore() {
+  return requestContextStorage.getStore();
+}
+function setActiveRequestLogger(logger3) {
+  const store = getRequestContextStore();
+  if (store) {
+    store.activeLogger = logger3;
+  }
+}
+function markStructuredCollectorActive() {
+  const store = getRequestContextStore();
+  if (store) {
+    store.structuredCollectorActive = true;
+  }
+}
+function markStructuredLogEmitted() {
+  const store = getRequestContextStore();
+  if (store) {
+    store.structuredLogEmitted = true;
+  }
+}
+function shouldDropRootLogWrite() {
+  const store = getRequestContextStore();
+  if (!store || !store.requestScopedLoggerActive || !store.structuredCollectorActive) {
+    return false;
+  }
+  if (!store.mixedLoggerWarningShown) {
+    store.mixedLoggerWarningShown = true;
+    console.warn(
+      "[Blyp] Warning: Mixed logger usage detected for this request. The root logger call was ignored because a request-scoped structured logger is active."
+    );
+  }
+  return true;
+}
+
+// src/core/log-record.ts
+var RECORD_LEVELS = {
+  success: "success",
+  critical: "critical",
+  warning: "warning",
+  info: "info",
+  debug: "debug",
+  error: "error",
+  warn: "warning",
+  table: "table"
+};
+function normalizePath2(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function isInternalLoggerFrame(filePath) {
+  const normalizedPath = normalizePath2(filePath);
+  return normalizedPath.startsWith("node:") || normalizedPath.includes("/node_modules/pino") || normalizedPath.includes("/node_modules/pino-pretty") || normalizedPath.includes("/node_modules/@blyp/core/") || normalizedPath.includes("/blyp/src/core/") || normalizedPath.includes("/blyp/src/frameworks/") || normalizedPath.includes("/blyp/src/posthog/") || normalizedPath.includes("/blyp/dist/");
+}
+function formatCallerPath(filePath) {
+  const normalizedPath = normalizePath2(filePath);
+  const normalizedCwd = normalizePath2(process.cwd());
+  return normalizedPath.startsWith(`${normalizedCwd}/`) ? normalizedPath.slice(normalizedCwd.length + 1) : normalizedPath;
+}
+function getCallerLocation() {
+  try {
+    const stack = new Error().stack;
+    if (!stack) {
+      return { file: null, line: null };
+    }
+    const lines = stack.split("\n");
+    let fallback = null;
+    for (let index = 2; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (!line) {
+        continue;
+      }
+      const match = line.match(/\((.*):(\d+):\d+\)/) || line.match(/at\s+(.*):(\d+):(\d+)/);
+      if (!match) {
+        continue;
+      }
+      const fileName = match[1] || "";
+      const lineNumber = parseInt(match[2] || "0", 10) || null;
+      if (fileName && !fileName.includes("node_modules") && !isInternalLoggerFrame(fileName)) {
+        const formattedPath = formatCallerPath(fileName);
+        const normalizedFormattedPath = normalizePath2(formattedPath);
+        if (!normalizedFormattedPath.startsWith("dist/")) {
+          return { file: formattedPath, line: lineNumber };
+        }
+        fallback ?? (fallback = { file: formattedPath, line: lineNumber });
+      }
+    }
+    if (fallback) {
+      return fallback;
+    }
+  } catch {
+    return { file: null, line: null };
+  }
+  return { file: null, line: null };
+}
+var serializeMessage = serializeLogMessage;
+function stripAnsi(value) {
+  return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function buildRecord(level, message, args, bindings) {
+  const { file, line } = getCallerLocation();
+  const serializedMessage = serializeMessage(message);
+  const record = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level: RECORD_LEVELS[level],
+    message: stripAnsi(serializedMessage)
+  };
+  if (message instanceof Error) {
+    record.error = normalizeError(message);
+  }
+  if (file) {
+    record.caller = line !== null ? `${file}:${line}` : file;
+  }
+  if (args.length === 1) {
+    record.data = normalizeLogValue(args[0]);
+  } else if (args.length > 1) {
+    record.data = normalizeLogValue(args);
+  }
+  if (Object.keys(bindings).length > 0) {
+    record.bindings = normalizeLogValue(bindings);
+  }
+  return record;
+}
+function buildStructuredRecord(level, message, payload, bindings) {
+  const { file, line } = getCallerLocation();
+  const normalizedPayload = normalizeLogValue(payload);
+  const record = {
+    message: stripAnsi(message),
+    ...normalizedPayload
+  };
+  if (file) {
+    record.caller = line !== null ? `${file}:${line}` : file;
+  }
+  if (Object.keys(bindings).length > 0) {
+    record.bindings = normalizeLogValue(bindings);
+  }
+  record.level = typeof normalizedPayload.level === "string" && normalizedPayload.level.length > 0 ? normalizedPayload.level : RECORD_LEVELS[level];
+  record.timestamp = typeof normalizedPayload.timestamp === "string" && normalizedPayload.timestamp.length > 0 ? normalizedPayload.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+  return record;
+}
+function resolveStructuredWriteLevel(level) {
+  switch (level) {
+    case "debug":
+      return "debug";
+    case "warning":
+      return "warning";
+    case "warn":
+      return "warn";
+    case "error":
+      return "error";
+    case "success":
+      return "success";
+    case "critical":
+      return "critical";
+    case "table":
+      return "table";
+    case "info":
+    default:
+      return "info";
+  }
+}
+
+// src/core/sinks/file-primary-sink.ts
+var FilePrimarySink = class {
+  constructor(logger3) {
+    this.logger = logger3;
+    __publicField(this, "isAsync", false);
+    __publicField(this, "isReady", true);
+  }
+  write(record) {
+    this.logger.write(record);
+  }
+  async flush() {
+  }
+  async shutdown() {
+  }
+};
+function createFilePrimarySink(config) {
+  return new FilePrimarySink(createFileLogger(config));
+}
+
+// src/database/adapters/drizzle.ts
+function createDrizzleRowWriter(adapter) {
+  const db = adapter.db;
+  if (typeof db?.insert !== "function" || adapter.table === void 0) {
+    throw new Error(
+      "[Blyp] Drizzle database adapter is missing a db.insert function or table reference."
+    );
+  }
+  return {
+    async insert(rows) {
+      if (rows.length === 0) {
+        return;
+      }
+      await db.insert(adapter.table).values(rows);
+    }
+  };
+}
+
+// src/database/adapters/prisma.ts
+function shouldFallbackFromCreateMany(error) {
+  const message = String(error ?? "");
+  return message.includes("createMany") || message.includes("Unknown argument") || message.includes("not supported") || message.includes("is not a function");
+}
+function createPrismaRowWriter(adapter) {
+  const client = adapter.client;
+  const model = adapter.model ?? "blypLog";
+  const delegateCandidate = client[model];
+  if (!delegateCandidate || typeof delegateCandidate.create !== "function") {
+    throw new Error(
+      `[Blyp] Prisma database adapter is missing the "${model}" delegate or its create method.`
+    );
+  }
+  const delegate = delegateCandidate;
+  let useCreateMany = typeof delegate.createMany === "function";
+  async function fallbackInsert(rows) {
+    if (typeof client.$transaction === "function") {
+      await client.$transaction(
+        rows.map((row) => delegate.create({ data: row }))
+      );
+      return;
+    }
+    for (const row of rows) {
+      await delegate.create({ data: row });
+    }
+  }
+  return {
+    async insert(rows) {
+      if (rows.length === 0) {
+        return;
+      }
+      if (rows.length === 1) {
+        await delegate.create({ data: rows[0] });
+        return;
+      }
+      if (!useCreateMany || typeof delegate.createMany !== "function") {
+        await fallbackInsert(rows);
+        return;
+      }
+      try {
+        await delegate.createMany({ data: rows });
+      } catch (error) {
+        if (!shouldFallbackFromCreateMany(error)) {
+          throw error;
+        }
+        useCreateMany = false;
+        await fallbackInsert(rows);
+      }
+    }
+  };
+}
+
+// src/database/helpers.ts
+function normalizeNullableNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizeNullableString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function parseTimestamp(value) {
+  if (typeof value === "string") {
+    const timestamp = new Date(value);
+    if (!Number.isNaN(timestamp.getTime())) {
+      return timestamp;
+    }
+  }
+  return /* @__PURE__ */ new Date();
+}
+function toDatabaseLogRow(record) {
+  const normalizedRecord = normalizeLogValue(record);
+  return {
+    id: randomUUID(),
+    timestamp: parseTimestamp(record.timestamp),
+    level: record.level,
+    message: record.message,
+    caller: normalizeNullableString(record.caller),
+    type: normalizeNullableString(record.type),
+    groupId: normalizeNullableString(record.groupId),
+    method: normalizeNullableString(record.method),
+    path: normalizeNullableString(record.path),
+    status: normalizeNullableNumber(record.status),
+    duration: normalizeNullableNumber(record.duration),
+    hasError: normalizedRecord.error != null,
+    data: normalizedRecord.data ?? null,
+    bindings: normalizedRecord.bindings ?? null,
+    error: normalizedRecord.error ?? null,
+    events: normalizedRecord.events ?? null,
+    record: normalizedRecord,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+function isPrismaAdapter2(adapter) {
+  return !!adapter && adapter.type === "prisma";
+}
+function isDrizzleAdapter2(adapter) {
+  return !!adapter && adapter.type === "drizzle";
+}
+function createDatabaseRowWriter(config) {
+  if (isPrismaAdapter2(config.adapter)) {
+    return createPrismaRowWriter(config.adapter);
+  }
+  if (isDrizzleAdapter2(config.adapter)) {
+    return createDrizzleRowWriter(config.adapter);
+  }
+  throw new Error("[Blyp] Unsupported database adapter configuration.");
+}
+
+// src/core/sinks/database-primary-sink.ts
+function delay(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+var DatabasePrimarySink = class {
+  constructor(config) {
+    this.config = config;
+    __publicField(this, "isAsync", true);
+    __publicField(this, "isReady", true);
+    __publicField(this, "warnOnce", createWarnOnceLogger(/* @__PURE__ */ new Set()));
+    __publicField(this, "queue", []);
+    __publicField(this, "writer");
+    __publicField(this, "timer", null);
+    __publicField(this, "processing", false);
+    __publicField(this, "closed", false);
+    __publicField(this, "terminalError", null);
+    __publicField(this, "activeDispatch", null);
+    this.writer = createDatabaseRowWriter(config);
+  }
+  write(record) {
+    if (this.closed) {
+      return;
+    }
+    this.enqueue(toDatabaseLogRow(record));
+    this.scheduleDispatch();
+  }
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const flushPromise = (async () => {
+      await this.drain();
+      if (this.terminalError) {
+        throw this.terminalError;
+      }
+    })();
+    let timeoutHandle = null;
+    try {
+      await Promise.race([
+        flushPromise,
+        new Promise((_, reject) => {
+          timeoutHandle = setTimeout(() => {
+            this.warnOnce(
+              "database-flush-timeout",
+              `[Blyp] Warning: Timed out flushing database logs after ${this.config.delivery.flushTimeoutMs}ms.`
+            );
+            reject(new Error("[Blyp] Timed out flushing database logs."));
+          }, this.config.delivery.flushTimeoutMs);
+        })
+      ]);
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+  }
+  async shutdown() {
+    this.closed = true;
+    await this.flush();
+  }
+  enqueue(row) {
+    this.queue.push(row);
+    const overflow = this.queue.length - this.config.delivery.maxQueueSize;
+    if (overflow <= 0) {
+      return;
+    }
+    this.warnOnce(
+      "database-overflow",
+      `[Blyp] Warning: Database log queue exceeded ${this.config.delivery.maxQueueSize} entries. Applying ${this.config.delivery.overflowStrategy} overflow handling.`
+    );
+    if (this.config.delivery.overflowStrategy === "drop-new") {
+      this.queue.splice(this.config.delivery.maxQueueSize);
+      return;
+    }
+    this.queue.splice(0, overflow);
+  }
+  scheduleDispatch() {
+    if (this.processing) {
+      return;
+    }
+    if (this.config.delivery.strategy === "immediate") {
+      void this.drain();
+      return;
+    }
+    if (this.queue.length >= this.config.delivery.batchSize) {
+      void this.drain();
+      return;
+    }
+    if (this.timer) {
+      return;
+    }
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.drain();
+    }, this.config.delivery.flushIntervalMs);
+  }
+  async drain() {
+    if (this.processing) {
+      if (this.activeDispatch) {
+        await this.activeDispatch;
+      }
+      return;
+    }
+    this.processing = true;
+    this.activeDispatch = this.processQueue();
+    try {
+      await this.activeDispatch;
+    } finally {
+      this.processing = false;
+      this.activeDispatch = null;
+    }
+  }
+  async processQueue() {
+    while (this.queue.length > 0) {
+      const batchSize = this.config.delivery.strategy === "batch" ? Math.max(1, this.config.delivery.batchSize) : 1;
+      const batch = this.queue.splice(0, batchSize);
+      try {
+        await this.insertWithRetry(batch);
+      } catch (error) {
+        const failure = error instanceof Error ? error : new Error(String(error ?? "Unknown database logging failure"));
+        this.terminalError = failure;
+        this.warnOnce(
+          "database-insert-failure",
+          `[Blyp] Warning: Failed to persist logs to the ${this.config.dialect ?? "database"} database.`,
+          failure
+        );
+        throw failure;
+      }
+    }
+  }
+  async insertWithRetry(batch) {
+    const maxAttempts = Math.max(1, this.config.delivery.retry.maxRetries + 1);
+    let attempt = 0;
+    while (attempt < maxAttempts) {
+      attempt += 1;
+      try {
+        await this.writer.insert(batch);
+        return;
+      } catch (error) {
+        if (attempt >= maxAttempts) {
+          throw error;
+        }
+        await delay(this.config.delivery.retry.backoffMs);
+      }
+    }
+  }
+};
+
+// src/core/primary-sink.ts
+var NoopPrimarySink = class {
+  constructor() {
+    __publicField(this, "isAsync", false);
+    __publicField(this, "isReady", false);
+  }
+  write(_record) {
+  }
+  async flush() {
+  }
+  async shutdown() {
+  }
+};
+var warnOnce3 = createWarnOnceLogger(/* @__PURE__ */ new Set());
+function createPrimarySink(config) {
+  if (config.destination !== "database") {
+    return createFilePrimarySink(config);
+  }
+  const databaseConfig = config.database;
+  if (!databaseConfig?.ready) {
+    warnOnce3(
+      "database-sink-disabled",
+      "[Blyp] Warning: Database destination is configured but not ready. Falling back to a no-op primary sink."
+    );
+    return new NoopPrimarySink();
+  }
+  return new DatabasePrimarySink(databaseConfig);
+}
+var PREVIOUSLY_CAPTURED_ERROR_KEY2 = "__betterstack_previously_captured_error";
+var warnedKeys3 = /* @__PURE__ */ new Set();
+var testHooks2 = {};
+var warnOnce4 = createErrorOnceLogger(warnedKeys3);
+function getSentryModule() {
+  return testHooks2.module ?? Sentry;
+}
+function resolveConnectorConfig2(config) {
+  const connector = isBlypConfig(config) ? config.connectors?.betterstack : config;
+  const enabled = connector?.enabled ?? false;
+  const sourceToken = connector?.sourceToken;
+  const ingestingHost = connector?.ingestingHost;
+  const errorTrackingEnabled = connector?.errorTracking?.enabled ?? enabled;
+  const errorTrackingDsn = connector?.errorTracking?.dsn;
+  const errorTrackingReady = enabled && errorTrackingEnabled && hasNonEmptyString(errorTrackingDsn);
+  const ready = enabled && hasNonEmptyString(sourceToken) && isAbsoluteHttpUrl(ingestingHost);
+  return {
+    enabled,
+    mode: connector?.mode ?? "auto",
+    sourceToken,
+    ingestingHost,
+    serviceName: connector?.serviceName ?? "blyp-app",
+    errorTracking: {
+      enabled: errorTrackingEnabled,
+      dsn: errorTrackingDsn,
+      tracesSampleRate: connector?.errorTracking?.tracesSampleRate ?? 1,
+      environment: connector?.errorTracking?.environment,
+      release: connector?.errorTracking?.release,
+      ready: errorTrackingReady,
+      status: errorTrackingReady ? "enabled" : "missing"
+    },
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function resolveBetterStackLevel(level) {
+  switch (level) {
+    case "debug":
+      return "debug";
+    case "warning":
+    case "warn":
+      return "warn";
+    case "error":
+      return "error";
+    case "critical":
+      return "fatal";
+    case "success":
+    case "table":
+    case "info":
+    default:
+      return "info";
+  }
+}
+function parseCaller(caller) {
+  if (typeof caller !== "string" || caller.trim().length === 0) {
+    return {};
+  }
+  const match = caller.match(/^(.*):(\d+)$/);
+  if (!match) {
+    return {};
+  }
+  const file = match[1]?.trim();
+  const line = Number.parseInt(match[2] ?? "", 10);
+  return {
+    ...file ? { file } : {},
+    ...Number.isFinite(line) ? { line } : {}
+  };
+}
+function buildContext(record, connector, source) {
+  const recordType = getRecordType(record);
+  const groupId = getField(record, "groupId");
+  const method = getField(record, "method");
+  const path3 = getField(record, "path");
+  const status = getField(record, "status");
+  const duration = getField(record, "duration");
+  const pagePath = getClientPageField(record, "pathname");
+  const pageUrl = getClientPageField(record, "url");
+  const sessionId = getClientSessionField(record, "sessionId");
+  const pageId = getClientSessionField(record, "pageId");
+  const runtime2 = parseCaller(record.caller);
+  return {
+    service: connector.serviceName,
+    context: {
+      blyp: {
+        level: record.level,
+        source,
+        ...recordType ? { type: recordType } : {},
+        ...groupId ? { group_id: groupId } : {},
+        ...record.caller ? { caller: record.caller } : {},
+        ...duration !== void 0 ? { duration_ms: duration } : {},
+        ...record.bindings ? { bindings: record.bindings } : {},
+        payload: serializeLogRecord(record)
+      },
+      ...method || path3 || status !== void 0 ? {
+        http: {
+          ...method ? { method } : {},
+          ...path3 ? { path: path3 } : {},
+          ...status !== void 0 ? { status_code: status } : {}
+        }
+      } : {},
+      ...pagePath || pageUrl || sessionId || pageId ? {
+        client: {
+          ...pagePath ? { page_path: pagePath } : {},
+          ...pageUrl ? { page_url: pageUrl } : {},
+          ...sessionId ? { session_id: sessionId } : {},
+          ...pageId ? { page_id: pageId } : {}
+        }
+      } : {},
+      ...Object.keys(runtime2).length > 0 ? { runtime: runtime2 } : {},
+      ...record.data !== void 0 ? { data: record.data } : {},
+      ...record.error !== void 0 ? { error: record.error } : {}
+    }
+  };
+}
+function toExceptionCandidate(value) {
+  if (!isPlainObject(value)) {
+    return void 0;
+  }
+  const message = typeof value.message === "string" ? value.message : void 0;
+  const name = typeof value.name === "string" ? value.name : void 0;
+  const stack = typeof value.stack === "string" ? value.stack : void 0;
+  if (!message && !name && !stack) {
+    return void 0;
+  }
+  const error = new Error(message ?? name ?? "Unknown error");
+  error.name = name ?? "Error";
+  if (stack) {
+    error.stack = stack;
+  }
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "message" || key === "name" || key === "stack") {
+      continue;
+    }
+    error[key] = entry;
+  }
+  return error;
+}
+function normalizeScopeLevel(level) {
+  switch (level) {
+    case "debug":
+      return "debug";
+    case "warning":
+    case "warn":
+      return "warning";
+    case "critical":
+      return "fatal";
+    case "error":
+      return "error";
+    case "success":
+    case "table":
+    case "info":
+    default:
+      return "info";
+  }
+}
+function normalizeExceptionInput2(input) {
+  if (input instanceof Error) {
+    return input;
+  }
+  const direct = toExceptionCandidate(input);
+  if (direct) {
+    return direct;
+  }
+  if (typeof input === "string") {
+    return new Error(input);
+  }
+  return new Error("Unknown Better Stack exception");
+}
+function isPreviouslyCapturedError(value) {
+  return isPlainObject(value) && value[PREVIOUSLY_CAPTURED_ERROR_KEY2] === true;
+}
+function markCapturedError(value) {
+  if (!isPlainObject(value) || isPreviouslyCapturedError(value)) {
+    return;
+  }
+  try {
+    Object.defineProperty(value, PREVIOUSLY_CAPTURED_ERROR_KEY2, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+  } catch {
+    try {
+      value[PREVIOUSLY_CAPTURED_ERROR_KEY2] = true;
+    } catch {
+    }
+  }
+}
+function createDefaultClient(connector) {
+  return new Logtail(connector.sourceToken ?? "", {
+    endpoint: connector.ingestingHost,
+    captureStackContext: false
+  });
+}
+function getClientOptions(client) {
+  return client?.getOptions?.() ?? {};
+}
+function registerShutdownHooks2(key, flush) {
+  const handlers = ["beforeExit", "SIGINT", "SIGTERM"];
+  for (const event of handlers) {
+    process.once(event, () => {
+      void flush().catch((error) => {
+        warnOnce4(
+          `${key}:shutdown`,
+          "[Blyp] Failed to flush Better Stack logs during shutdown.",
+          error
+        );
+      });
+    });
+  }
+}
+function createBetterStackSender(config) {
+  const connector = resolveConnectorConfig2(config);
+  const key = `${connector.serviceName}:${connector.ingestingHost ?? "missing"}:${connector.mode}`;
+  const sentryModule = getSentryModule();
+  const client = connector.ready ? testHooks2.createClient?.(connector) ?? createDefaultClient(connector) : void 0;
+  let sentryClient = connector.errorTracking.enabled ? sentryModule?.getClient?.() : void 0;
+  if (sentryClient) {
+    const options = getClientOptions(sentryClient);
+    if (hasNonEmptyString(connector.errorTracking.dsn) && connector.errorTracking.dsn !== options.dsn || hasNonEmptyString(connector.errorTracking.environment) && connector.errorTracking.environment !== options.environment || hasNonEmptyString(connector.errorTracking.release) && connector.errorTracking.release !== options.release) {
+      warnOnce4(
+        `betterstack-error-mismatch:${key}`,
+        "[Blyp] Sentry is already initialized with different options. Reusing the existing Sentry client for Better Stack error tracking."
+      );
+    }
+  }
+  if (!sentryClient && connector.errorTracking.enabled && hasNonEmptyString(connector.errorTracking.dsn) && sentryModule) {
+    try {
+      sentryModule.init({
+        dsn: connector.errorTracking.dsn,
+        tracesSampleRate: connector.errorTracking.tracesSampleRate,
+        environment: connector.errorTracking.environment,
+        release: connector.errorTracking.release
+      });
+      sentryClient = sentryModule.getClient();
+    } catch (error) {
+      warnOnce4(
+        `betterstack-error-init:${key}`,
+        "[Blyp] Failed to initialize Better Stack error tracking.",
+        error
+      );
+    }
+  }
+  const errorTrackingReady = connector.errorTracking.enabled && sentryClient !== void 0;
+  if (client || errorTrackingReady) {
+    registerShutdownHooks2(key, async () => {
+      if (client) {
+        await client.flush();
+      }
+      if (errorTrackingReady) {
+        await sentryModule.flush(2e3);
+      }
+    });
+  }
+  const emitUnavailableWarning = () => {
+    warnOnce4(
+      `betterstack-unavailable:${key}`,
+      "[Blyp] Better Stack connector is not configured or not ready. Skipping Better Stack delivery."
+    );
+  };
+  const emitExceptionUnavailableWarning = () => {
+    warnOnce4(
+      `betterstack-exception-unavailable:${key}`,
+      "[Blyp] Better Stack error tracking is not configured. Skipping Better Stack exception capture."
+    );
+  };
+  return {
+    enabled: connector.enabled,
+    ready: connector.ready,
+    mode: connector.mode,
+    serviceName: connector.serviceName,
+    ingestingHost: connector.ingestingHost,
+    status: connector.status,
+    errorTracking: {
+      enabled: connector.errorTracking.enabled,
+      ready: errorTrackingReady,
+      status: errorTrackingReady ? "enabled" : "missing",
+      dsn: connector.errorTracking.dsn,
+      tracesSampleRate: connector.errorTracking.tracesSampleRate,
+      environment: connector.errorTracking.environment,
+      release: connector.errorTracking.release
+    },
+    shouldAutoForwardServerLogs() {
+      return connector.ready && connector.mode === "auto";
+    },
+    shouldAutoCaptureExceptions() {
+      return errorTrackingReady;
+    },
+    send(record, options = {}) {
+      if (!connector.ready || !client) {
+        if (options.warnIfUnavailable) {
+          emitUnavailableWarning();
+        }
+        return;
+      }
+      const source = options.source ?? "server";
+      void client.log(
+        record.message,
+        resolveBetterStackLevel(record.level),
+        buildContext(record, connector, source)
+      ).catch((error) => {
+        warnOnce4(
+          `betterstack-send:${key}`,
+          "[Blyp] Failed to deliver log to Better Stack.",
+          error
+        );
+      });
+    },
+    captureException(error, options = {}) {
+      if (!errorTrackingReady || !sentryModule) {
+        if (options.warnIfUnavailable) {
+          emitExceptionUnavailableWarning();
+        }
+        return;
+      }
+      if (isPreviouslyCapturedError(error)) {
+        return;
+      }
+      try {
+        const exception = normalizeExceptionInput2(error);
+        sentryModule.withScope((scope) => {
+          scope.setLevel(
+            normalizeScopeLevel(
+              options.source === "client" ? "error" : "error"
+            )
+          );
+          scope.setContext("blyp", {
+            source: options.source ?? "server",
+            ...options.context ? { context: options.context } : {}
+          });
+          sentryModule.captureException(exception);
+        });
+        markCapturedError(error);
+        markCapturedError(exception);
+      } catch (captureError) {
+        warnOnce4(
+          `betterstack-manual-capture:${key}`,
+          "[Blyp] Failed to capture exception in Better Stack error tracking.",
+          captureError
+        );
+      }
+    },
+    async flush() {
+      if (!client) {
+        if (!errorTrackingReady || !sentryModule) {
+          return;
+        }
+      }
+      try {
+        if (client) {
+          await client.flush();
+        }
+        if (errorTrackingReady && sentryModule) {
+          await sentryModule.flush(2e3);
+        }
+      } catch (error) {
+        warnOnce4(
+          `betterstack-flush:${key}`,
+          "[Blyp] Failed to flush Better Stack logs.",
+          error
+        );
+      }
+    }
+  };
+}
+var warnedKeys4 = /* @__PURE__ */ new Set();
+var testHooks3 = {};
+var warnOnce5 = createErrorOnceLogger(warnedKeys4);
+function getSentryModule2() {
+  return testHooks3.module ?? Sentry;
+}
+function resolveConnectorConfig3(config) {
+  const connector = isBlypConfig(config) ? config.connectors?.sentry : config;
+  const enabled = connector?.enabled ?? false;
+  const dsn = connector?.dsn;
+  const ready = enabled && hasNonEmptyString(dsn);
+  return {
+    enabled,
+    mode: connector?.mode ?? "auto",
+    dsn,
+    environment: connector?.environment,
+    release: connector?.release,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function normalizeAttributes(record, source) {
+  const attributes = {
+    "blyp.level": record.level,
+    "blyp.source": source,
+    "blyp.payload": serializeLogRecord(record)
+  };
+  const recordType = getRecordType(record);
+  const caller = typeof record.caller === "string" ? record.caller : void 0;
+  const groupId = getField(record, "groupId");
+  const method = getField(record, "method");
+  const path3 = getField(record, "path");
+  const status = getField(record, "status");
+  const duration = getField(record, "duration");
+  const pagePath = getClientPageField(record, "pathname");
+  const pageUrl = getClientPageField(record, "url");
+  const sessionId = getClientSessionField(record, "sessionId");
+  const pageId = getClientSessionField(record, "pageId");
+  const ifTruthy = [
+    ["blyp.type", recordType],
+    ["blyp.caller", caller],
+    ["blyp.group_id", groupId],
+    ["http.method", method],
+    ["url.path", path3],
+    ["client.page_path", pagePath],
+    ["client.page_url", pageUrl],
+    ["client.session_id", sessionId],
+    ["client.page_id", pageId]
+  ];
+  const ifDefined = [
+    ["http.status_code", status],
+    ["blyp.duration_ms", duration]
+  ];
+  for (const [k, v] of ifTruthy) if (v) attributes[k] = v;
+  for (const [k, v] of ifDefined) if (v !== void 0) attributes[k] = v;
+  return attributes;
+}
+function resolveLogMethod(module, level) {
+  switch (level) {
+    case "debug":
+      return module.logger.debug;
+    case "warning":
+    case "warn":
+      return module.logger.warn;
+    case "error":
+      return module.logger.error;
+    case "critical":
+      return module.logger.fatal;
+    case "success":
+    case "table":
+    case "info":
+    default:
+      return module.logger.info;
+  }
+}
+function normalizeScopeLevel2(level) {
+  switch (level) {
+    case "debug":
+      return "debug";
+    case "warning":
+    case "warn":
+      return "warning";
+    case "critical":
+      return "fatal";
+    case "error":
+      return "error";
+    case "success":
+    case "table":
+    case "info":
+    default:
+      return "info";
+  }
+}
+function toExceptionCandidate2(value) {
+  if (!isPlainObject(value)) {
+    return void 0;
+  }
+  const message = typeof value.message === "string" ? value.message : void 0;
+  const name = typeof value.name === "string" ? value.name : void 0;
+  const stack = typeof value.stack === "string" ? value.stack : void 0;
+  if (!message && !name && !stack) {
+    return void 0;
+  }
+  const error = new Error(message ?? name ?? "Unknown error");
+  error.name = name ?? "Error";
+  if (stack) {
+    error.stack = stack;
+  }
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "message" || key === "name" || key === "stack") {
+      continue;
+    }
+    error[key] = entry;
+  }
+  return error;
+}
+function extractExceptionCandidate(record) {
+  if (record.level !== "error" && record.level !== "critical") {
+    return void 0;
+  }
+  const direct = toExceptionCandidate2(record.error);
+  if (direct) {
+    return direct;
+  }
+  if (isPlainObject(record.data)) {
+    const directData = toExceptionCandidate2(record.data);
+    if (directData) {
+      return directData;
+    }
+    const nested = toExceptionCandidate2(record.data.error);
+    if (nested) {
+      return nested;
+    }
+  }
+  const payload = getPrimaryPayload(record);
+  if (isPlainObject(payload)) {
+    const nested = toExceptionCandidate2(payload.error);
+    if (nested) {
+      return nested;
+    }
+  }
+  return void 0;
+}
+function getClientOptions2(client) {
+  return client?.getOptions?.() ?? {};
+}
+function hasConfigMismatch(connector, client) {
+  const options = getClientOptions2(client);
+  return hasNonEmptyString(connector.dsn) && connector.dsn !== options.dsn || hasNonEmptyString(connector.environment) && connector.environment !== options.environment || hasNonEmptyString(connector.release) && connector.release !== options.release;
+}
+function createSentrySender(config) {
+  const connector = resolveConnectorConfig3(config);
+  const key = `${connector.mode}:${connector.dsn ?? "missing"}`;
+  const module = getSentryModule2();
+  let client = connector.enabled ? module.getClient() : void 0;
+  if (!client && connector.enabled && hasNonEmptyString(connector.dsn)) {
+    try {
+      module.init({
+        dsn: connector.dsn,
+        environment: connector.environment,
+        release: connector.release,
+        enableLogs: true
+      });
+      client = module.getClient();
+    } catch (error) {
+      warnOnce5(
+        `sentry-init:${key}`,
+        "[Blyp] Failed to initialize Sentry. Skipping Sentry delivery.",
+        error
+      );
+    }
+  }
+  if (client && hasConfigMismatch(connector, client)) {
+    warnOnce5(
+      `sentry-mismatch:${key}`,
+      "[Blyp] Sentry is already initialized with different options. Reusing the existing Sentry client."
+    );
+  }
+  const ready = connector.enabled && client !== void 0;
+  const emitUnavailableWarning = () => {
+    warnOnce5(
+      `sentry-unavailable:${key}`,
+      "[Blyp] Sentry connector is not configured. Skipping Sentry delivery."
+    );
+  };
+  return {
+    enabled: connector.enabled,
+    ready,
+    mode: connector.mode,
+    status: ready ? "enabled" : "missing",
+    shouldAutoForwardServerLogs() {
+      return ready && connector.mode === "auto";
+    },
+    send(record, options = {}) {
+      if (!ready) {
+        if (options.warnIfUnavailable) {
+          emitUnavailableWarning();
+        }
+        return;
+      }
+      const source = options.source ?? "server";
+      const attributes = normalizeAttributes(record, source);
+      const logMethod = resolveLogMethod(module, record.level);
+      try {
+        logMethod(record.message, attributes);
+      } catch (error) {
+        warnOnce5(
+          `sentry-log:${key}`,
+          "[Blyp] Failed to deliver log to Sentry.",
+          error
+        );
+      }
+      const exception = extractExceptionCandidate(record);
+      if (!exception) {
+        return;
+      }
+      try {
+        module.withScope((scope) => {
+          scope.setLevel(normalizeScopeLevel2(record.level));
+          scope.setContext("blyp", attributes);
+          scope.setExtra("blyp.payload", serializeLogRecord(record));
+          module.captureException(exception);
+        });
+      } catch (error) {
+        warnOnce5(
+          `sentry-exception:${key}`,
+          "[Blyp] Failed to capture exception in Sentry.",
+          error
+        );
+      }
+    },
+    async flush() {
+      try {
+        await module.flush(2e3);
+      } catch (error) {
+        warnOnce5(
+          `sentry-flush:${key}`,
+          "[Blyp] Failed to flush Sentry logs.",
+          error
+        );
+      }
+    }
+  };
+}
+var warnedKeys5 = /* @__PURE__ */ new Set();
+var testHooks4 = {};
+var warnOnce6 = createErrorOnceLogger(warnedKeys5);
+function normalizeOTLPRecord(record, connector, source = "server") {
+  const severity = resolveSeverity2(record.level);
+  const body = typeof record.message === "string" ? record.message : String(record.message);
+  const recordType = getRecordType(record);
+  const caller = typeof record.caller === "string" ? record.caller : void 0;
+  const groupId = getField(record, "groupId");
+  const method = getField(record, "method");
+  const path3 = getField(record, "path");
+  const status = getField(record, "status");
+  const duration = getField(record, "duration");
+  const pagePath = getClientPageField(record, "pathname");
+  const pageUrl = getClientPageField(record, "url");
+  const sessionId = getClientSessionField(record, "sessionId");
+  const pageId = getClientSessionField(record, "pageId");
+  const attributes = {
+    "blyp.level": record.level,
+    "blyp.source": source,
+    "blyp.payload": serializeLogRecord(record)
+  };
+  const ifTruthy = [
+    ["blyp.type", recordType],
+    ["blyp.caller", caller],
+    ["blyp.group_id", groupId],
+    ["http.method", method],
+    ["url.path", path3],
+    ["client.page_path", pagePath],
+    ["client.page_url", pageUrl],
+    ["client.session_id", sessionId],
+    ["client.page_id", pageId]
+  ];
+  const ifDefined = [
+    ["http.status_code", status],
+    ["blyp.duration_ms", duration]
+  ];
+  for (const [k, v] of ifTruthy) if (v) attributes[k] = v;
+  for (const [k, v] of ifDefined) if (v !== void 0) attributes[k] = v;
+  return {
+    body,
+    severityText: severity.text,
+    severityNumber: severity.number,
+    attributes,
+    resourceAttributes: {
+      "service.name": connector.serviceName
+    }
+  };
+}
+function resolveSeverity2(level) {
+  switch (level) {
+    case "debug":
+      return { text: "debug", number: SeverityNumber.DEBUG };
+    case "warning":
+    case "warn":
+      return { text: "warn", number: SeverityNumber.WARN };
+    case "error":
+      return { text: "error", number: SeverityNumber.ERROR };
+    case "critical":
+      return { text: "fatal", number: SeverityNumber.FATAL };
+    case "success":
+    case "table":
+    case "info":
+    default:
+      return { text: "info", number: SeverityNumber.INFO };
+  }
+}
+function registerShutdownHooks3(key, shutdown) {
+  const handlers = ["beforeExit", "SIGINT", "SIGTERM"];
+  for (const event of handlers) {
+    process.once(event, async () => {
+      try {
+        await shutdown();
+      } catch (error) {
+        warnOnce6(
+          `${key}:shutdown`,
+          "[Blyp] Failed to flush OTLP logs during shutdown.",
+          error
+        );
+      }
+      if (event !== "beforeExit") {
+        process.exit(0);
+      }
+    });
+  }
+}
+function resolveTransportHeaders(connector) {
+  const headers = {
+    ...connector.headers ?? {}
+  };
+  if (headers.Authorization === void 0 && connector.auth) {
+    headers.Authorization = connector.auth;
+  }
+  return headers;
+}
+function createDefaultTransport2(connector) {
+  const exporter = new OTLPLogExporter({
+    url: connector.endpoint,
+    headers: resolveTransportHeaders(connector)
+  });
+  const provider = new LoggerProvider({
+    resource: resourceFromAttributes({
+      "service.name": connector.serviceName
+    }),
+    processors: [new BatchLogRecordProcessor(exporter)]
+  });
+  const logger3 = provider.getLogger(`blyp-otlp:${connector.name}`);
+  return {
+    emit(payload) {
+      logger3.emit({
+        body: payload.body,
+        severityText: payload.severityText,
+        severityNumber: payload.severityNumber,
+        attributes: payload.attributes
+      });
+    },
+    flush() {
+      return provider.forceFlush();
+    },
+    shutdown() {
+      return provider.shutdown();
+    }
+  };
+}
+function resolveConnectors(config) {
+  const connectors = isBlypConfig(config) ? config.connectors?.otlp ?? [] : config;
+  return connectors.map((connector) => {
+    const headers = {
+      ...connector.headers ?? {}
+    };
+    const enabled = connector.enabled ?? false;
+    const endpoint = connector.endpoint;
+    const explicitReady = "ready" in connector && typeof connector.ready === "boolean" ? connector.ready : void 0;
+    const ready = (explicitReady ?? (enabled && isAbsoluteHttpUrl(endpoint))) && isAbsoluteHttpUrl(endpoint);
+    return {
+      name: connector.name,
+      enabled,
+      mode: connector.mode ?? "auto",
+      endpoint,
+      headers,
+      auth: connector.auth,
+      serviceName: connector.serviceName ?? "blyp-app",
+      ready,
+      status: ready ? "enabled" : "missing"
+    };
+  });
+}
+function createUnavailableSender(name, connector) {
+  const senderName = name || connector?.name || "otlp";
+  const key = `${senderName}:${connector?.serviceName ?? "blyp-app"}:${connector?.endpoint ?? "missing"}`;
+  const emitUnavailableWarning = () => {
+    warnOnce6(
+      `otlp-unavailable:${key}`,
+      `[Blyp] OTLP target "${senderName}" is not configured or not ready. Skipping OTLP delivery.`
+    );
+  };
+  return {
+    name: senderName,
+    enabled: connector?.enabled ?? false,
+    ready: false,
+    mode: connector?.mode ?? "auto",
+    serviceName: connector?.serviceName ?? "blyp-app",
+    endpoint: connector?.endpoint,
+    status: "missing",
+    send(_record, options = {}) {
+      if (options.warnIfUnavailable) {
+        emitUnavailableWarning();
+      }
+    },
+    async flush() {
+    }
+  };
+}
+function createSender(connector) {
+  if (!connector.ready || !connector.endpoint) {
+    return createUnavailableSender(connector.name, connector);
+  }
+  const key = `${connector.name}:${connector.serviceName}:${connector.endpoint}:${connector.mode}`;
+  const transportConnector = {
+    ...connector,
+    headers: resolveTransportHeaders(connector)
+  };
+  const transport = testHooks4.createTransport?.(transportConnector) ?? createDefaultTransport2(transportConnector);
+  return {
+    name: connector.name,
+    enabled: connector.enabled,
+    ready: connector.ready,
+    mode: connector.mode,
+    serviceName: connector.serviceName,
+    endpoint: connector.endpoint,
+    status: connector.status,
+    send(record, options = {}) {
+      const source = options.source ?? "server";
+      const normalized = normalizeOTLPRecord(record, connector, source);
+      try {
+        const result = transport.emit(normalized);
+        if (result && typeof result.catch === "function") {
+          void result.catch((error) => {
+            warnOnce6(
+              `otlp-emit:${key}`,
+              `[Blyp] Failed to deliver log to OTLP target "${connector.name}".`,
+              error
+            );
+          });
+        }
+      } catch (error) {
+        warnOnce6(
+          `otlp-emit:${key}`,
+          `[Blyp] Failed to deliver log to OTLP target "${connector.name}".`,
+          error
+        );
+      }
+    },
+    async flush() {
+      try {
+        if (transport.flush) {
+          await transport.flush();
+        }
+      } catch (error) {
+        warnOnce6(
+          `otlp-flush:${key}`,
+          `[Blyp] Failed to flush OTLP logs for target "${connector.name}".`,
+          error
+        );
+      }
+    }
+  };
+}
+function createOTLPRegistry(config) {
+  const senders = /* @__PURE__ */ new Map();
+  for (const connector of resolveConnectors(config)) {
+    senders.set(connector.name, createSender(connector));
+  }
+  const registry = {
+    get(name) {
+      return senders.get(name) ?? createUnavailableSender(name);
+    },
+    getAutoForwardTargets() {
+      return Array.from(senders.values()).filter((sender) => sender.ready && sender.mode === "auto");
+    },
+    send(name, record, options = {}) {
+      const sender = senders.get(name) ?? createUnavailableSender(name);
+      sender.send(record, options);
+    },
+    async flush() {
+      await Promise.all(Array.from(senders.values()).map((sender) => sender.flush()));
+    }
+  };
+  registerShutdownHooks3("otlp-registry", () => registry.flush());
+  return registry;
+}
+var _RuntimeDetector = class _RuntimeDetector {
+  constructor() {
+    __publicField(this, "_type", null);
+  }
+  static getInstance() {
+    if (!_RuntimeDetector.instance) {
+      _RuntimeDetector.instance = new _RuntimeDetector();
+    }
+    return _RuntimeDetector.instance;
+  }
+  get type() {
+    if (this._type === null) {
+      this._type = this.detectRuntime();
+    }
+    return this._type;
+  }
+  get isBun() {
+    return this.type === "bun";
+  }
+  get isNode() {
+    return this.type === "node";
+  }
+  detectRuntime() {
+    if (typeof Bun !== "undefined" && typeof Bun.file === "function") {
+      return "bun";
+    }
+    return "node";
+  }
+};
+__publicField(_RuntimeDetector, "instance");
+var RuntimeDetector = _RuntimeDetector;
+var BunAdapter = class {
+  constructor() {
+    __publicField(this, "type", "bun");
+    __publicField(this, "isBun", true);
+    __publicField(this, "isNode", false);
+    __publicField(this, "file", {
+      existsSync: (filePath) => {
+        try {
+          const file = Bun.file(filePath);
+          return file.size > 0 || file.name !== "";
+        } catch {
+          return false;
+        }
+      },
+      mkdirSync: (filePath, options) => {
+        try {
+          fs.mkdirSync(filePath, options);
+        } catch {
+        }
+      },
+      writeFileSync: (filePath, data) => {
+        Bun.write(filePath, data);
+      }
+    });
+    __publicField(this, "path", {
+      join: (...paths) => {
+        return path.join(...paths);
+      }
+    });
+    __publicField(this, "env", {
+      get: (key) => Bun.env[key]
+    });
+    __publicField(this, "cwd", () => {
+      return process.cwd();
+    });
+  }
+};
+var NodeAdapter = class {
+  constructor() {
+    __publicField(this, "type", "node");
+    __publicField(this, "isBun", false);
+    __publicField(this, "isNode", true);
+    __publicField(this, "file", {
+      existsSync: (filePath) => fs.existsSync(filePath),
+      mkdirSync: (filePath, options) => {
+        fs.mkdirSync(filePath, options);
+      },
+      writeFileSync: (filePath, data) => {
+        fs.writeFileSync(filePath, data);
+      }
+    });
+    __publicField(this, "path", {
+      join: (...paths) => path.join(...paths)
+    });
+    __publicField(this, "env", {
+      get: (key) => process.env[key]
+    });
+    __publicField(this, "cwd", () => process.cwd());
+  }
+};
+function createRuntimeAdapter() {
+  const detector = RuntimeDetector.getInstance();
+  if (detector.isBun) {
+    return new BunAdapter();
+  }
+  return new NodeAdapter();
+}
+var runtime = createRuntimeAdapter();
+
+// src/core/structured-log.ts
+function serializeMessage2(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message !== null && typeof message === "object") {
+    try {
+      return JSON.stringify(
+        message,
+        (_key, value) => {
+          if (typeof value === "function") {
+            return `[Function: ${value.name || "anonymous"}]`;
+          }
+          if (value === void 0) {
+            return "[undefined]";
+          }
+          if (typeof value === "symbol") {
+            return value.toString();
+          }
+          return value;
+        },
+        2
+      );
+    } catch {
+      return "[Object]";
+    }
+  }
+  return String(message);
+}
+function normalizeEventData(message, args) {
+  if (typeof message === "string") {
+    if (args.length === 0) {
+      return void 0;
+    }
+    return args.length === 1 ? args[0] : args;
+  }
+  const values = [message, ...args];
+  return values.length === 1 ? values[0] : values;
+}
+function normalizeDetails(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeError2(error, fallbackStatus) {
+  if (error === void 0 || error === null) {
+    return fallbackStatus === void 0 || fallbackStatus < 400 ? void 0 : {
+      message: `HTTP ${fallbackStatus}`,
+      code: fallbackStatus,
+      type: "HttpError"
+    };
+  }
+  if (error instanceof Error) {
+    const errorLike = error;
+    return {
+      message: error.message,
+      code: errorLike.code,
+      type: errorLike.type ?? error.name ?? error.constructor?.name,
+      stack: error.stack,
+      why: errorLike.why,
+      fix: errorLike.fix,
+      link: errorLike.link,
+      details: normalizeDetails(errorLike.details),
+      cause: errorLike.cause
+    };
+  }
+  if (typeof error === "object") {
+    const record = error;
+    const statusCode = typeof record.statusCode === "number" ? record.statusCode : typeof record.status === "number" ? record.status : fallbackStatus;
+    return {
+      message: typeof record.message === "string" ? record.message : `HTTP ${statusCode ?? 500}`,
+      code: typeof record.code === "string" || typeof record.code === "number" ? record.code : statusCode,
+      type: typeof record.type === "string" ? record.type : typeof record.name === "string" ? record.name : "Error",
+      stack: typeof record.stack === "string" ? record.stack : void 0,
+      why: typeof record.why === "string" ? record.why : void 0,
+      fix: typeof record.fix === "string" ? record.fix : void 0,
+      link: typeof record.link === "string" ? record.link : void 0,
+      details: normalizeDetails(record.details),
+      cause: record.cause
+    };
+  }
+  return {
+    message: String(error),
+    code: fallbackStatus,
+    type: typeof error
+  };
+}
+function resolveEmitStatus(options) {
+  if (options.response && typeof options.response.status === "number") {
+    return options.response.status;
+  }
+  if (typeof options.status === "number") {
+    return options.status;
+  }
+  if (options.error && typeof options.error === "object" && options.error !== null && typeof options.error.statusCode === "number") {
+    return options.error.statusCode;
+  }
+  if (options.error && typeof options.error === "object" && options.error !== null && typeof options.error.status === "number") {
+    return options.error.status;
+  }
+  return options.error ? 500 : void 0;
+}
+function createStructuredLog(groupId, options) {
+  const startedAt = performance.now();
+  const fields = { ...options.initialFields ?? {} };
+  const events = [];
+  let emittedPayload;
+  options.onCreate?.();
+  const appendEvent = (level, message, args) => {
+    events.push({
+      level,
+      message: serializeMessage2(message),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...normalizeEventData(message, args) === void 0 ? {} : { data: normalizeEventData(message, args) }
+    });
+    return structuredLog;
+  };
+  const structuredLog = {
+    set(extraFields) {
+      Object.assign(fields, extraFields);
+      return structuredLog;
+    },
+    debug(message, ...args) {
+      return appendEvent("debug", message, args);
+    },
+    info(message, ...args) {
+      return appendEvent("info", message, args);
+    },
+    warn(message, ...args) {
+      return appendEvent("warn", message, args);
+    },
+    warning(message, ...args) {
+      return appendEvent("warning", message, args);
+    },
+    error(message, ...args) {
+      return appendEvent("error", message, args);
+    },
+    success(message, ...args) {
+      return appendEvent("success", message, args);
+    },
+    critical(message, ...args) {
+      return appendEvent("critical", message, args);
+    },
+    table(message, data) {
+      return appendEvent("table", message, data === void 0 ? [] : [data]);
+    },
+    emit(emitOptions = {}) {
+      if (emittedPayload) {
+        return emittedPayload;
+      }
+      const defaultFields = options.resolveDefaultFields?.() ?? {};
+      const status = resolveEmitStatus(emitOptions);
+      const error = normalizeError2(emitOptions.error, status);
+      const level = emitOptions.level ?? (error ? "error" : "info");
+      const payload = {
+        ...defaultFields,
+        ...fields,
+        groupId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        duration: Math.round(performance.now() - startedAt),
+        ...typeof status === "number" ? { status } : {},
+        ...events.length > 0 ? { events: [...events] } : {},
+        ...error ? { error } : {}
+      };
+      options.write(payload, emitOptions.message ?? "structured_log");
+      emittedPayload = payload;
+      options.onEmit?.(payload);
+      return payload;
+    }
+  };
+  return structuredLog;
+}
+
+// src/core/logger.ts
+var LOGGER_FACTORY = /* @__PURE__ */ Symbol("blyp.logger.factory");
+var CUSTOM_LEVELS = {
+  success: 25,
+  info: 30,
+  debug: 35,
+  table: 37,
+  warning: 40,
+  error: 50,
+  critical: 60
+};
+var CONSOLE_LEVELS = {
+  success: "success",
+  critical: "critical",
+  warning: "warning",
+  info: "info",
+  debug: "debug",
+  error: "error",
+  warn: "warn",
+  table: "debug"
+};
+var MAGENTA = "\x1B[35m";
+var RESET = "\x1B[0m";
+function summarizeClientConsoleData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return null;
+  }
+  const record = data;
+  const summary = {};
+  if (record.data !== void 0) {
+    summary.data = record.data;
+  }
+  const pathname = typeof record.page?.pathname === "string" ? record.page.pathname : void 0;
+  const url = typeof record.page?.url === "string" ? record.page.url : void 0;
+  if (pathname || url) {
+    summary.page = pathname ?? url;
+  }
+  if (record.metadata !== void 0) {
+    summary.metadata = record.metadata;
+  }
+  return Object.keys(summary).length > 0 ? summary : null;
+}
+function getConsoleDataPayload(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return { hidden: false, value: data };
+  }
+  const record = data;
+  if (record.type === "http_request" || record.type === "http_error") {
+    return { hidden: true };
+  }
+  if (record.type === "client_log") {
+    const summary = summarizeClientConsoleData(data);
+    if (!summary) {
+      return { hidden: true };
+    }
+    return {
+      hidden: false,
+      value: summary
+    };
+  }
+  return { hidden: false, value: data };
+}
+function createPinoLogger(config) {
+  if (config.pretty) {
+    const pinoPretty = __require("pino-pretty");
+    const pretty = pinoPretty.default({
+      colorize: true,
+      translateTime: "SYS:HH:MM:ss",
+      ignore: "pid,hostname,caller",
+      customColors: {
+        success: "green",
+        critical: "red bold",
+        info: "blue",
+        warning: "yellow",
+        error: "red",
+        debug: "cyan",
+        table: "cyan"
+      },
+      messageFormat: (log, messageKey) => {
+        const message = String(log[messageKey] ?? "");
+        const caller = typeof log.caller === "string" ? log.caller.trim() : "";
+        if (!caller) {
+          return message;
+        }
+        return `${message} ${MAGENTA}${caller}${RESET}`;
+      }
+    });
+    return pino(
+      {
+        level: config.level,
+        customLevels: CUSTOM_LEVELS
+      },
+      pretty
+    );
+  }
+  return pino({
+    level: config.level,
+    customLevels: CUSTOM_LEVELS
+  });
+}
+function getLoggerFactory(logger3) {
+  const factory = logger3[LOGGER_FACTORY];
+  if (!factory) {
+    throw new Error("Unsupported Blyp logger instance");
+  }
+  return factory;
+}
+function getPostHogSender(logger3) {
+  return getLoggerFactory(logger3).posthog;
+}
+function getBetterStackSender(logger3) {
+  return getLoggerFactory(logger3).betterstack;
+}
+function tryGetPostHogSender(logger3) {
+  try {
+    return getPostHogSender(logger3);
+  } catch {
+    return null;
+  }
+}
+function tryGetBetterStackSender(logger3) {
+  try {
+    return getBetterStackSender(logger3);
+  } catch {
+    return null;
+  }
+}
+function getSentrySender(logger3) {
+  return getLoggerFactory(logger3).sentry;
+}
+function getOtlpRegistry(logger3) {
+  return getLoggerFactory(logger3).otlp;
+}
+function attachLoggerInternals(target, source) {
+  const factory = getLoggerFactory(source);
+  Object.defineProperty(target, LOGGER_FACTORY, {
+    value: factory,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return target;
+}
+function createLoggerWithSource(logger3, source) {
+  const factory = getLoggerFactory(logger3);
+  return factory.create(source, factory.bindings);
+}
+function createStructuredLogForLogger(logger3, groupId, options = {}) {
+  const factory = getLoggerFactory(logger3);
+  return createStructuredLog(groupId, {
+    initialFields: options.initialFields,
+    resolveDefaultFields: () => ({
+      ...factory.bindings,
+      ...options.resolveDefaultFields?.() ?? {}
+    }),
+    write: (payload, message) => {
+      factory.writeStructured(payload, message, "structured-flush");
+    },
+    onCreate: options.onCreate,
+    onEmit: options.onEmit
+  });
+}
+function maybeSendToPostHog(posthog, record) {
+  if (isClientLogRecord(record)) {
+    return;
+  }
+  if (!posthog.shouldAutoForwardServerLogs()) {
+    if (posthog.enabled && !posthog.ready) {
+      posthog.send(record, { source: "server", warnIfUnavailable: true });
+    }
+    return;
+  }
+  posthog.send(record, { source: "server", warnIfUnavailable: true });
+}
+function maybeSendToBetterStack(betterstack, record) {
+  if (isClientLogRecord(record)) {
+    return;
+  }
+  if (!betterstack.shouldAutoForwardServerLogs()) {
+    if (betterstack.enabled && !betterstack.ready) {
+      betterstack.send(record, { source: "server", warnIfUnavailable: true });
+    }
+    return;
+  }
+  betterstack.send(record, { source: "server", warnIfUnavailable: true });
+}
+function maybeSendToSentry(sentry, record) {
+  if (isClientLogRecord(record)) {
+    return;
+  }
+  if (!sentry.shouldAutoForwardServerLogs()) {
+    if (sentry.enabled && !sentry.ready) {
+      sentry.send(record, { source: "server", warnIfUnavailable: true });
+    }
+    return;
+  }
+  sentry.send(record, { source: "server", warnIfUnavailable: true });
+}
+function maybeSendToOTLP(otlp, record) {
+  if (isClientLogRecord(record)) {
+    return;
+  }
+  for (const sender of otlp.getAutoForwardTargets()) {
+    sender.send(record, { source: "server", warnIfUnavailable: true });
+  }
+}
+function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry, otlp, bindings = {}, source = "root") {
+  const rawLogger = Object.keys(bindings).length > 0 ? rootRawLogger.child(bindings) : rootRawLogger;
+  const writeRecord = (level, message, args, writeSource = source) => {
+    if (writeSource === "root" && shouldDropRootLogWrite()) {
+      return;
+    }
+    const record = buildRecord(level, message, args, bindings);
+    const consoleMessage = serializeMessage(message);
+    const payload = {
+      caller: record.caller
+    };
+    const consoleData = getConsoleDataPayload(record.data);
+    if (!consoleData.hidden && consoleData.value !== void 0) {
+      payload.data = consoleData.value;
+    }
+    const consoleMethod = CONSOLE_LEVELS[level];
+    const boundLogger = rawLogger;
+    const logMethod = boundLogger[consoleMethod] ?? boundLogger.info ?? ((_payload, _message) => {
+    });
+    logMethod.call(
+      rawLogger,
+      payload,
+      consoleMessage
+    );
+    sink.write(record);
+    maybeSendToBetterStack(betterstack, record);
+    maybeSendToPostHog(posthog, record);
+    maybeSendToSentry(sentry, record);
+    maybeSendToOTLP(otlp, record);
+  };
+  const writeStructuredRecord = (payload, message, writeSource = "structured-flush") => {
+    const level = resolveStructuredWriteLevel(payload.level);
+    const record = buildStructuredRecord(level, message, payload, bindings);
+    const consoleMethod = CONSOLE_LEVELS[level];
+    const boundLogger = rawLogger;
+    const logMethod = boundLogger[consoleMethod] ?? boundLogger.info ?? ((_payload, _message) => {
+    });
+    logMethod.call(
+      rawLogger,
+      {
+        caller: record.caller,
+        ...payload
+      },
+      message
+    );
+    if (writeSource !== "root" || !shouldDropRootLogWrite()) {
+      sink.write(record);
+    }
+    maybeSendToBetterStack(betterstack, record);
+    maybeSendToPostHog(posthog, record);
+    maybeSendToSentry(sentry, record);
+    maybeSendToOTLP(otlp, record);
+  };
+  const logger3 = {
+    success: (message, ...args) => {
+      writeRecord("success", message, args);
+    },
+    critical: (message, ...args) => {
+      writeRecord("critical", message, args);
+    },
+    warning: (message, ...args) => {
+      writeRecord("warning", message, args);
+    },
+    info: (message, ...args) => {
+      writeRecord("info", message, args);
+    },
+    debug: (message, ...args) => {
+      writeRecord("debug", message, args);
+    },
+    error: (message, ...args) => {
+      writeRecord("error", message, args);
+    },
+    warn: (message, ...args) => {
+      writeRecord("warn", message, args);
+    },
+    table: (message, data) => {
+      if (data && typeof data === "object" && runtime.env.get("NODE_ENV") !== "production") {
+        console.log("TABLE:", message);
+        console.table(data);
+      }
+      writeRecord("table", message, data === void 0 ? [] : [data]);
+    },
+    flush: () => sink.flush(),
+    shutdown: () => sink.shutdown(),
+    createStructuredLog: (groupId, initial) => {
+      return createStructuredLogForLogger(logger3, groupId, {
+        initialFields: initial
+      });
+    },
+    child: (childBindings) => {
+      const mergedBindings = { ...bindings, ...childBindings };
+      return createLoggerInstance(
+        rootRawLogger,
+        sink,
+        betterstack,
+        posthog,
+        sentry,
+        otlp,
+        mergedBindings,
+        source
+      );
+    },
+    [LOGGER_FACTORY]: {
+      bindings,
+      betterstack,
+      posthog,
+      sentry,
+      otlp,
+      sink,
+      create: (nextSource, nextBindings = bindings) => {
+        return createLoggerInstance(
+          rootRawLogger,
+          sink,
+          betterstack,
+          posthog,
+          sentry,
+          otlp,
+          nextBindings,
+          nextSource
+        );
+      },
+      writeStructured: (payload, message, nextSource = "structured-flush") => {
+        writeStructuredRecord(payload, message, nextSource);
+      }
+    }
+  };
+  return logger3;
+}
+var loggerInstance = null;
+function createBaseLogger(config) {
+  if (config === void 0 && loggerInstance) {
+    return loggerInstance;
+  }
+  const resolvedConfig = resolveConfig(config);
+  const rawLogger = createPinoLogger(resolvedConfig);
+  const sink = createPrimarySink(resolvedConfig);
+  const betterstack = createBetterStackSender(resolvedConfig);
+  const posthog = createPostHogSender(resolvedConfig);
+  const sentry = createSentrySender(resolvedConfig);
+  const otlp = createOTLPRegistry(resolvedConfig);
+  const instance = createLoggerInstance(
+    rawLogger,
+    sink,
+    betterstack,
+    posthog,
+    sentry,
+    otlp
+  );
+  if (config === void 0) {
+    loggerInstance = instance;
+  }
+  return instance;
+}
+createBaseLogger();
+
+// src/frameworks/shared/logger.ts
+function buildVerboseLogMessage(method, statusCode, url, responseTime) {
+  const methodColor = getMethodColor(method);
+  const statusColor = getStatusColor(statusCode);
+  const timeColor = getResponseTimeColor(responseTime);
+  return `${methodColor} ${url} ${statusColor} ${timeColor}`;
+}
+function resolveClientLoggingConfig(clientLogging, defaultClientLogging) {
+  const defaultPath = normalizeEndpointPath(
+    defaultClientLogging?.path ?? DEFAULT_CLIENT_LOG_ENDPOINT
+  );
+  const defaultConfig = defaultClientLogging?.enabled === false ? null : { path: defaultPath };
+  if (clientLogging === false) {
+    return null;
+  }
+  if (clientLogging === void 0) {
+    return defaultConfig;
+  }
+  if (clientLogging === true) {
+    return {
+      path: defaultPath
+    };
+  }
+  return {
+    ...defaultConfig,
+    ...clientLogging,
+    path: normalizeEndpointPath(clientLogging.path ?? defaultPath)
+  };
+}
+function resolveServerLogger(config = {}, loggerOverride) {
+  const resolvedConfig = resolveConfig({
+    ...config.level !== void 0 ? { level: config.level } : {},
+    ...config.pretty !== void 0 ? { pretty: config.pretty } : {},
+    ...config.destination !== void 0 ? { destination: config.destination } : {},
+    ...config.logDir !== void 0 ? { logDir: config.logDir } : {},
+    ...config.file !== void 0 ? { file: config.file } : {},
+    ...config.database !== void 0 ? { database: config.database } : {},
+    ...config.connectors !== void 0 ? { connectors: config.connectors } : {}
+  });
+  const {
+    level = resolvedConfig.level,
+    pretty = resolvedConfig.pretty,
+    destination = resolvedConfig.destination,
+    logDir = resolvedConfig.logDir,
+    file = resolvedConfig.file,
+    database = resolvedConfig.database,
+    autoLogging = true,
+    customProps,
+    logErrors = true,
+    ignorePaths,
+    clientLogging,
+    connectors
+  } = config;
+  const logger3 = loggerOverride ?? createBaseLogger({
+    level,
+    pretty,
+    destination,
+    logDir,
+    file,
+    database,
+    connectors
+  });
+  const resolvedClientLogging = resolveClientLoggingConfig(
+    clientLogging,
+    resolvedConfig.clientLogging
+  );
+  const ingestionPath = resolvedClientLogging?.path ?? DEFAULT_CLIENT_LOG_ENDPOINT;
+  const resolvedIgnorePaths = resolvedClientLogging ? Array.from(/* @__PURE__ */ new Set([...ignorePaths ?? [], ingestionPath])) : ignorePaths;
+  return {
+    logger: logger3,
+    betterstack: getBetterStackSender(logger3),
+    posthog: getPostHogSender(logger3),
+    sentry: getSentrySender(logger3),
+    otlp: getOtlpRegistry(logger3),
+    resolvedConfig,
+    level,
+    pretty,
+    logDir,
+    file,
+    autoLogging,
+    customProps,
+    logErrors,
+    resolvedIgnorePaths,
+    resolvedClientLogging,
+    ingestionPath
+  };
+}
+function shouldSkipAutoLogging(config, ctx, path3) {
+  if (config.autoLogging === false) {
+    return true;
+  }
+  if (typeof config.autoLogging === "object" && config.autoLogging.ignore?.(ctx)) {
+    return true;
+  }
+  return shouldIgnorePath(path3, config.resolvedIgnorePaths);
+}
+function shouldSkipErrorLogging(config, path3) {
+  if (!config.logErrors) {
+    return true;
+  }
+  return shouldIgnorePath(path3, config.resolvedIgnorePaths);
+}
+function resolveAdditionalProps(config, ctx) {
+  return config.customProps ? config.customProps(ctx) : {};
+}
+function emitHttpRequestLog(logger3, level, request, path3, statusCode, responseTime, additionalProps = {}) {
+  const requestLogData = buildRequestLogData(
+    request,
+    "http_request",
+    path3,
+    statusCode,
+    responseTime,
+    additionalProps
+  );
+  if (level === "info") {
+    logger3.info(
+      buildInfoLogMessage(request.method, statusCode, path3, responseTime),
+      requestLogData
+    );
+  } else {
+    logger3.info(
+      buildVerboseLogMessage(request.method, statusCode, path3, responseTime),
+      requestLogData
+    );
+    if (Object.keys(additionalProps).length > 0) {
+      logger3.debug("Request context", additionalProps);
+    }
+  }
+  return requestLogData;
+}
+function emitHttpErrorLog(logger3, level, request, path3, statusCode, responseTime, error, additionalProps = {}, captureContext = {}) {
+  const errorLogData = buildRequestLogData(
+    request,
+    "http_error",
+    path3,
+    statusCode,
+    responseTime,
+    {
+      error: error?.message ?? `HTTP ${statusCode}`,
+      stack: error?.stack,
+      code: error?.code,
+      why: error?.why,
+      fix: error?.fix,
+      link: error?.link,
+      details: error?.details,
+      ...additionalProps
+    }
+  );
+  const message = level === "info" ? buildInfoLogMessage(request.method, statusCode, path3, responseTime) : buildVerboseLogMessage(request.method, statusCode, path3, responseTime);
+  logger3.error(message, errorLogData);
+  const posthog = tryGetPostHogSender(logger3);
+  if (posthog?.shouldAutoCaptureExceptions()) {
+    posthog.captureException(captureContext.error ?? error ?? message, {
+      source: "server",
+      warnIfUnavailable: true,
+      distinctId: captureContext.distinctId ?? getHeaderValue(request.headers, "x-posthog-distinct-id"),
+      properties: buildPostHogExceptionProperties(
+        {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level: "error",
+          message,
+          data: errorLogData
+        },
+        "server",
+        {
+          $request_method: request.method,
+          $request_path: path3,
+          $current_url: request.url,
+          $response_status_code: statusCode,
+          ...getHeaderValue(request.headers, "user-agent") ? { $user_agent: getHeaderValue(request.headers, "user-agent") } : {},
+          ...errorLogData.ip ? { $ip: errorLogData.ip } : {}
+        }
+      )
+    });
+  }
+  const betterstack = tryGetBetterStackSender(logger3);
+  if (betterstack?.shouldAutoCaptureExceptions()) {
+    betterstack.captureException(captureContext.error ?? error ?? message, {
+      source: "server",
+      warnIfUnavailable: true,
+      context: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "error",
+        message,
+        status: statusCode,
+        path: path3,
+        data: errorLogData
+      }
+    });
+  }
+  return errorLogData;
+}
+async function parseClientLogPayload(request, body) {
+  if (body !== void 0) {
+    if (typeof body === "string") {
+      return JSON.parse(body);
+    }
+    return body;
+  }
+  if (typeof request.json === "function") {
+    return await request.json();
+  }
+  throw new Error("Unable to parse client log payload");
+}
+function getClientLogMethod(logger3, level) {
+  switch (level) {
+    case "debug":
+      return logger3.debug;
+    case "info":
+      return logger3.info;
+    case "warning":
+      return logger3.warning;
+    case "error":
+      return logger3.error;
+    case "critical":
+      return logger3.critical;
+    case "success":
+      return logger3.success;
+  }
+}
+async function handleClientLogIngestion(options) {
+  const { config, ctx, request, body, deliveryPath } = options;
+  if (!config.resolvedClientLogging) {
+    return { status: 404 };
+  }
+  let payload;
+  try {
+    payload = await parseClientLogPayload(request, body);
+  } catch {
+    return { status: 400 };
+  }
+  if (!isClientLogEvent(payload)) {
+    return { status: 400 };
+  }
+  const isAllowed = config.resolvedClientLogging.validate ? await config.resolvedClientLogging.validate(ctx, payload) : true;
+  if (!isAllowed) {
+    return { status: 403 };
+  }
+  const serverContext = config.resolvedClientLogging.enrich ? await config.resolvedClientLogging.enrich(ctx, payload) : void 0;
+  const structuredPayload = {
+    ...payload,
+    receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    delivery: buildClientDetails(request, deliveryPath ?? extractPathname(request.url))
+  };
+  if (serverContext !== void 0) {
+    structuredPayload.serverContext = serverContext;
+  }
+  if (payload.level === "table") {
+    config.logger.table(`[client] ${payload.message}`, structuredPayload);
+  } else {
+    const logMethod = getClientLogMethod(config.logger, payload.level);
+    logMethod(`[client] ${payload.message}`, structuredPayload);
+  }
+  const headers = {};
+  if (payload.connector === "betterstack") {
+    headers["x-blyp-betterstack-status"] = config.betterstack.ready ? "enabled" : "missing";
+    if (config.betterstack.ready) {
+      const forwardedRecord = {
+        timestamp: structuredPayload.receivedAt,
+        level: payload.level,
+        message: `[client] ${payload.message}`,
+        data: structuredPayload
+      };
+      config.betterstack.send(forwardedRecord, {
+        source: "client"
+      });
+      if ((payload.level === "error" || payload.level === "critical") && config.betterstack.shouldAutoCaptureExceptions()) {
+        const clientErrorCandidate = payload.data && typeof payload.data === "object" && !Array.isArray(payload.data) && typeof payload.data.message === "string" ? payload.data : payload.message;
+        config.betterstack.captureException(clientErrorCandidate, {
+          source: "client",
+          warnIfUnavailable: true,
+          context: {
+            sessionId: payload.session.sessionId,
+            pageUrl: payload.page.url,
+            pagePath: payload.page.pathname,
+            metadata: payload.metadata,
+            payload: structuredPayload
+          }
+        });
+      }
+    }
+  } else if (payload.connector === "posthog") {
+    headers["x-blyp-posthog-status"] = config.posthog.ready ? "enabled" : "missing";
+    if (config.posthog.ready) {
+      const forwardedRecord = {
+        timestamp: structuredPayload.receivedAt,
+        level: payload.level,
+        message: `[client] ${payload.message}`,
+        data: structuredPayload
+      };
+      config.posthog.send(forwardedRecord, {
+        source: "client"
+      });
+      if ((payload.level === "error" || payload.level === "critical") && config.posthog.shouldAutoCaptureExceptions()) {
+        const metadata = structuredPayload.metadata;
+        const posthogDistinctId = metadata && typeof metadata === "object" && !Array.isArray(metadata) && typeof metadata.posthogDistinctId === "string" && metadata.posthogDistinctId ? String(metadata.posthogDistinctId) : void 0;
+        const clientErrorCandidate = payload.data && typeof payload.data === "object" && !Array.isArray(payload.data) && typeof payload.data.message === "string" ? payload.data : payload.message;
+        config.posthog.captureException(clientErrorCandidate, {
+          source: "client",
+          warnIfUnavailable: true,
+          distinctId: posthogDistinctId,
+          properties: buildPostHogExceptionProperties(forwardedRecord, "client", {
+            $session_id: payload.session.sessionId,
+            $current_url: payload.page.url,
+            $request_path: payload.page.pathname,
+            "client.runtime": payload.device?.runtime,
+            "client.metadata": payload.metadata
+          })
+        });
+      }
+    }
+  } else if (payload.connector === "sentry") {
+    headers["x-blyp-sentry-status"] = config.sentry.ready ? "enabled" : "missing";
+    if (config.sentry.ready) {
+      config.sentry.send({
+        timestamp: structuredPayload.receivedAt,
+        level: payload.level,
+        message: `[client] ${payload.message}`,
+        data: structuredPayload
+      }, {
+        source: "client"
+      });
+    }
+  } else if (payload.connector?.type === "otlp") {
+    const sender = config.otlp.get(payload.connector.name);
+    headers["x-blyp-otlp-status"] = sender.ready ? "enabled" : "missing";
+    if (sender.ready) {
+      sender.send({
+        timestamp: structuredPayload.receivedAt,
+        level: payload.level,
+        message: `[client] ${payload.message}`,
+        data: structuredPayload
+      }, {
+        source: "client"
+      });
+    }
+  }
+  return Object.keys(headers).length > 0 ? { status: 204, headers } : { status: 204 };
+}
+async function readNodeRequestBody(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function buildAbsoluteUrl(path3, headers) {
+  if (path3.startsWith("http://") || path3.startsWith("https://")) {
+    return path3;
+  }
+  const protocol = getHeaderValue(headers, "x-forwarded-proto") ?? "http";
+  const host = getHeaderValue(headers, "host") ?? "localhost";
+  return `${protocol}://${host}${path3.startsWith("/") ? path3 : `/${path3}`}`;
+}
+
+// src/frameworks/shared/request-logger.ts
+function createRequestScopedLogger(logger3, options = {}) {
+  const scopedLogger = createLoggerWithSource(logger3, "request-scoped");
+  const requestScopedLogger = attachLoggerInternals({
+    ...scopedLogger,
+    createStructuredLog: (groupId, initial) => {
+      return createStructuredLogForLogger(requestScopedLogger, groupId, {
+        initialFields: initial,
+        resolveDefaultFields: options.resolveStructuredFields,
+        onCreate: () => {
+          markStructuredCollectorActive();
+        },
+        onEmit: () => {
+          markStructuredLogEmitted();
+          options.onStructuredEmit?.();
+        }
+      });
+    },
+    child(bindings) {
+      return createRequestScopedLogger(scopedLogger.child(bindings), options);
+    }
+  }, scopedLogger);
+  setActiveRequestLogger(requestScopedLogger);
+  return requestScopedLogger;
+}
+
+// src/frameworks/standalone/logger.ts
+function buildStructuredArgs(message, args) {
+  const text = serializeMessage3(message);
+  if (typeof message === "string") {
+    return { text, data: args };
+  }
+  return { text, data: [message, ...args] };
+}
+function serializeMessage3(message) {
+  return serializeLogMessage(message);
+}
+function wrapBaseLogger(baseLogger, config) {
+  return attachLoggerInternals({
+    debug: (message, ...args) => {
+      const { text, data } = buildStructuredArgs(message, args);
+      baseLogger.debug(text, ...data);
+    },
+    info: (message, ...args) => {
+      const { text, data } = buildStructuredArgs(message, args);
+      baseLogger.info(text, ...data);
+    },
+    error: (message, ...args) => {
+      const { text, data } = buildStructuredArgs(message, args);
+      baseLogger.error(text, ...data);
+    },
+    warn: (message, ...args) => {
+      const { text, data } = buildStructuredArgs(message, args);
+      baseLogger.warn(text, ...data);
+    },
+    warning: (message, ...args) => {
+      const { text, data } = buildStructuredArgs(message, args);
+      baseLogger.warning(text, ...data);
+    },
+    success: (message, meta) => {
+      const { text, data } = buildStructuredArgs(message, meta === void 0 ? [] : [meta]);
+      if (meta) {
+        baseLogger.success(text, ...data);
+      } else {
+        baseLogger.success(text);
+      }
+    },
+    critical: (message, meta) => {
+      const { text, data } = buildStructuredArgs(message, meta === void 0 ? [] : [meta]);
+      if (meta) {
+        baseLogger.critical(text, ...data);
+      } else {
+        baseLogger.critical(text);
+      }
+    },
+    table: (message, data) => {
+      baseLogger.table(message, data);
+    },
+    flush: () => baseLogger.flush(),
+    shutdown: () => baseLogger.shutdown(),
+    createStructuredLog: (groupId, initial) => {
+      return baseLogger.createStructuredLog(groupId, initial);
+    },
+    child: (bindings) => {
+      return wrapBaseLogger(baseLogger.child(bindings));
+    }
+  }, baseLogger);
+}
+function createStandaloneLogger(config = {}) {
+  const baseLogger = createBaseLogger(config);
+  return wrapBaseLogger(baseLogger);
+}
+var defaultLoggerInstance = createStandaloneLogger();
+function getDefaultLogger() {
+  return defaultLoggerInstance;
+}
+function createLoggerProxy() {
+  return attachLoggerInternals({
+    debug: (message, ...args) => {
+      getDefaultLogger().debug(message, ...args);
+    },
+    info: (message, ...args) => {
+      getDefaultLogger().info(message, ...args);
+    },
+    error: (message, ...args) => {
+      getDefaultLogger().error(message, ...args);
+    },
+    warn: (message, ...args) => {
+      getDefaultLogger().warn(message, ...args);
+    },
+    warning: (message, ...args) => {
+      getDefaultLogger().warning(message, ...args);
+    },
+    success: (message, meta) => {
+      if (meta === void 0) {
+        getDefaultLogger().success(message);
+        return;
+      }
+      getDefaultLogger().success(message, meta);
+    },
+    critical: (message, meta) => {
+      if (meta === void 0) {
+        getDefaultLogger().critical(message);
+        return;
+      }
+      getDefaultLogger().critical(message, meta);
+    },
+    table: (message, data) => {
+      getDefaultLogger().table(message, data);
+    },
+    flush: () => getDefaultLogger().flush(),
+    shutdown: () => getDefaultLogger().shutdown(),
+    createStructuredLog: (groupId, initial) => {
+      return getDefaultLogger().createStructuredLog(groupId, initial);
+    },
+    child: (bindings) => {
+      return getDefaultLogger().child(bindings);
+    }
+  }, getDefaultLogger());
+}
+function configureDefaultStandaloneLogger(config = {}) {
+  defaultLoggerInstance = createStandaloneLogger(config);
+  return defaultLoggerInstance;
+}
+createLoggerProxy();
+
+// src/frameworks/nestjs/constants.ts
+var BLYP_NEST_LOGGER = /* @__PURE__ */ Symbol("BLYP_NEST_LOGGER");
+var BLYP_NEST_LOGGER_INIT_ERROR = "BlypModule.forRoot() requires createLogger(...) to run before NestFactory.create(AppModule).";
+
+// src/frameworks/nestjs/logger.ts
+var nestLoggerState = null;
+function toStandaloneLoggerConfig(config) {
+  const clientLogging = config.clientLogging === void 0 ? void 0 : config.clientLogging === false ? { enabled: false } : config.clientLogging === true ? { enabled: true } : {
+    enabled: true,
+    path: config.clientLogging.path
+  };
+  return {
+    ...config.level !== void 0 ? { level: config.level } : {},
+    ...config.pretty !== void 0 ? { pretty: config.pretty } : {},
+    ...config.destination !== void 0 ? { destination: config.destination } : {},
+    ...config.logDir !== void 0 ? { logDir: config.logDir } : {},
+    ...config.file !== void 0 ? { file: config.file } : {},
+    ...config.database !== void 0 ? { database: config.database } : {},
+    ...clientLogging !== void 0 ? { clientLogging } : {},
+    ...config.connectors !== void 0 ? { connectors: config.connectors } : {}
+  };
+}
+function createNestLogger(config = {}) {
+  const logger3 = configureDefaultStandaloneLogger(toStandaloneLoggerConfig(config));
+  const shared = resolveServerLogger(config, logger3);
+  nestLoggerState = {
+    ...shared,
+    logger: logger3
+  };
+  return logger3;
+}
+var createLogger = createNestLogger;
+function getNestLoggerStateOrThrow() {
+  if (!nestLoggerState) {
+    throw new Error(BLYP_NEST_LOGGER_INIT_ERROR);
+  }
+  return nestLoggerState;
+}
+
+// src/frameworks/nestjs/helpers.ts
+function resolveNestAdapterType(request, response) {
+  if (isPlainObject(response) && "raw" in response && response.raw !== void 0) {
+    return "fastify";
+  }
+  if (isPlainObject(request) && "raw" in request && request.raw !== void 0) {
+    return "fastify";
+  }
+  return "express";
+}
+function getNestRequestMethod(request) {
+  if (!isPlainObject(request)) {
+    return "GET";
+  }
+  if (typeof request.method === "string") {
+    return request.method;
+  }
+  if (isPlainObject(request.raw) && typeof request.raw.method === "string") {
+    return request.raw.method;
+  }
+  return "GET";
+}
+function getNestRequestHeaders(request) {
+  if (!isPlainObject(request)) {
+    return void 0;
+  }
+  if (isPlainObject(request.headers)) {
+    return request.headers;
+  }
+  if (isPlainObject(request.raw) && isPlainObject(request.raw.headers)) {
+    return request.raw.headers;
+  }
+  return void 0;
+}
+function getNestRequestUrl(request) {
+  if (!isPlainObject(request)) {
+    return "/";
+  }
+  if (typeof request.originalUrl === "string" && request.originalUrl.length > 0) {
+    return request.originalUrl;
+  }
+  if (typeof request.url === "string" && request.url.length > 0) {
+    return request.url;
+  }
+  if (isPlainObject(request.raw) && typeof request.raw.url === "string" && request.raw.url.length > 0) {
+    return request.raw.url;
+  }
+  return "/";
+}
+function getNestRequestPath(request) {
+  return extractPathname(getNestRequestUrl(request));
+}
+async function readNestRequestBody(request) {
+  if (!isPlainObject(request)) {
+    return void 0;
+  }
+  if ("body" in request && request.body !== void 0) {
+    return request.body;
+  }
+  if (isPlainObject(request.raw) && "body" in request.raw && request.raw.body !== void 0) {
+    return request.raw.body;
+  }
+  if (Symbol.asyncIterator in request) {
+    return await readNodeRequestBody(
+      request
+    );
+  }
+  if (isPlainObject(request.raw) && Symbol.asyncIterator in request.raw) {
+    return await readNodeRequestBody(
+      request.raw
+    );
+  }
+  return void 0;
+}
+function setNestRequestStartTime(request, startTime) {
+  if (!isPlainObject(request)) {
+    return;
+  }
+  request.blypStartTime = startTime;
+}
+function getNestRequestStartTime(request) {
+  if (!isPlainObject(request)) {
+    return void 0;
+  }
+  return typeof request.blypStartTime === "number" ? request.blypStartTime : void 0;
+}
+function setNestStructuredLogEmitted(request, emitted) {
+  if (!isPlainObject(request)) {
+    return;
+  }
+  request.blypStructuredLogEmitted = emitted;
+}
+function getNestStructuredLogEmitted(request) {
+  if (!isPlainObject(request)) {
+    return false;
+  }
+  return request.blypStructuredLogEmitted === true;
+}
+function attachNestRequestLogger(request, logger3) {
+  if (!isPlainObject(request)) {
+    return;
+  }
+  request.blypLog = logger3;
+}
+function buildNestRequestLike(request) {
+  const method = getNestRequestMethod(request);
+  const headers = getNestRequestHeaders(request);
+  const path3 = getNestRequestUrl(request);
+  return createRequestLike(method, buildAbsoluteUrl(path3, headers), headers);
+}
+function getNestResponseStatus(response) {
+  if (!isPlainObject(response)) {
+    return 200;
+  }
+  if (typeof response.statusCode === "number") {
+    return response.statusCode;
+  }
+  if (isPlainObject(response.raw) && typeof response.raw.statusCode === "number") {
+    return response.raw.statusCode;
+  }
+  return 200;
+}
+function setRawStatus(target, statusCode) {
+  target.statusCode = statusCode;
+}
+function setNestResponseHeaders(response, headers) {
+  if (!isPlainObject(response)) {
+    return;
+  }
+  if (typeof response.setHeader === "function") {
+    for (const [key, value] of Object.entries(headers)) {
+      response.setHeader(key, value);
+    }
+    return;
+  }
+  if (typeof response.header === "function") {
+    for (const [key, value] of Object.entries(headers)) {
+      response.header(key, value);
+    }
+    return;
+  }
+  if (isPlainObject(response.raw) && typeof response.raw.setHeader === "function") {
+    for (const [key, value] of Object.entries(headers)) {
+      response.raw.setHeader(key, value);
+    }
+  }
+}
+function sendNestStatusResponse(response, statusCode) {
+  if (!isPlainObject(response)) {
+    return;
+  }
+  if (typeof response.status === "function") {
+    const expressResponse = response.status(statusCode);
+    expressResponse.end?.();
+    return;
+  }
+  if (typeof response.code === "function") {
+    const fastifyReply = response.code(statusCode);
+    fastifyReply.send?.();
+    return;
+  }
+  if (isPlainObject(response.raw)) {
+    setRawStatus(response.raw, statusCode);
+    if (typeof response.raw.end === "function") {
+      response.raw.end();
+    }
+    return;
+  }
+  setRawStatus(response, statusCode);
+  if (typeof response.end === "function") {
+    response.end();
+  }
+}
+function getControllerName(context) {
+  const controller = context.getClass();
+  return controller?.name || void 0;
+}
+function getHandlerName(context) {
+  const handler = context.getHandler();
+  return handler?.name || void 0;
+}
+function createNestLoggerContext(options) {
+  const { request, response, executionContext, error } = options;
+  const adapterType = resolveNestAdapterType(request, response);
+  return {
+    request,
+    response,
+    adapterType,
+    executionContext,
+    error,
+    controllerName: executionContext ? getControllerName(executionContext) : void 0,
+    handlerName: executionContext ? getHandlerName(executionContext) : void 0
+  };
+}
+
+// src/frameworks/nestjs/filter.ts
+var BlypNestExceptionFilter = class extends BaseExceptionFilter {
+  constructor(state, httpAdapterHost) {
+    super(httpAdapterHost.httpAdapter);
+    this.state = state;
+  }
+  catch(exception, host) {
+    if (host.getType() === "http") {
+      const http = host.switchToHttp();
+      const request = http.getRequest();
+      const response = http.getResponse();
+      const loggerContext = createNestLoggerContext({
+        request,
+        response,
+        error: exception
+      });
+      const path3 = getNestRequestPath(request);
+      if (getNestStructuredLogEmitted(request)) {
+        super.catch(exception, host);
+        return;
+      }
+      if (!shouldSkipErrorLogging(this.state, path3)) {
+        const statusCode = exception instanceof HttpException ? exception.getStatus() : 500;
+        const responseTime = Math.round(
+          performance.now() - (getNestRequestStartTime(request) ?? performance.now())
+        );
+        emitHttpErrorLog(
+          this.state.logger,
+          this.state.level,
+          buildNestRequestLike(request),
+          path3,
+          statusCode,
+          responseTime,
+          toErrorLike(exception, statusCode),
+          resolveAdditionalProps(this.state, loggerContext),
+          {
+            error: exception
+          }
+        );
+      }
+    }
+    super.catch(exception, host);
+  }
+};
+BlypNestExceptionFilter = __decorateClass([
+  Catch(),
+  __decorateParam(0, Inject(BLYP_NEST_LOGGER))
+], BlypNestExceptionFilter);
+var BlypNestInterceptor = class {
+  constructor(state) {
+    this.state = state;
+  }
+  intercept(context, next) {
+    if (context.getType() !== "http") {
+      return next.handle();
+    }
+    const http = context.switchToHttp();
+    const request = http.getRequest();
+    const response = http.getResponse();
+    const loggerContext = createNestLoggerContext({
+      request,
+      response,
+      executionContext: context
+    });
+    if (!request.blypLog) {
+      attachNestRequestLogger(request, this.state.logger);
+    }
+    if (getNestRequestStartTime(request) === void 0) {
+      setNestRequestStartTime(request, performance.now());
+    }
+    return next.handle().pipe(
+      tap({
+        complete: () => {
+          const path3 = getNestRequestPath(request);
+          const statusCode = getNestResponseStatus(response);
+          const responseTime = Math.round(
+            performance.now() - (getNestRequestStartTime(request) ?? performance.now())
+          );
+          const requestLike = buildNestRequestLike(request);
+          const additionalProps = resolveAdditionalProps(this.state, loggerContext);
+          if (getNestStructuredLogEmitted(request)) {
+            return;
+          }
+          if (isErrorStatus(statusCode)) {
+            if (!shouldSkipErrorLogging(this.state, path3)) {
+              emitHttpErrorLog(
+                this.state.logger,
+                this.state.level,
+                requestLike,
+                path3,
+                statusCode,
+                responseTime,
+                toErrorLike(void 0, statusCode),
+                additionalProps
+              );
+            }
+            return;
+          }
+          if (!shouldSkipAutoLogging(this.state, loggerContext, path3)) {
+            emitHttpRequestLog(
+              this.state.logger,
+              this.state.level,
+              requestLike,
+              path3,
+              statusCode,
+              responseTime,
+              additionalProps
+            );
+          }
+        }
+      })
+    );
+  }
+};
+BlypNestInterceptor = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(BLYP_NEST_LOGGER))
+], BlypNestInterceptor);
+var BlypNestMiddleware = class {
+  constructor(state) {
+    this.state = state;
+  }
+  use(request, response, next) {
+    enterRequestContext();
+    setNestStructuredLogEmitted(request, false);
+    attachNestRequestLogger(
+      request,
+      createRequestScopedLogger(this.state.logger, {
+        resolveStructuredFields: () => {
+          const loggerContext = createNestLoggerContext({
+            request,
+            response
+          });
+          return {
+            method: buildNestRequestLike(request).method,
+            path: getNestRequestPath(request),
+            ...resolveAdditionalProps(this.state, loggerContext)
+          };
+        },
+        onStructuredEmit: () => {
+          setNestStructuredLogEmitted(request, true);
+        }
+      })
+    );
+    setNestRequestStartTime(request, performance.now());
+    const path3 = getNestRequestPath(request);
+    const method = getNestRequestMethod(request).toUpperCase();
+    if (this.state.resolvedClientLogging && method === "POST" && path3 === this.state.ingestionPath) {
+      void this.handleClientLogRequest(request, response, next);
+      return;
+    }
+    next();
+  }
+  async handleClientLogRequest(request, response, next) {
+    try {
+      const body = await readNestRequestBody(request);
+      const result = await handleClientLogIngestion({
+        config: this.state,
+        ctx: createNestLoggerContext({
+          request,
+          response
+        }),
+        request: buildNestRequestLike(request),
+        body,
+        deliveryPath: this.state.ingestionPath
+      });
+      if (result.headers) {
+        setNestResponseHeaders(response, result.headers);
+      }
+      sendNestStatusResponse(response, result.status);
+    } catch (error) {
+      next(error);
+    }
+  }
+};
+BlypNestMiddleware = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(BLYP_NEST_LOGGER))
+], BlypNestMiddleware);
+
+// src/frameworks/nestjs/module.ts
+var BlypModule = class {
+  static forRoot() {
+    return {
+      global: true,
+      module: BlypModule,
+      providers: [
+        BlypNestMiddleware,
+        {
+          provide: BLYP_NEST_LOGGER,
+          useFactory: () => getNestLoggerStateOrThrow()
+        },
+        {
+          provide: APP_INTERCEPTOR,
+          useClass: BlypNestInterceptor
+        },
+        {
+          provide: APP_FILTER,
+          useClass: BlypNestExceptionFilter
+        }
+      ],
+      exports: [BLYP_NEST_LOGGER]
+    };
+  }
+  configure(consumer) {
+    consumer.apply(BlypNestMiddleware).forRoutes({ path: "*", method: RequestMethod.ALL });
+  }
+};
+BlypModule = __decorateClass([
+  Global(),
+  Module({})
+], BlypModule);
+
+export { BlypModule, createLogger, createNestLogger };
+//# sourceMappingURL=nestjs.mjs.map
+//# sourceMappingURL=nestjs.mjs.map