@brizz/sdk 0.1.29 → 0.1.30

package/dist/preload.cjs

@@ -1,2455 +1,17 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/internal/logger.ts
-var import_api = require("@opentelemetry/api");
-var import_pino = __toESM(require("pino"), 1);
-var DEFAULT_LOG_LEVEL = 2 /* WARN */;
-var PinoLogger = class {
-  _level = DEFAULT_LOG_LEVEL;
-  _pinoLogger = null;
-  constructor() {
-    const envLevel = this.getLogLevelFromEnv();
-    this._level = envLevel;
-  }
-  /**
-   * Lazy initialization of Pino logger to ensure it's created AFTER Jest spies
-   * are set up during tests. This prevents the pino-pretty transport from
-   * bypassing stdout/stderr spies.
-   */
-  ensurePinoLogger() {
-    if (!this._pinoLogger) {
-      this._pinoLogger = (0, import_pino.default)({
-        name: "Brizz",
-        level: this.logLevelToPino(this._level),
-        // Disable transport in test environment to allow proper spy capture
-        transport: this.isProduction() || this.isTest() ? void 0 : {
-          target: "pino-pretty",
-          options: {
-            singleLine: true,
-            colorize: true,
-            translateTime: "HH:MM:ss",
-            ignore: "pid,hostname",
-            messageFormat: "[{name}] {msg}"
-          }
-        }
-      });
-    }
-    return this._pinoLogger;
-  }
-  isProduction() {
-    return process.env["NODE_ENV"] === "production";
-  }
-  isTest() {
-    return process.env["NODE_ENV"] === "test";
-  }
-  getLogLevelFromEnv() {
-    const envLevel = process.env["BRIZZ_LOG_LEVEL"];
-    return envLevel ? parseLogLevel(envLevel) : DEFAULT_LOG_LEVEL;
-  }
-  logLevelToPino(level) {
-    switch (level) {
-      case 4 /* DEBUG */:
-        return "debug";
-      case 3 /* INFO */:
-        return "info";
-      case 2 /* WARN */:
-        return "warn";
-      case 1 /* ERROR */:
-        return "error";
-      default:
-        return "silent";
-    }
-  }
-  formatMeta(meta) {
-    if (meta.length === 0) {
-      return {};
-    }
-    if (meta.length === 1 && typeof meta[0] === "object" && meta[0] !== null) {
-      return meta[0];
-    }
-    return { metadata: meta };
-  }
-  setLevel(level) {
-    this._level = level;
-    if (this._pinoLogger) {
-      this._pinoLogger.level = this.logLevelToPino(level);
-    }
-  }
-  getLevel() {
-    return this._level;
-  }
-  debug = (msg, ...meta) => {
-    if (this._level >= 4 /* DEBUG */) {
-      this.ensurePinoLogger().debug(this.formatMeta(meta), msg);
-    }
-  };
-  info = (msg, ...meta) => {
-    if (this._level >= 3 /* INFO */) {
-      this.ensurePinoLogger().info(this.formatMeta(meta), msg);
-    }
-  };
-  warn = (msg, ...meta) => {
-    if (this._level >= 2 /* WARN */) {
-      this.ensurePinoLogger().warn(this.formatMeta(meta), msg);
-    }
-  };
-  error = (msg, ...meta) => {
-    if (this._level >= 1 /* ERROR */) {
-      this.ensurePinoLogger().error(this.formatMeta(meta), msg);
-    }
-  };
-};
-function parseLogLevel(level) {
-  if (!level) {
-    return DEFAULT_LOG_LEVEL;
-  }
-  const normalizedLevel = level.toLowerCase().trim();
-  switch (normalizedLevel) {
-    case "debug":
-      return 4 /* DEBUG */;
-    case "info":
-      return 3 /* INFO */;
-    case "warn":
-    case "warning":
-      return 2 /* WARN */;
-    case "error":
-      return 1 /* ERROR */;
-    case "none":
-    case "off":
-    case "silent":
-      return 0 /* NONE */;
-    default: {
-      const numLevel = Number.parseInt(normalizedLevel, 10);
-      if (!Number.isNaN(numLevel) && numLevel >= 0 && numLevel <= 4) {
-        return numLevel;
-      }
-      return DEFAULT_LOG_LEVEL;
-    }
-  }
-}
-var logger = new PinoLogger();
-function setLogLevel(level) {
-  const resolvedLevel = typeof level === "string" ? parseLogLevel(level) : level;
-  logger.setLevel(resolvedLevel);
-}
-
-// src/internal/sdk.ts
-var import_resources3 = require("@opentelemetry/resources");
-var import_sdk_node = require("@opentelemetry/sdk-node");
-
-// src/internal/dsn.ts
-var PLACEHOLDER_SERVICE = "<service-name>";
-var SERVICE_NAME_HEADER = "X-Brizz-Service-Name";
-function parseDSN(dsn) {
-  let parsed;
-  try {
-    parsed = new globalThis.URL(dsn);
-  } catch {
-    return null;
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || !parsed.username || !parsed.host) {
-    return null;
-  }
-  const scheme = parsed.protocol === "https:" ? "https" : "http";
-  let service;
-  try {
-    service = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
-  } catch {
-    return null;
-  }
-  if (service === "" || service === PLACEHOLDER_SERVICE) {
-    return null;
-  }
-  return {
-    scheme,
-    host: parsed.host,
-    bearer: decodeURIComponent(parsed.username),
-    service,
-    baseUrl: `${scheme}://${parsed.host}`
-  };
-}
-
-// src/internal/config.ts
-function resolveConfig(options) {
-  const envLogLevel = process.env["BRIZZ_LOG_LEVEL"] || options.logLevel?.toString() || DEFAULT_LOG_LEVEL.toString();
-  let resolvedLogLevel;
-  if (envLogLevel) {
-    resolvedLogLevel = parseLogLevel(envLogLevel);
-  } else if (typeof options.logLevel === "string") {
-    resolvedLogLevel = parseLogLevel(options.logLevel);
-  } else {
-    resolvedLogLevel = options.logLevel || DEFAULT_LOG_LEVEL;
-  }
-  setLogLevel(resolvedLogLevel);
-  let maskingStatus;
-  if (options.masking === true) {
-    maskingStatus = "enabled";
-  } else if (options.masking === false) {
-    maskingStatus = "disabled";
-  } else if (typeof options.masking === "object") {
-    maskingStatus = "custom";
-  } else {
-    maskingStatus = "default-disabled";
-  }
-  logger.debug("Starting configuration resolution", {
-    appName: options.appName,
-    baseUrl: options.baseUrl,
-    hasApiKey: !!options.apiKey,
-    dsnProvided: !!(process.env["BRIZZ_DSN"] || options.dsn),
-    disableBatch: options.disableBatch,
-    logLevel: resolvedLogLevel,
-    headersCount: Object.keys(options.headers || {}).length,
-    masking: maskingStatus
-  });
-  let resolvedMasking;
-  if (options.masking === true) {
-    resolvedMasking = {
-      spanMasking: {},
-      eventMasking: {}
-    };
-  } else if (options.masking && typeof options.masking === "object") {
-    resolvedMasking = options.masking;
-  }
-  const resolvedConfig = {
-    ...options,
-    appName: process.env["BRIZZ_APP_NAME"] || options.appName || "unknown-app",
-    appVersion: process.env["BRIZZ_APP_VERSION"] || options.appVersion,
-    baseUrl: process.env["BRIZZ_BASE_URL"] || options.baseUrl || "https://telemetry.brizz.dev",
-    headers: { ...options.headers },
-    apiKey: process.env["BRIZZ_API_KEY"] || options.apiKey,
-    disableBatch: process.env["BRIZZ_DISABLE_BATCH"] === "true" || !!options.disableBatch,
-    disableSpanExporter: process.env["BRIZZ_DISABLE_SPAN_EXPORTER"] === "true" || !!options.disableSpanExporter,
-    environment: process.env["BRIZZ_ENVIRONMENT"] || options.environment,
-    logLevel: resolvedLogLevel,
-    masking: resolvedMasking
-  };
-  const dsnInput = process.env["BRIZZ_DSN"] || options.dsn;
-  let parsedDSN = null;
-  if (dsnInput) {
-    const kwargConflicts = [];
-    if (options.apiKey !== void 0) {
-      kwargConflicts.push("apiKey");
-    }
-    if (options.baseUrl !== void 0) {
-      kwargConflicts.push("baseUrl");
-    }
-    if (options.appName !== void 0) {
-      kwargConflicts.push("appName");
-    }
-    if (kwargConflicts.length > 0) {
-      throw new Error(
-        `dsn cannot be combined with kwargs ${kwargConflicts.join(", ")}. The DSN bundles bearer, gateway URL, and service name \u2014 choose one configuration style.`
-      );
-    }
-    const envConflicts = ["BRIZZ_API_KEY", "BRIZZ_BASE_URL", "BRIZZ_APP_NAME"].filter(
-      (name) => process.env[name] !== void 0
-    );
-    if (envConflicts.length > 0) {
-      logger.warn(
-        `Ignoring ${envConflicts.join(", ")} \u2014 dsn / BRIZZ_DSN takes precedence.`
-      );
-    }
-    resolvedConfig.apiKey = void 0;
-    resolvedConfig.baseUrl = "https://telemetry.brizz.dev";
-    resolvedConfig.appName = "unknown-app";
-    parsedDSN = parseDSN(dsnInput);
-    if (parsedDSN) {
-      resolvedConfig.appName = parsedDSN.service;
-      resolvedConfig.baseUrl = parsedDSN.baseUrl;
-      resolvedConfig.apiKey = parsedDSN.bearer;
-    }
-  } else if (resolvedConfig.apiKey) {
-    resolvedConfig.headers["Authorization"] = `Bearer ${resolvedConfig.apiKey}`;
-  }
-  if (process.env["BRIZZ_HEADERS"]) {
-    try {
-      const envHeaders = JSON.parse(process.env["BRIZZ_HEADERS"]);
-      Object.assign(resolvedConfig.headers, envHeaders);
-      logger.debug("Added headers from environment variable", {
-        headers: Object.keys(envHeaders)
-      });
-    } catch (error) {
-      logger.error("Failed to parse BRIZZ_HEADERS environment variable", { error });
-      throw new Error("Invalid JSON in BRIZZ_HEADERS environment variable", { cause: error });
-    }
-  }
-  if (dsnInput) {
-    const authHeaderKeys = /* @__PURE__ */ new Set(["authorization", SERVICE_NAME_HEADER.toLowerCase()]);
-    resolvedConfig.headers = Object.fromEntries(
-      Object.entries(resolvedConfig.headers).filter(
-        ([key]) => !authHeaderKeys.has(key.toLowerCase())
-      )
-    );
-    if (parsedDSN) {
-      resolvedConfig.headers["Authorization"] = `Bearer ${parsedDSN.bearer}`;
-      resolvedConfig.headers[SERVICE_NAME_HEADER] = parsedDSN.service;
-    }
-  }
-  logger.debug("Configuration resolved with environment variables", {
-    appName: resolvedConfig.appName,
-    baseUrl: resolvedConfig.baseUrl,
-    hasApiKey: !!resolvedConfig.apiKey,
-    dsnProvided: !!dsnInput,
-    disableBatch: resolvedConfig.disableBatch,
-    envOverrides: {
-      hasEnvApiKey: !!process.env["BRIZZ_API_KEY"],
-      hasEnvBaseUrl: !!process.env["BRIZZ_BASE_URL"],
-      hasEnvDsn: !!process.env["BRIZZ_DSN"],
-      hasEnvBatch: !!process.env["BRIZZ_DISABLE_BATCH"],
-      hasEnvHeaders: !!process.env["BRIZZ_HEADERS"]
-    }
-  });
-  return resolvedConfig;
-}
-
-// src/internal/constants.ts
-var BRIZZ_SDK_VERSION = "brizz.sdk.version";
-var BRIZZ_SDK_LANGUAGE = "brizz.sdk.language";
-var SDK_LANGUAGE = "typescript";
-
-// src/internal/instrumentation/registry.ts
-var import_instrumentation_anthropic = require("@traceloop/instrumentation-anthropic");
-var import_instrumentation_bedrock = require("@traceloop/instrumentation-bedrock");
-var import_instrumentation_chromadb = require("@traceloop/instrumentation-chromadb");
-var import_instrumentation_cohere = require("@traceloop/instrumentation-cohere");
-var import_instrumentation_llamaindex = require("@traceloop/instrumentation-llamaindex");
-var import_instrumentation_openai = require("@traceloop/instrumentation-openai");
-var import_instrumentation_pinecone = require("@traceloop/instrumentation-pinecone");
-var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
-var import_instrumentation_together = require("@traceloop/instrumentation-together");
-var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
-
-// src/internal/instrumentation/mcp/instrumentation.ts
-var import_openinference_instrumentation_mcp = require("@arizeai/openinference-instrumentation-mcp");
-var import_api7 = require("@opentelemetry/api");
-var import_instrumentation = require("@opentelemetry/instrumentation");
-
-// src/internal/instrumentation/mcp/patches/protocol.ts
-var import_api6 = require("@opentelemetry/api");
-
-// src/internal/instrumentation/mcp/schemas.ts
-var import_api2 = require("@opentelemetry/api");
+"use strict"; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-// src/internal/instrumentation/mcp/semantic-conventions.ts
-var MCP_TOOL_NAME = "mcp.tool.name";
-var MCP_TOOL_ARGUMENTS = "mcp.tool.arguments";
-var MCP_TOOL_RESULT = "mcp.tool.result";
-var MCP_COMPONENT_TYPE = "mcp.component.type";
-var MCP_COMPONENT_TOOL = "tool";
-var MCP_COMPONENT_TOOL_SCHEMA = "tool_schema";
-var MCP_TOOL_SCHEMA_PARAMETERS = "mcp.tool.schema.parameters";
-var MCP_TOOL_SCHEMA_OUTPUT = "mcp.tool.schema.output";
-var MCP_TOOL_DESCRIPTION = "mcp.tool.description";
-var SPAN_NAME_TOOL_REGISTER = "mcp.tool.register";
-var MCP_METHOD_NAME = "mcp.method.name";
-var MCP_REQUEST_ID = "mcp.request.id";
-var MCP_SESSION_ID = "mcp.session.id";
-var MCP_PROTOCOL_VERSION = "mcp.protocol.version";
-var MCP_RESOURCE_URI = "mcp.resource.uri";
-var RPC_SYSTEM = "rpc.system";
-var RPC_SYSTEM_MCP = "mcp";
-var RPC_RESPONSE_STATUS_CODE = "rpc.response.status_code";
-var GEN_AI_TOOL_NAME = "gen_ai.tool.name";
-var GEN_AI_PROMPT_NAME = "gen_ai.prompt.name";
-var GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
-var GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
-var NETWORK_TRANSPORT = "network.transport";
-var ERROR_TYPE = "error.type";
-var ERROR_TYPE_TOOL = "tool_error";
-var JSONRPC_REQUEST_ID = "jsonrpc.request.id";
-var SPAN_NAME_TOOLS_CALL = "tools/call";
-var MAX_ATTRIBUTE_LENGTH = 32 * 1024;
-var TRUNCATION_SUFFIX = "\u2026(truncated)";
-var METHOD_TOOLS_CALL = "tools/call";
-var METHOD_TOOLS_LIST = "tools/list";
-var METHOD_RESOURCES_READ = "resources/read";
-var METHOD_PROMPTS_GET = "prompts/get";
-var METHOD_INITIALIZE = "initialize";
-
-// src/internal/instrumentation/mcp/schemas.ts
-var _MAX_SCHEMA_ATTR_BYTES = 4e3;
-function truncateSchemaAttr(value) {
-  if (value.length <= _MAX_SCHEMA_ATTR_BYTES) {
-    return value;
-  }
-  return `{"_truncated":true,"original_length":${value.length}}`;
-}
-function safeStringify(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "";
-  }
-}
-function emitSchemaSpansFromListResponse(result, transportSessionId, tracer) {
-  if (!transportSessionId) {
-    return;
-  }
-  const tools = extractTools(result);
-  if (tools === void 0) {
-    return;
-  }
-  for (const tool of tools) {
-    const name = typeof tool.name === "string" ? tool.name : void 0;
-    if (!name) {
-      continue;
-    }
-    const span = tracer.startSpan(`${SPAN_NAME_TOOL_REGISTER} ${name}`, {
-      kind: import_api2.SpanKind.INTERNAL
-    });
-    try {
-      stampSchemaAttributes(span, name, transportSessionId, tool);
-      span.setStatus({ code: import_api2.SpanStatusCode.OK });
-    } finally {
-      span.end();
-    }
-  }
-}
-function stampSchemaAttributes(span, toolName, transportSessionId, tool) {
-  if (!span.isRecording()) {
-    logger.warn(
-      `Brizz MCP: schema span is not recording; dropping attributes for ${toolName}`
-    );
-    return;
-  }
-  const description = typeof tool.description === "string" ? tool.description : "";
-  const parameters = truncateSchemaAttr(safeStringify(tool.inputSchema));
-  const outputSchema = tool.outputSchema !== void 0 && tool.outputSchema !== null ? truncateSchemaAttr(safeStringify(tool.outputSchema)) : "";
-  span.setAttribute(RPC_SYSTEM, RPC_SYSTEM_MCP);
-  span.setAttribute(MCP_COMPONENT_TYPE, MCP_COMPONENT_TOOL_SCHEMA);
-  span.setAttribute(MCP_SESSION_ID, transportSessionId);
-  span.setAttribute(MCP_TOOL_NAME, toolName);
-  span.setAttribute(MCP_TOOL_SCHEMA_PARAMETERS, parameters);
-  span.setAttribute(MCP_TOOL_SCHEMA_OUTPUT, outputSchema);
-  span.setAttribute(MCP_TOOL_DESCRIPTION, description);
-}
-function extractTools(result) {
-  if (!result || typeof result !== "object") {
-    return void 0;
-  }
-  const tools = result.tools;
-  if (!Array.isArray(tools)) {
-    return void 0;
-  }
-  return tools.filter(
-    (t) => t !== null && typeof t === "object"
-  );
-}
 
-// src/internal/instrumentation/mcp/session.ts
-var import_api4 = require("@opentelemetry/api");
+var _chunkNUTJMVD4cjs = require('./chunk-NUTJMVD4.cjs');
 
-// src/internal/semantic-conventions.ts
-var import_api3 = require("@opentelemetry/api");
-var BRIZZ = "brizz";
-var PROPERTIES = "properties";
-var SESSION_ID = "session.id";
-var PROPERTIES_CONTEXT_KEY = (0, import_api3.createContextKey)(PROPERTIES);
-var SESSION_OBJECT_CONTEXT_KEY = (0, import_api3.createContextKey)("brizz.session.object");
-var INTERRUPT_TOOLS = "brizz.internal.interrupt";
-var INTERNAL_EVENT_PREFIX = "brizz.internal.";
 
-// src/internal/instrumentation/mcp/session.ts
-function stampAndPropagateSession(span, sessionId, baseContext = import_api4.context.active()) {
-  if (!sessionId) {
-    return { context: baseContext, sessionId: null };
-  }
-  if (span.isRecording()) {
-    try {
-      span.setAttribute(`${BRIZZ}.${SESSION_ID}`, sessionId);
-    } catch (error) {
-      logger.warn(
-        `Brizz MCP: failed to stamp session id on span: ${String(error)}`
-      );
-    }
-  }
-  try {
-    const prev = baseContext.getValue(PROPERTIES_CONTEXT_KEY);
-    const merged = prev ? { ...prev, [SESSION_ID]: sessionId } : { [SESSION_ID]: sessionId };
-    return {
-      context: baseContext.setValue(PROPERTIES_CONTEXT_KEY, merged),
-      sessionId
-    };
-  } catch (error) {
-    logger.warn(`Brizz MCP: failed to attach session context: ${String(error)}`);
-    return { context: baseContext, sessionId };
-  }
-}
 
-// src/internal/instrumentation/mcp/patches/attributes.ts
-var import_api5 = require("@opentelemetry/api");
-function deriveSpanName(method, params) {
-  try {
-    if (method === METHOD_TOOLS_CALL) {
-      const name = typeof params?.["name"] === "string" ? params["name"] : "";
-      return name ? `${SPAN_NAME_TOOLS_CALL} ${name}` : SPAN_NAME_TOOLS_CALL;
-    }
-    if (method === METHOD_RESOURCES_READ) {
-      const uri = typeof params?.["uri"] === "string" ? params["uri"] : "";
-      return uri ? `${METHOD_RESOURCES_READ} ${uri}` : METHOD_RESOURCES_READ;
-    }
-    if (method === METHOD_PROMPTS_GET) {
-      const name = typeof params?.["name"] === "string" ? params["name"] : "";
-      return name ? `${METHOD_PROMPTS_GET} ${name}` : METHOD_PROMPTS_GET;
-    }
-    return method;
-  } catch {
-    return method || "mcp";
-  }
-}
-function applyBaseAttributes(span, request) {
-  span.setAttribute(RPC_SYSTEM, RPC_SYSTEM_MCP);
-  if (request.method) {
-    span.setAttribute(MCP_METHOD_NAME, request.method);
-  }
-  if (request.id !== void 0 && request.id !== null) {
-    const id = String(request.id);
-    span.setAttribute(MCP_REQUEST_ID, id);
-    span.setAttribute(JSONRPC_REQUEST_ID, id);
-  }
-}
-function applyClientRequestAttributes(span, request, transportName) {
-  applyBaseAttributes(span, request);
-  applyMethodSpecificRequestAttributes(span, request);
-  if (transportName) {
-    const transport = normalizeTransport(transportName);
-    if (transport) {
-      span.setAttribute(NETWORK_TRANSPORT, transport);
-    }
-  }
-}
-function applyServerRequestAttributes(span, request, protocol) {
-  applyBaseAttributes(span, request);
-  applyMethodSpecificRequestAttributes(span, request);
-  if (request.method === METHOD_TOOLS_CALL) {
-    const args = request.params?.["arguments"];
-    if (args !== void 0) {
-      span.setAttribute(MCP_TOOL_ARGUMENTS, serializeForAttribute(args));
-    }
-  }
-  const sessionId = protocol.sessionId ?? protocol._transport?.sessionId;
-  if (sessionId) {
-    span.setAttribute(MCP_SESSION_ID, String(sessionId));
-  }
-}
-function applyMethodSpecificRequestAttributes(span, request) {
-  const params = request.params ?? {};
-  switch (request.method) {
-    case METHOD_TOOLS_CALL: {
-      const name = typeof params["name"] === "string" ? params["name"] : "";
-      if (name) {
-        span.setAttribute(MCP_TOOL_NAME, name);
-        span.setAttribute(GEN_AI_TOOL_NAME, name);
-      }
-      span.setAttribute(MCP_COMPONENT_TYPE, MCP_COMPONENT_TOOL);
-      span.setAttribute(GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_EXECUTE_TOOL);
-      break;
-    }
-    case METHOD_RESOURCES_READ: {
-      const uri = typeof params["uri"] === "string" ? params["uri"] : "";
-      if (uri) {
-        span.setAttribute(MCP_RESOURCE_URI, uri);
-      }
-      break;
-    }
-    case METHOD_PROMPTS_GET: {
-      const name = typeof params["name"] === "string" ? params["name"] : "";
-      if (name) {
-        span.setAttribute(GEN_AI_PROMPT_NAME, name);
-      }
-      break;
-    }
-    default:
-      break;
-  }
-}
-function applyResultAttributes(span, method, result) {
-  if (method === METHOD_INITIALIZE && result && typeof result === "object") {
-    const protocolVersion = result["protocolVersion"];
-    if (typeof protocolVersion === "string") {
-      span.setAttribute(MCP_PROTOCOL_VERSION, protocolVersion);
-    }
-    return;
-  }
-  if (method !== METHOD_TOOLS_CALL) {
-    return;
-  }
-  const obj = result && typeof result === "object" ? result : null;
-  const content = obj?.["content"] ?? result;
-  span.setAttribute(MCP_TOOL_RESULT, serializeForAttribute(content));
-  if (obj && obj["isError"] === true) {
-    span.setAttribute(ERROR_TYPE, ERROR_TYPE_TOOL);
-    const message = extractToolErrorMessage(obj);
-    span.setStatus({ code: import_api5.SpanStatusCode.ERROR, message });
-  }
-}
-function applyErrorAttributes(span, err) {
-  const error = err;
-  const code = error?.code;
-  if (typeof code === "number") {
-    span.setAttribute(RPC_RESPONSE_STATUS_CODE, code);
-    span.setAttribute(ERROR_TYPE, String(code));
-  } else if (error?.name === "AbortError") {
-    span.setAttribute(ERROR_TYPE, "cancelled");
-  } else if (error?.name === "TimeoutError") {
-    span.setAttribute(ERROR_TYPE, "timeout");
-  } else {
-    span.setAttribute(
-      ERROR_TYPE,
-      error?.constructor?.name || error?.name || "Error"
-    );
-  }
-  try {
-    span.recordException(error);
-  } catch {
-  }
-  span.setStatus({
-    code: import_api5.SpanStatusCode.ERROR,
-    message: typeof error?.message === "string" ? error.message : void 0
-  });
-}
-function serializeForAttribute(value) {
-  const raw = rawSerialize(value);
-  if (raw.length <= MAX_ATTRIBUTE_LENGTH) {
-    return raw;
-  }
-  return raw.slice(0, MAX_ATTRIBUTE_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
-}
-function rawSerialize(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    try {
-      if (value === null || value === void 0) {
-        return "";
-      }
-      const tag = Object.prototype.toString.call(value);
-      return typeof value.toString === "function" ? (
-        // eslint-disable-next-line @typescript-eslint/no-base-to-string
-        String(value)
-      ) : tag;
-    } catch {
-      return "";
-    }
-  }
-}
-function extractToolErrorMessage(result) {
-  const content = result["content"];
-  if (Array.isArray(content)) {
-    for (const item of content) {
-      if (item && typeof item === "object") {
-        const text = item["text"];
-        if (typeof text === "string") {
-          return text;
-        }
-      }
-    }
-  }
-  return void 0;
-}
-function normalizeTransport(ctorName) {
-  const name = ctorName.toLowerCase();
-  if (name.includes("stdio")) {
-    return "stdio";
-  }
-  if (name.includes("sse")) {
-    return "sse";
-  }
-  if (name.includes("streamablehttp") || name.includes("http")) {
-    return "http";
-  }
-  return null;
-}
-
-// src/internal/instrumentation/mcp/patches/protocol.ts
-var PATCHED_FLAG = /* @__PURE__ */ Symbol("brizz.mcp.protocol-patched");
-function patchProtocolPrototype(prototype, tracer) {
-  if (!prototype || typeof prototype !== "object") {
-    return false;
-  }
-  const proto = prototype;
-  if (proto[PATCHED_FLAG]) {
-    logger.debug("Brizz MCP: Protocol.prototype already patched, skipping");
-    return false;
-  }
-  const originalRequest = proto["request"];
-  const originalOnRequest = proto["_onrequest"];
-  if (typeof originalRequest === "function") {
-    proto["request"] = wrapRequest(originalRequest, tracer);
-  } else {
-    logger.debug(
-      "Brizz MCP: Protocol.prototype.request missing \u2014 skipping CLIENT patch"
-    );
-  }
-  if (typeof originalOnRequest === "function") {
-    proto["_onrequest"] = wrapOnRequest(
-      originalOnRequest,
-      tracer
-    );
-  } else {
-    logger.debug(
-      "Brizz MCP: Protocol.prototype._onrequest missing \u2014 skipping SERVER patch"
-    );
-  }
-  proto[PATCHED_FLAG] = true;
-  return true;
-}
-function wrapRequest(original, tracer) {
-  return function wrappedRequest(...args) {
-    const request = args[0];
-    if (!request || typeof request !== "object" || !request.method) {
-      return original.apply(this, args);
-    }
-    const span = safeStartClientSpan(tracer, request, this);
-    if (!span) {
-      return original.apply(this, args);
-    }
-    return executeAroundSpan(span, request.method, () => {
-      const ctx = import_api6.trace.setSpan(import_api6.context.active(), span);
-      return import_api6.context.with(ctx, () => original.apply(this, args));
-    });
-  };
-}
-function wrapOnRequest(original, tracer) {
-  return function wrappedOnRequest(...args) {
-    const request = args[0];
-    if (!request || typeof request !== "object" || !request.method) {
-      return original.apply(this, args);
-    }
-    const handlers = this._requestHandlers;
-    if (!handlers || typeof handlers.get !== "function") {
-      return original.apply(this, args);
-    }
-    const method = request.method;
-    const handler = handlers.get(method) ?? this.fallbackRequestHandler;
-    if (!handler) {
-      return original.apply(this, args);
-    }
-    const started = safeStartServerSpan(tracer, request, this);
-    if (!started) {
-      return original.apply(this, args);
-    }
-    const { span, spanCtx } = started;
-    const transportSessionId = this.sessionId ?? this._transport?.sessionId;
-    const postResult = method === METHOD_TOOLS_LIST ? (result) => {
-      try {
-        emitSchemaSpansFromListResponse(result, transportSessionId, tracer);
-      } catch (error) {
-        logger.warn(
-          `Brizz MCP: failed to emit tools/list schema spans: ${String(error)}`
-        );
-      }
-    } : void 0;
-    const wrappedHandler = (req, extra) => import_api6.context.with(
-      spanCtx,
-      () => executeHandler(span, method, handler, req, extra, postResult)
-    );
-    const hadEntry = handlers.has(method);
-    const prev = handlers.get(method);
-    handlers.set(method, wrappedHandler);
-    const usedFallback = !hadEntry && this.fallbackRequestHandler === handler;
-    const fallbackPrev = usedFallback ? this.fallbackRequestHandler : void 0;
-    if (usedFallback) {
-      this.fallbackRequestHandler = wrappedHandler;
-    }
-    try {
-      return original.apply(this, args);
-    } finally {
-      if (hadEntry) {
-        handlers.set(method, prev);
-      } else {
-        handlers.delete(method);
-      }
-      if (usedFallback) {
-        this.fallbackRequestHandler = fallbackPrev;
-      }
-    }
-  };
-}
-function executeAroundSpan(span, method, run, postResult) {
-  let result;
-  try {
-    result = run();
-  } catch (error) {
-    safeApplyErrorAttributes(span, error);
-    safeEnd(span);
-    throw error;
-  }
-  if (!isThenable(result)) {
-    safeApplyResultAttributes(span, method, result);
-    if (postResult) {
-      postResult(result);
-    }
-    safeEnd(span);
-    return result;
-  }
-  return result.then(
-    (value) => {
-      safeApplyResultAttributes(span, method, value);
-      if (postResult) {
-        postResult(value);
-      }
-      safeEnd(span);
-      return value;
-    },
-    (error) => {
-      safeApplyErrorAttributes(span, error);
-      safeEnd(span);
-      throw error;
-    }
-  );
-}
-function executeHandler(span, method, handler, req, extra, postResult) {
-  return executeAroundSpan(span, method, () => handler(req, extra), postResult);
-}
-function safeStartClientSpan(tracer, request, protocol) {
-  try {
-    const spanName = deriveSpanName(request.method, request.params);
-    const span = tracer.startSpan(spanName, { kind: import_api6.SpanKind.CLIENT });
-    applyClientRequestAttributes(
-      span,
-      request,
-      protocol._transport?.constructor?.name
-    );
-    return span;
-  } catch (error) {
-    logger.debug(`Brizz MCP: failed to open CLIENT span: ${String(error)}`);
-    return null;
-  }
-}
-function safeStartServerSpan(tracer, request, protocol) {
-  try {
-    const parentCtx = extractParentContext(request);
-    const spanName = deriveSpanName(request.method, request.params);
-    const span = tracer.startSpan(
-      spanName,
-      { kind: import_api6.SpanKind.SERVER },
-      parentCtx
-    );
-    applyServerRequestAttributes(span, request, protocol);
-    const sessionId = protocol.sessionId ?? protocol._transport?.sessionId;
-    const { context: sessCtx } = stampAndPropagateSession(span, sessionId, parentCtx);
-    return { span, spanCtx: import_api6.trace.setSpan(sessCtx, span) };
-  } catch (error) {
-    logger.debug(`Brizz MCP: failed to open SERVER span: ${String(error)}`);
-    return null;
-  }
-}
-function extractParentContext(request) {
-  try {
-    const meta = request.params?._meta;
-    if (meta && typeof meta === "object") {
-      return import_api6.propagation.extract(import_api6.context.active(), meta);
-    }
-  } catch (error) {
-    logger.debug(
-      `Brizz MCP: failed to extract parent context from _meta: ${String(error)}`
-    );
-  }
-  return import_api6.context.active();
-}
-function isThenable(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
-}
-function safeApplyResultAttributes(span, method, value) {
-  try {
-    applyResultAttributes(span, method, value);
-  } catch (error) {
-    logger.debug(
-      `Brizz MCP: failed to apply result attributes: ${String(error)}`
-    );
-  }
-}
-function safeApplyErrorAttributes(span, err) {
-  try {
-    applyErrorAttributes(span, err);
-  } catch (error) {
-    logger.debug(
-      `Brizz MCP: failed to apply error attributes: ${String(error)}`
-    );
-  }
-}
-function safeEnd(span) {
-  try {
-    span.end();
-  } catch (error) {
-    logger.debug(`Brizz MCP: failed to end span: ${String(error)}`);
-  }
-}
-
-// src/internal/version.ts
-function getSDKVersion() {
-  return "0.1.29";
-}
-
-// src/internal/instrumentation/mcp/version.ts
-var INSTRUMENTATION_NAME = "@brizz/sdk/mcp";
-var INSTRUMENTATION_VERSION = getSDKVersion();
-
-// src/internal/instrumentation/mcp/instrumentation.ts
-var PROTOCOL_MODULE_NAME = "@modelcontextprotocol/sdk/shared/protocol.js";
-var PROTOCOL_SUPPORTED_VERSIONS = [">=1.0.0 <2"];
-var MCPInstrumentation = class extends import_openinference_instrumentation_mcp.MCPInstrumentation {
-  /**
-   * Dedicated Brizz-named tracer for our SERVER + CLIENT spans.
-   *
-   * Why a separate tracer from the parent class's one: Arize's inherited
-   * transport patches don't emit spans (they only inject propagation
-   * headers), so using our own tracer here keeps Brizz spans attributed to
-   * `@brizz/sdk/mcp` in the dashboard. The parent's `tracer` is a
-   * `protected get` (no setter), so fighting it with assignment is the
-   * wrong tool.
-   */
-  brizzTracer;
-  constructor(_config) {
-    super({ instrumentationConfig: _config?.instrumentationConfig });
-    this.brizzTracer = import_api7.trace.getTracer(INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION);
-  }
-  /**
-   * Extend `super.init()` with our protocol-layer module definition.
-   *
-   * Arize's `init()` returns definitions for the six transport modules
-   * (SSE client/server, stdio client/server, streamable-HTTP client/server)
-   * whose `send`/`start` methods get patched for W3C trace-context
-   * injection. We append one more: `@modelcontextprotocol/sdk/shared/protocol.js`
-   * where our patches open SERVER/CLIENT spans around the handler + outgoing
-   * request. If `super.init()` throws (unlikely but possible across Arize
-   * versions), we gracefully degrade to protocol-only instrumentation.
-   *
-   * The cast at the end satisfies the parent's strongly-typed generic
-   * without leaking the cast into call sites.
-   */
-  init() {
-    let base;
-    try {
-      base = super.init() ?? [];
-    } catch (error) {
-      logger.warn(
-        `Brizz MCP: base Arize init() failed \u2014 transport context propagation disabled: ${String(error)}`
-      );
-      base = [];
-    }
-    const baseArr = Array.isArray(base) ? base : [base];
-    const brizzDef = new import_instrumentation.InstrumentationNodeModuleDefinition(
-      PROTOCOL_MODULE_NAME,
-      PROTOCOL_SUPPORTED_VERSIONS,
-      (module3) => {
-        this.patchProtocolModule(module3);
-        return module3;
-      },
-      (module3) => {
-        this.unpatchProtocolModule(module3);
-        return module3;
-      }
-    );
-    return [...baseArr, brizzDef];
-  }
-  /**
-   * Manually instrument MCP modules for Next.js/Webpack where the
-   * auto-instrumentation module-load hook doesn't fire.
-   *
-   * Forwards the six transport module fields to the inherited Arize
-   * `manuallyInstrument(...)` (context propagation) and applies our
-   * protocol patch if `protocolModule` is provided (SERVER/CLIENT spans).
-   * Both legs are try/catch-guarded — a failure in one shouldn't prevent
-   * the other from taking effect.
-   */
-  manuallyInstrument(modules) {
-    const {
-      clientSSEModule,
-      serverSSEModule,
-      clientStdioModule,
-      serverStdioModule,
-      clientStreamableHTTPModule,
-      serverStreamableHTTPModule,
-      protocolModule
-    } = modules;
-    try {
-      super.manuallyInstrument({
-        clientSSEModule,
-        serverSSEModule,
-        clientStdioModule,
-        serverStdioModule,
-        clientStreamableHTTPModule,
-        serverStreamableHTTPModule
-      });
-    } catch (error) {
-      logger.warn(`Brizz MCP: Arize manuallyInstrument(...) failed: ${String(error)}`);
-    }
-    if (protocolModule) {
-      try {
-        this.patchProtocolModule(protocolModule);
-      } catch (error) {
-        logger.warn(
-          `Brizz MCP: failed to manually patch Protocol module: ${String(error)}`
-        );
-      }
-    }
-  }
-  /**
-   * Apply the SERVER + CLIENT patch to a loaded `protocol.js` module. Shared
-   * by both the automatic module-load callback in `init()` and the manual
-   * `manuallyInstrument(...)` path above so there's exactly one place that
-   * calls `patchProtocolPrototype`.
-   */
-  patchProtocolModule(module3) {
-    const proto = module3?.Protocol?.prototype;
-    if (!proto) {
-      logger.debug(
-        "Brizz MCP: module does not expose Protocol.prototype \u2014 skipping protocol patches"
-      );
-      return;
-    }
-    const ok = patchProtocolPrototype(proto, this.brizzTracer);
-    if (ok) {
-      logger.debug("Brizz MCP: patched Protocol.prototype for SERVER+CLIENT spans");
-    }
-  }
-  /**
-   * Unpatch is intentionally a no-op.
-   *
-   * `patchProtocolPrototype` wraps methods in place and sets a PATCHED_FLAG
-   * Symbol on the prototype to prevent double-patching. Restoring the
-   * originals would require us to hold references across module unloads,
-   * which isn't a pattern we need — instrumentation rarely gets torn down
-   * at runtime, and a process reload is the canonical way to detach.
-   */
-  unpatchProtocolModule(_module) {
-    logger.debug(
-      "Brizz MCP: unpatch is a no-op \u2014 reload the process to cleanly detach"
-    );
-  }
-};
-
-// src/internal/instrumentation/registry.ts
-var InstrumentationRegistry = class _InstrumentationRegistry {
-  static instance;
-  manualModules = null;
-  static getInstance() {
-    if (!_InstrumentationRegistry.instance) {
-      _InstrumentationRegistry.instance = new _InstrumentationRegistry();
-    }
-    return _InstrumentationRegistry.instance;
-  }
-  /**
-   * Set manual instrumentation modules for Next.js/Webpack environments
-   */
-  setManualModules(modules) {
-    this.manualModules = modules;
-    logger.info("Manual instrumentation modules configured for Next.js/Webpack compatibility");
-  }
-  /**
-   * Helper to load instrumentation with optional manual module
-   */
-  loadInstrumentation(InstrumentationClass, name, manualModule, exceptionLogger) {
-    try {
-      const inst = new InstrumentationClass({
-        exceptionLogger: exceptionLogger || ((error) => logger.error(`Exception in instrumentation: ${String(error)}`))
-      });
-      if (manualModule) {
-        inst.manuallyInstrument(manualModule);
-        logger.debug(`Manual instrumentation enabled for ${name}`);
-      }
-      return inst;
-    } catch (error) {
-      logger.error(`Failed to load ${name} instrumentation: ${String(error)}`);
-      return null;
-    }
-  }
-  /**
-   * Get manual instrumentations only.
-   * Auto-instrumentations are handled at import time.
-   */
-  getManualInstrumentations() {
-    if (!this.manualModules || Object.keys(this.manualModules).length === 0) {
-      logger.debug("No manual instrumentation modules configured");
-      return [];
-    }
-    const instrumentations = [];
-    const exceptionLogger = (error) => {
-      logger.error(`Exception in manual instrumentation: ${String(error)}`);
-    };
-    this.loadManualInstrumentations(instrumentations, exceptionLogger);
-    logger.info(`Loaded ${instrumentations.length} manual instrumentations`);
-    return instrumentations;
-  }
-  /**
-   * Load manual instrumentations only (with modules provided by user).
-   * @private
-   */
-  loadManualInstrumentations(instrumentations, exceptionLogger) {
-    const instrumentationConfigs = [
-      { class: import_instrumentation_openai.OpenAIInstrumentation, name: "OpenAI", module: this.manualModules?.openAI },
-      { class: import_instrumentation_anthropic.AnthropicInstrumentation, name: "Anthropic", module: this.manualModules?.anthropic },
-      { class: import_instrumentation_cohere.CohereInstrumentation, name: "Cohere", module: this.manualModules?.cohere },
-      {
-        class: import_instrumentation_vertexai.VertexAIInstrumentation,
-        name: "Vertex AI",
-        module: this.manualModules?.google_vertexai
-      },
-      { class: import_instrumentation_bedrock.BedrockInstrumentation, name: "Bedrock", module: this.manualModules?.bedrock },
-      { class: import_instrumentation_pinecone.PineconeInstrumentation, name: "Pinecone", module: this.manualModules?.pinecone },
-      {
-        class: import_instrumentation_llamaindex.LlamaIndexInstrumentation,
-        name: "LlamaIndex",
-        module: this.manualModules?.llamaindex
-      },
-      { class: import_instrumentation_chromadb.ChromaDBInstrumentation, name: "ChromaDB", module: this.manualModules?.chromadb },
-      { class: import_instrumentation_qdrant.QdrantInstrumentation, name: "Qdrant", module: this.manualModules?.qdrant },
-      { class: import_instrumentation_together.TogetherInstrumentation, name: "Together", module: this.manualModules?.together }
-    ];
-    for (const config of instrumentationConfigs) {
-      if (config.module) {
-        const instrumentation = this.loadInstrumentation(
-          config.class,
-          config.name,
-          config.module,
-          exceptionLogger
-        );
-        if (instrumentation) {
-          instrumentations.push(instrumentation);
-        }
-      }
-    }
-    if (this.manualModules?.langchain?.callbackManagerModule) {
-      const callbackManagerModule = this.manualModules.langchain.callbackManagerModule;
-      void (async () => {
-        try {
-          const { LangChainInstrumentation } = await import("@arizeai/openinference-instrumentation-langchain");
-          const lcInst = new LangChainInstrumentation();
-          lcInst.manuallyInstrument(callbackManagerModule);
-          logger.debug("Manual instrumentation enabled for LangChain");
-        } catch (error) {
-          logger.error(
-            `Failed to load LangChain instrumentation. Ensure @langchain/core is installed: ${String(error)}`
-          );
-        }
-      })();
-    }
-    if (this.manualModules?.mcp) {
-      try {
-        new MCPInstrumentation({ exceptionLogger }).manuallyInstrument(this.manualModules.mcp);
-        logger.debug("Manual instrumentation enabled for MCP");
-      } catch (error) {
-        logger.error(`Failed to apply MCP instrumentation: ${String(error)}`);
-      }
-    }
-  }
-};
-
-// src/internal/instrumentation/vercel-ai/interrupt.ts
-var import_api8 = require("@opentelemetry/api");
-var INNER_OPERATION_IDS = /* @__PURE__ */ new Set([
-  "ai.generateText.doGenerate",
-  "ai.streamText.doStream"
-]);
-function isInnerLLMSpan(span) {
-  if (INNER_OPERATION_IDS.has(span.name)) {
-    return true;
-  }
-  const opId = span.attributes["ai.operationId"];
-  return typeof opId === "string" && INNER_OPERATION_IDS.has(opId);
-}
-var pendingByParentSpanId = /* @__PURE__ */ new Map();
-var InterruptPropagator = class {
-  onStart(span, _parentContext) {
-    if (!isInnerLLMSpan(span)) {
-      return;
-    }
-    const parentSpanId = span.parentSpanContext?.spanId;
-    if (!parentSpanId) {
-      return;
-    }
-    const value = pendingByParentSpanId.get(parentSpanId);
-    if (!value) {
-      return;
-    }
-    span.setAttribute(INTERRUPT_TOOLS, value);
-    pendingByParentSpanId.delete(parentSpanId);
-  }
-  onEnd() {
-  }
-  async shutdown() {
-  }
-  async forceFlush() {
-  }
-};
-
-// src/internal/log/logging.ts
-var import_api_logs = require("@opentelemetry/api-logs");
-var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
-var import_resources = require("@opentelemetry/resources");
-var import_sdk_logs2 = require("@opentelemetry/sdk-logs");
-
-// src/internal/trace/session.ts
-var import_api9 = require("@opentelemetry/api");
-
-// src/internal/log/processors/log-processor.ts
-var import_api10 = require("@opentelemetry/api");
-var import_sdk_logs = require("@opentelemetry/sdk-logs");
-
-// src/internal/masking/patterns.ts
-var DEFAULT_PII_PATTERNS = [
-  // Phone numbers (US format)
-  {
-    name: "us_phone_numbers",
-    pattern: String.raw`(?:^|[\s])(?:\+?1[-.\s]*)?(?:\([0-9]{3}\)\s?[0-9]{3}[-.\s]?[0-9]{4}|[0-9]{3}[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}|[0-9]{10})(?=[\s]|$)`
-  },
-  // Credit card numbers
-  {
-    name: "credit_cards",
-    pattern: String.raw`\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|6(?:011|5[0-9]{2})[0-9]{12}|(?:2131|1800|35\\d{3})\\d{11})\b`
-  },
-  {
-    name: "credit_cards_with_separators",
-    pattern: String.raw`\b(?:4\\d{3}|5[1-5]\\d{2}|3[47]\\d{2})[-\s]?\\d{4}[-\s]?\\d{4}[-\s]?\\d{4}\b`
-  },
-  // IP addresses (IPv4)
-  {
-    name: "ipv4_addresses",
-    pattern: String.raw`\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?!\.[0-9])\b`
-  },
-  // API keys/tokens
-  {
-    name: "generic_api_keys",
-    pattern: String.raw`\b(?:[Aa][Pp][Ii][_-]?[Kk][Ee][Yy]|[Tt][Oo][Kk][Ee][Nn]|[Ss][Ee][Cc][Rr][Ee][Tt])[_-]?[=:]?\s*["']?(?:[a-zA-Z0-9\-_.]{20,})["']?\b`
-  },
-  {
-    name: "openai_keys",
-    pattern: String.raw`\bsk[-_][a-zA-Z0-9]{20,}\b`
-  },
-  // AWS Keys
-  {
-    name: "aws_access_keys",
-    pattern: String.raw`\b(?:AKIA|ABIA|ACCA|ASIA)[0-9A-Z]{16}\b`
-  },
-  // GitHub tokens
-  {
-    name: "github_tokens",
-    pattern: String.raw`\bghp_[a-zA-Z0-9]{36}\b`
-  },
-  // Slack tokens
-  {
-    name: "slack_tokens",
-    pattern: String.raw`\bxox[baprs]-[0-9]{10,13}-[0-9]{10,13}-[a-zA-Z0-9]{24,34}\b`
-  },
-  // Stripe keys
-  {
-    name: "stripe_keys",
-    pattern: String.raw`\b(?:sk|pk)_(?:test|live)_[a-zA-Z0-9]{24,}\b`
-  },
-  // JWT tokens
-  {
-    name: "jwt_tokens",
-    pattern: String.raw`\beyJ[A-Za-z0-9_-]{2,}\\.[A-Za-z0-9_-]{2,}\\.[A-Za-z0-9_-]{2,}\b`
-  },
-  // MAC addresses
-  {
-    name: "mac_addresses",
-    pattern: String.raw`\b(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\b`
-  },
-  // IPv6 addresses
-  {
-    name: "ipv6_addresses",
-    pattern: String.raw`\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b`
-  },
-  // Bitcoin addresses
-  {
-    name: "bitcoin_addresses",
-    pattern: String.raw`\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b`
-  },
-  // Ethereum addresses
-  {
-    name: "ethereum_addresses",
-    pattern: String.raw`\b0x[a-fA-F0-9]{40}(?![a-fA-F0-9])\b`
-  },
-  // Database connection strings
-  {
-    name: "database_connections",
-    pattern: String.raw`\b(?:[Mm][Oo][Nn][Gg][Oo][Dd][Bb]|[Pp][Oo][Ss][Tt][Gg][Rr][Ee][Ss]|[Mm][Yy][Ss][Qq][Ll]|[Rr][Ee][Dd][Ii][Ss]|[Mm][Ss][Ss][Qq][Ll]|[Oo][Rr][Aa][Cc][Ll][Ee]):\\/\\/[^\\s]+\b`
-  },
-  // Private keys
-  {
-    name: "rsa_private_keys",
-    pattern: "-----BEGIN (?:RSA )?PRIVATE KEY-----"
-  },
-  {
-    name: "pgp_private_keys",
-    pattern: "-----BEGIN PGP PRIVATE KEY BLOCK-----"
-  },
-  // Additional API Keys and Tokens
-  {
-    name: "google_oauth",
-    pattern: String.raw`\bya29\\.[a-zA-Z0-9_-]{60,}\b`
-  },
-  {
-    name: "firebase_tokens",
-    pattern: String.raw`\bAAAA[A-Za-z0-9_-]{100,}\b`
-  },
-  {
-    name: "google_app_ids",
-    pattern: String.raw`\b[0-9]+-\w+\.apps\.googleusercontent\.com\b`
-  },
-  {
-    name: "facebook_secrets",
-    pattern: String.raw`\b(facebook_secret|FACEBOOK_SECRET|facebook_app_secret|FACEBOOK_APP_SECRET)[a-z_ =\\s"'\\:]{0,5}[^a-zA-Z0-9][a-f0-9]{32}[^a-zA-Z0-9]`
-  },
-  {
-    name: "github_keys",
-    pattern: String.raw`\b(GITHUB_SECRET|GITHUB_KEY|github_secret|github_key|github_token|GITHUB_TOKEN|github_api_key|GITHUB_API_KEY)[a-z_ =\\s\"'\\:]{0,10}[^a-zA-Z0-9][a-zA-Z0-9]{40}[^a-zA-Z0-9]`
-  },
-  {
-    name: "heroku_keys",
-    pattern: String.raw`\b(heroku_api_key|HEROKU_API_KEY|heroku_secret|HEROKU_SECRET)[a-z_ =\\s\"'\\:]{0,10}[^a-zA-Z0-9-]\\w{8}(?:-\\w{4}){3}-\\w{12}[^a-zA-Z0-9\\-]`
-  },
-  {
-    name: "slack_api_keys",
-    pattern: String.raw`\b(slack_api_key|SLACK_API_KEY|slack_key|SLACK_KEY)[a-z_ =\\s\"'\\:]{0,10}[^a-f0-9][a-f0-9]{32}[^a-f0-9]`
-  },
-  {
-    name: "slack_api_tokens",
-    pattern: String.raw`\b(xox[pb](?:-[a-zA-Z0-9]+){4,})\b`
-  },
-  // Extended Private Keys and Certificates
-  {
-    name: "dsa_private_keys",
-    pattern: String.raw`-----BEGIN DSA PRIVATE KEY-----(?:[a-zA-Z0-9\+\=\/"']|\s)+?-----END DSA PRIVATE KEY-----`
-  },
-  {
-    name: "ec_private_keys",
-    pattern: String.raw`-----BEGIN (?:EC|ECDSA) PRIVATE KEY-----(?:[a-zA-Z0-9\+\=\/"']|\s)+?-----END (?:EC|ECDSA) PRIVATE KEY-----`
-  },
-  {
-    name: "encrypted_private_keys",
-    pattern: String.raw`-----BEGIN ENCRYPTED PRIVATE KEY-----(?:.|\s)+?-----END ENCRYPTED PRIVATE KEY-----`
-  },
-  {
-    name: "ssl_certificates",
-    pattern: String.raw`-----BEGIN CERTIFICATE-----(?:.|\n)+?\s*-----END CERTIFICATE-----`
-  },
-  {
-    name: "ssh_dss_public",
-    pattern: String.raw`\bssh-dss [0-9A-Za-z+/]+[=]{2}\b`
-  },
-  {
-    name: "ssh_rsa_public",
-    pattern: String.raw`\bssh-rsa AAAA[0-9A-Za-z+/]+[=]{0,3} [^@]+@[^@]+\b`
-  },
-  {
-    name: "putty_ssh_keys",
-    pattern: String.raw`PuTTY-User-Key-File-2: ssh-(?:rsa|dss)\s*Encryption: none(?:.|\s?)*?Private-MAC:`
-  },
-  // Security and Network
-  {
-    name: "cve_numbers",
-    pattern: String.raw`\b[Cc][Vv][Ee]-\\d{4}-\\d{4,7}\b`
-  },
-  {
-    name: "microsoft_oauth",
-    pattern: String.raw`https://login\.microsoftonline\.com/common/oauth2/v2\.0/token|https://login\.windows\.net/common/oauth2/token`
-  },
-  {
-    name: "postgres_connections",
-    pattern: String.raw`\b(?:[Pp][Oo][Ss][Tt][Gg][Rr][Ee][Ss]|[Pp][Gg][Ss][Qq][Ll])\\:\\/\\/`
-  },
-  {
-    name: "box_links",
-    pattern: String.raw`https://app\.box\.com/[s|l]/\S+`
-  },
-  {
-    name: "dropbox_links",
-    pattern: String.raw`https://www\.dropbox\.com/(?:s|l)/\S+`
-  },
-  // Credit Card Variants
-  {
-    name: "amex_cards",
-    pattern: String.raw`\b3[47][0-9]{13}\b`
-  },
-  {
-    name: "visa_cards",
-    pattern: String.raw`\b4[0-9]{12}(?:[0-9]{3})?\b`
-  },
-  {
-    name: "discover_cards",
-    pattern: String.raw`\b65[4-9][0-9]{13}|64[4-9][0-9]{13}|6011[0-9]{12}\b`
-  }
-];
-
-// src/internal/masking/utils.ts
-function isValidPatternName(name) {
-  return /^[a-zA-Z0-9_]+$/.test(name);
-}
-function isLikelyReDoSPattern(pattern) {
-  const dangerousPatterns = [
-    // Nested quantifiers like (a+)+, (a*)+, (a+)*
-    /\([^)]*[+*]\)[+*]/,
-    // Overlapping alternation under an outer quantifier like (a|a)+, (\w|\d)+. Scoped to
-    // capturing groups so the lazy (?:…)+? built-ins aren't false-flagged.
-    /\((?!\?)[^)]*\|[^)]*\)[+*]/,
-    // Complex backtracking patterns - but more specific
-    /\([^)]*[+*][^)]*[+*][^)]*\)[+*]/
-  ];
-  return dangerousPatterns.some((dangerous) => dangerous.test(pattern));
-}
-function getGroupedPattern(patternEntry) {
-  let name = patternEntry.name;
-  if (!name || name === "") {
-    name = `pattern_${Math.random().toString(16).slice(2)}`;
-  }
-  if (!isValidPatternName(name)) {
-    throw new Error(
-      `Pattern name '${name}' must only contain alphanumeric characters and underscores`
-    );
-  }
-  if (isLikelyReDoSPattern(patternEntry.pattern)) {
-    throw new Error(`Potentially dangerous ReDoS pattern detected: '${patternEntry.pattern}'`);
-  }
-  try {
-    new RegExp(patternEntry.pattern);
-  } catch (error) {
-    throw new Error(`Invalid regex pattern '${patternEntry.pattern}': ${String(error)}`, {
-      cause: error
-    });
-  }
-  return `(?<${name}>${patternEntry.pattern})`;
-}
-function isIPatternEntry(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.pattern === "string" && (obj.name === void 0 || typeof obj.name === "string");
-}
-function isIEventMaskingRule(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.mode === "string" && Array.isArray(obj.patterns) && obj.patterns.every(
-    (p) => isIPatternEntry(p) || typeof p === "string"
-  ) && (obj.attributePattern === void 0 || typeof obj.attributePattern === "string");
-}
-function convertPatternsToPatternEntries(patterns) {
-  const patternEntries = [];
-  for (const pattern of patterns) {
-    if (typeof pattern === "string") {
-      patternEntries.push({ pattern, name: "" });
-    } else if (isIPatternEntry(pattern)) {
-      patternEntries.push(pattern);
-    } else {
-      throw new Error("Patterns must be either strings or PatternEntry instances");
-    }
-  }
-  return patternEntries;
-}
-function compilePatternEntries(patternEntries) {
-  const patternGroups = [];
-  for (const patternEntry of patternEntries) {
-    try {
-      patternGroups.push(getGroupedPattern(patternEntry));
-    } catch (error) {
-      logger.warn(`Invalid pattern '${patternEntry.name}': ${patternEntry.pattern}`, error);
-      continue;
-    }
-  }
-  if (patternGroups.length === 0) {
-    return null;
-  }
-  try {
-    return new RegExp(patternGroups.join("|"));
-  } catch (error) {
-    logger.warn("Failed to compile pattern entries into regex", error);
-    return null;
-  }
-}
-var compiledPatternCache = /* @__PURE__ */ new WeakMap();
-function getCompiledPatternsForRule(rule) {
-  const key = rule.patterns;
-  if (compiledPatternCache.has(key)) {
-    return compiledPatternCache.get(key) ?? null;
-  }
-  const compiled = compilePatternEntries(convertPatternsToPatternEntries(rule.patterns));
-  compiledPatternCache.set(key, compiled);
-  return compiled;
-}
-function getCompiledAttributeNamePattern(rule) {
-  if (!rule.attributePattern) {
-    logger.debug("No attribute pattern provided, using default .*");
-    return /.*/;
-  }
-  let compiledPatternString = rule.attributePattern;
-  if (isIEventMaskingRule(rule) && rule.eventNamePattern) {
-    compiledPatternString = `(${compiledPatternString})|(${rule.eventNamePattern})`;
-  }
-  return new RegExp(compiledPatternString);
-}
-function shouldContinueExecution(startTime, iterations, timeoutMs) {
-  if (Date.now() - startTime > timeoutMs) {
-    logger.warn("Regex execution timed out - potential ReDoS pattern detected");
-    return false;
-  }
-  const maxIterations = 1e3;
-  if (iterations > maxIterations) {
-    logger.warn("Regex execution exceeded maximum iterations - potential ReDoS pattern detected");
-    return false;
-  }
-  return true;
-}
-function createGlobalPattern(pattern) {
-  return new RegExp(
-    pattern.source,
-    pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g"
-  );
-}
-function executeRegexWithTimeout(pattern, value, timeoutMs = 100) {
-  const matches = [];
-  const globalPattern = createGlobalPattern(pattern);
-  const startTime = Date.now();
-  let match;
-  let iterations = 0;
-  while ((match = globalPattern.exec(value)) !== null) {
-    if (!shouldContinueExecution(startTime, ++iterations, timeoutMs)) {
-      break;
-    }
-    matches.push(match);
-    if (match[0].length === 0) {
-      globalPattern.lastIndex = match.index + 1;
-    }
-  }
-  return matches;
-}
-function maskStringByPattern(value, pattern, mode = "full") {
-  const matches = [];
-  try {
-    const regexMatches = executeRegexWithTimeout(pattern, value);
-    for (const match of regexMatches) {
-      matches.push({
-        start: match.index,
-        end: match.index + match[0].length,
-        text: match[0],
-        groups: match.groups
-      });
-    }
-  } catch (error) {
-    logger.warn("Regex execution failed, skipping masking", error);
-    return value;
-  }
-  for (const matchInfo of matches.toReversed()) {
-    let patternName = "unknown";
-    if (matchInfo.groups) {
-      for (const [groupName, groupValue] of Object.entries(matchInfo.groups)) {
-        if (groupValue !== void 0) {
-          if (groupName.includes("_") && /\d$/.test(groupName)) {
-            const parts = groupName.split("_");
-            patternName = parts[0] || groupName;
-          } else {
-            patternName = groupName;
-          }
-          break;
-        }
-      }
-    }
-    logger.info(`Masking detected: pattern '${patternName}' found match in value`);
-    const masked = mode === "partial" ? matchInfo.text[0] + "*****" : "*****";
-    value = value.slice(0, matchInfo.start) + masked + value.slice(matchInfo.end);
-  }
-  return value;
-}
-function maskStringByPatternBasedRule(value, rule) {
-  const patternEntries = convertPatternsToPatternEntries(rule.patterns);
-  if (patternEntries.length === 0) {
-    logger.warn("No patterns provided for masking rule, returning original value");
-    return value;
-  }
-  const mode = rule.mode;
-  if (!patternEntries || patternEntries.length === 0) {
-    return mode === "partial" && value ? value[0] + "*****" : "*****";
-  }
-  const compiledPatterns = getCompiledPatternsForRule(rule);
-  if (!compiledPatterns) {
-    return value;
-  }
-  return maskStringByPattern(value, compiledPatterns, mode);
-}
-function maskValue(value, rule) {
-  if (typeof value === "string") {
-    return maskStringByPatternBasedRule(value, rule);
-  } else if (typeof value === "boolean" || typeof value === "number") {
-    return maskStringByPatternBasedRule(String(value), rule);
-  } else if (Array.isArray(value)) {
-    return value.map((v) => maskStringByPatternBasedRule(String(v), rule));
-  } else if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      result[k] = maskValue(v, rule);
-    }
-    return result;
-  } else {
-    throw new Error(`Unsupported value type for masking: ${typeof value}`);
-  }
-}
-function maskAttributes(attributes, rules, outputOriginalValue = false) {
-  if (!attributes || Object.keys(attributes).length === 0) {
-    return {};
-  }
-  const maskedAttributes = { ...attributes };
-  for (const rule of rules) {
-    const compiledAttributeNamePattern = getCompiledAttributeNamePattern(rule);
-    const attributesToMask = compiledAttributeNamePattern ? Object.keys(maskedAttributes).filter((attr) => compiledAttributeNamePattern.test(attr)) : Object.keys(maskedAttributes);
-    for (const attribute of attributesToMask) {
-      const value = maskedAttributes[attribute];
-      if (value === null || value === void 0) {
-        continue;
-      }
-      if (outputOriginalValue) {
-        logger.debug(`Masking attribute '${attribute}' with original value`, { value });
-      }
-      maskedAttributes[attribute] = maskValue(value, rule);
-    }
-  }
-  return maskedAttributes;
-}
-
-// src/internal/log/processors/log-processor.ts
-var DEFAULT_LOG_MASKING_RULES = [
-  {
-    mode: "partial",
-    attributePattern: "event.name",
-    patterns: DEFAULT_PII_PATTERNS
-  }
-];
-var BrizzSimpleLogRecordProcessor = class extends import_sdk_logs.SimpleLogRecordProcessor {
-  config;
-  constructor(exporter, config) {
-    super(exporter);
-    this.config = config;
-  }
-  onEmit(logRecord) {
-    const maskingConfig = this.config.masking?.eventMasking;
-    if (maskingConfig) {
-      maskLog(logRecord, maskingConfig);
-    }
-    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
-    if (associationProperties) {
-      for (const [key, value] of Object.entries(associationProperties)) {
-        logRecord.setAttribute(`${BRIZZ}.${key}`, value);
-      }
-    }
-    super.onEmit(logRecord);
-  }
-};
-var BrizzBatchLogRecordProcessor = class extends import_sdk_logs.BatchLogRecordProcessor {
-  config;
-  constructor(exporter, config) {
-    super(exporter);
-    this.config = config;
-  }
-  onEmit(logRecord) {
-    const maskingConfig = this.config.masking?.eventMasking;
-    if (maskingConfig) {
-      maskLog(logRecord, maskingConfig);
-    }
-    const associationProperties = import_api10.context.active().getValue(PROPERTIES_CONTEXT_KEY);
-    if (associationProperties) {
-      for (const [key, value] of Object.entries(associationProperties)) {
-        logRecord.setAttribute(`${BRIZZ}.${key}`, value);
-      }
-    }
-    super.onEmit(logRecord);
-  }
-};
-function maskLog(logRecord, config) {
-  if (!logRecord.attributes) {
-    return logRecord;
-  }
-  let rules = config.rules || [];
-  if (!config.disableDefaultRules) {
-    rules = [...DEFAULT_LOG_MASKING_RULES, ...rules];
-  }
-  try {
-    if (logRecord.attributes && Object.keys(logRecord.attributes).length > 0) {
-      const attributesRecord = {};
-      for (const [key, value] of Object.entries(logRecord.attributes)) {
-        attributesRecord[key] = value;
-      }
-      const maskedAttributes = maskAttributes(attributesRecord, rules);
-      if (maskedAttributes) {
-        const newAttributes = {};
-        for (const [key, value] of Object.entries(maskedAttributes)) {
-          newAttributes[key] = value;
-        }
-        for (const [key, value] of Object.entries(logRecord.attributes)) {
-          if (key.startsWith(INTERNAL_EVENT_PREFIX)) {
-            newAttributes[key] = value;
-          }
-        }
-        logRecord.setAttributes(newAttributes);
-      }
-    }
-    if (config.maskBody && logRecord.body !== void 0 && logRecord.body !== null) {
-      let maskedBody = logRecord.body;
-      for (const rule of rules) {
-        maskedBody = maskValue(maskedBody, rule);
-      }
-      logRecord.setBody(maskedBody);
-    }
-    return logRecord;
-  } catch (error) {
-    logger.error("Error masking log record:", error);
-    return logRecord;
-  }
-}
-
-// src/internal/log/logging.ts
-var LoggingModule = class _LoggingModule {
-  static instance = null;
-  logExporter = null;
-  logProcessor = null;
-  loggerProvider = null;
-  static getInstance() {
-    if (!_LoggingModule.instance) {
-      throw new Error("Brizz must be initialized before accessing LoggingModule");
-    }
-    return _LoggingModule.instance;
-  }
-  /**
-   * Initialize the logging module with the provided configuration
-   */
-  setup(config) {
-    logger.info("Setting up logging module");
-    this.initLogExporter(config);
-    this.initLogProcessor(config);
-    this.initLoggerProvider(config);
-    _LoggingModule.instance = this;
-    logger.info("Logging module setup completed");
-  }
-  /**
-   * Initialize the log exporter
-   */
-  initLogExporter(config) {
-    if (this.logExporter) {
-      logger.debug("Log exporter already initialized, skipping re-initialization");
-      return;
-    }
-    if (config.customLogExporter) {
-      logger.debug("Using custom log exporter");
-      this.logExporter = config.customLogExporter;
-      logger.debug("Custom log exporter initialized successfully");
-      return;
-    }
-    const logsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/logs";
-    logger.debug("Initializing default OTLP log exporter", { url: logsUrl });
-    const headers = { ...config.headers };
-    this.logExporter = new import_exporter_logs_otlp_http.OTLPLogExporter({
-      url: logsUrl,
-      headers
-    });
-    logger.debug("OTLP log exporter initialized successfully");
-  }
-  /**
-   * Initialize the log processor with masking support
-   */
-  initLogProcessor(config) {
-    if (this.logProcessor) {
-      logger.debug("Log processor already initialized, skipping re-initialization");
-      return;
-    }
-    if (!this.logExporter) {
-      throw new Error("Log exporter must be initialized before processor");
-    }
-    logger.debug("Initializing log processor", {
-      disableBatch: config.disableBatch,
-      hasMasking: !!config.masking?.eventMasking
-    });
-    this.logProcessor = config.disableBatch ? new BrizzSimpleLogRecordProcessor(this.logExporter, config) : new BrizzBatchLogRecordProcessor(this.logExporter, config);
-    logger.debug("Log processor initialized successfully");
-  }
-  /**
-   * Initialize the logger provider
-   */
-  initLoggerProvider(config) {
-    if (this.loggerProvider) {
-      logger.debug("Logger provider already initialized, skipping re-initialization");
-      return;
-    }
-    if (!this.logProcessor) {
-      throw new Error("Log processor must be initialized before logger provider");
-    }
-    logger.debug("Creating resource with service name", {
-      serviceName: config.appName
-    });
-    const resourceAttributes = {
-      ...config.resourceAttributes,
-      "service.name": config.appName,
-      [BRIZZ_SDK_VERSION]: getSDKVersion(),
-      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
-    };
-    if (config.environment) {
-      resourceAttributes["deployment.environment"] = config.environment;
-    }
-    if (config.appVersion) {
-      resourceAttributes["service.version"] = config.appVersion;
-    }
-    const resource = (0, import_resources.resourceFromAttributes)(resourceAttributes);
-    logger.debug("Creating logger provider with resource");
-    this.loggerProvider = new import_sdk_logs2.LoggerProvider({
-      resource,
-      processors: [this.logProcessor]
-    });
-    logger.debug("Logger provider initialization completed");
-  }
-  /**
-   * Emit a custom event to the telemetry pipeline
-   */
-  emitEvent(name, attributes, body, severityNumber = import_api_logs.SeverityNumber.INFO) {
-    logger.debug("Attempting to emit event", {
-      name,
-      hasAttributes: !!attributes,
-      attributesCount: attributes ? Object.keys(attributes).length : 0,
-      hasBody: !!body,
-      severityNumber
-    });
-    if (!this.loggerProvider) {
-      logger.error("Cannot emit event: Logger provider not initialized");
-      throw new Error("Logging module not initialized");
-    }
-    const logAttributes = { "event.name": name };
-    if (attributes) {
-      Object.assign(logAttributes, attributes);
-      logger.debug("Combined log attributes", { attributes: Object.keys(logAttributes) });
-    }
-    logger.debug("Getting logger instance for brizz_events");
-    const eventLogger = this.loggerProvider.getLogger("brizz.events");
-    logger.debug("Emitting log record with eventName", { eventName: name });
-    try {
-      eventLogger.emit({
-        eventName: name,
-        attributes: logAttributes,
-        severityNumber,
-        body
-      });
-      logger.debug("Event successfully emitted", { eventName: name });
-    } catch (error) {
-      logger.error(`Failed to emit event '${name}'`, { error, eventName: name });
-      logger.error("Log record that failed", {
-        eventName: name,
-        hasAttributes: logAttributes,
-        severityNumber,
-        hasBody: body
-      });
-      throw error instanceof Error ? error : new Error(String(error));
-    }
-  }
-  /**
-   * Check if the module is initialized
-   */
-  isInitialized() {
-    return this.loggerProvider !== null;
-  }
-  /**
-   * Get the logger provider
-   */
-  getLoggerProvider() {
-    return this.loggerProvider;
-  }
-  /**
-   * Shutdown the logging module
-   */
-  async shutdown() {
-    logger.debug("Shutting down logging module");
-    if (this.loggerProvider) {
-      await this.loggerProvider.shutdown();
-      this.loggerProvider = null;
-    }
-    this.logProcessor = null;
-    this.logExporter = null;
-    if (_LoggingModule.instance === this) {
-      _LoggingModule.instance = null;
-    }
-    logger.debug("Logging module shutdown completed");
-  }
-};
-
-// src/internal/metric/metrics.ts
-var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
-var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
-var MetricsModule = class _MetricsModule {
-  static instance = null;
-  metricsExporter = null;
-  metricsReader = null;
-  static getInstance() {
-    if (!_MetricsModule.instance) {
-      throw new Error("Brizz must be initialized before accessing MetricsModule");
-    }
-    return _MetricsModule.instance;
-  }
-  /**
-   * Initialize the metrics module with the provided configuration
-   */
-  setup(config) {
-    logger.info("Setting up metrics module");
-    this.initMetricsReader(config);
-    _MetricsModule.instance = this;
-    logger.info("Metrics module setup completed");
-  }
-  /**
-   * Initialize the metrics exporter
-   */
-  initMetricsExporter(config) {
-    if (this.metricsExporter) {
-      logger.debug("Metrics exporter already initialized, skipping re-initialization");
-      return;
-    }
-    const metricsUrl = config.baseUrl.replace(/\/$/, "") + "/v1/metrics";
-    logger.debug("Initializing metrics exporter", { url: metricsUrl });
-    this.metricsExporter = new import_exporter_metrics_otlp_http.OTLPMetricExporter({
-      url: metricsUrl,
-      headers: config.headers
-    });
-    logger.debug("Metrics exporter initialized successfully");
-  }
-  /**
-   * Initialize the metrics reader
-   */
-  initMetricsReader(config) {
-    if (this.metricsReader) {
-      logger.debug("Metrics reader already initialized, skipping re-initialization");
-      return;
-    }
-    if (config.customMetricReader) {
-      logger.debug("Using custom metric reader");
-      this.metricsReader = config.customMetricReader;
-      logger.debug("Custom metric reader initialized successfully");
-      return;
-    }
-    logger.debug(
-      "Using default metrics flow - creating OTLP exporter and PeriodicExportingMetricReader"
-    );
-    this.initMetricsExporter(config);
-    if (!this.metricsExporter) {
-      throw new Error("Failed to initialize metrics exporter");
-    }
-    this.metricsReader = new import_sdk_metrics.PeriodicExportingMetricReader({
-      exporter: this.metricsExporter
-    });
-    logger.debug("Default metrics reader initialized successfully");
-  }
-  /**
-   * Get the metrics exporter
-   */
-  getMetricsExporter() {
-    if (!this.metricsExporter) {
-      throw new Error("Metrics module not initialized");
-    }
-    return this.metricsExporter;
-  }
-  /**
-   * Get the metrics reader
-   */
-  getMetricsReader() {
-    if (!this.metricsReader) {
-      throw new Error("Metrics module not initialized");
-    }
-    return this.metricsReader;
-  }
-  /**
-   * Shutdown the metrics module
-   */
-  shutdown() {
-    logger.debug("Shutting down metrics module");
-    this.metricsReader = null;
-    this.metricsExporter = null;
-    if (_MetricsModule.instance === this) {
-      _MetricsModule.instance = null;
-    }
-    logger.debug("Metrics module shutdown completed");
-  }
-};
-function getMetricsReader() {
-  return MetricsModule.getInstance().getMetricsReader();
-}
-
-// src/internal/trace/tracing.ts
-var import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
-
-// src/internal/trace/exporters/span-exporter.ts
-var import_core = require("@opentelemetry/core");
-var import_resources2 = require("@opentelemetry/resources");
-var BrizzSpanExporter = class {
-  _delegate;
-  _brizzResource;
-  _beforeSendSpan;
-  constructor(delegate, config) {
-    this._delegate = delegate;
-    const resourceAttrs = {
-      ...config.resourceAttributes,
-      "service.name": config.appName,
-      [BRIZZ_SDK_VERSION]: getSDKVersion(),
-      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
-    };
-    if (config.environment) {
-      resourceAttrs["deployment.environment"] = config.environment;
-    }
-    if (config.appVersion) {
-      resourceAttrs["service.version"] = config.appVersion;
-    }
-    this._brizzResource = (0, import_resources2.resourceFromAttributes)(resourceAttrs);
-    this._beforeSendSpan = config.beforeSendSpan;
-  }
-  export(spans, resultCallback) {
-    if (spans.length === 0) {
-      resultCallback({ code: import_core.ExportResultCode.SUCCESS });
-      return;
-    }
-    const patchedSpans = spans.map((span) => ({
-      ...span,
-      resource: span.resource.merge(this._brizzResource),
-      spanContext: span.spanContext.bind(span)
-    }));
-    const filter = this._beforeSendSpan;
-    if (!filter) {
-      this._delegate.export(patchedSpans, resultCallback);
-      return;
-    }
-    const verdicts = patchedSpans.map((span) => {
-      try {
-        return Promise.resolve(filter(span));
-      } catch (error) {
-        logger.warn("beforeSendSpan threw; span will be kept", { error });
-        return Promise.resolve(true);
-      }
-    });
-    Promise.all(verdicts).then((keep) => {
-      const filtered = patchedSpans.filter((_, i) => keep[i] !== false);
-      if (filtered.length === 0) {
-        resultCallback({ code: import_core.ExportResultCode.SUCCESS });
-        return;
-      }
-      this._delegate.export(filtered, resultCallback);
-      return;
-    }).catch((error) => {
-      logger.warn("beforeSendSpan rejected; all spans will be kept", { error });
-      this._delegate.export(patchedSpans, resultCallback);
-    });
-  }
-  async shutdown() {
-    return this._delegate.shutdown();
-  }
-  async forceFlush() {
-    return this._delegate.forceFlush?.();
-  }
-};
-
-// src/internal/trace/processors/span-processor.ts
-var import_api11 = require("@opentelemetry/api");
-var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-function applyContextAttributes(span) {
-  const sessionProperties = import_api11.context.active().getValue(PROPERTIES_CONTEXT_KEY);
-  if (sessionProperties) {
-    for (const [key, value] of Object.entries(sessionProperties)) {
-      span.setAttribute(`${BRIZZ}.${key}`, value);
-    }
-  }
-}
-var DEFAULT_MASKING_RULES = [
-  {
-    mode: "partial",
-    patterns: DEFAULT_PII_PATTERNS
-  }
-];
-var BrizzSimpleSpanProcessor = class extends import_sdk_trace_base.SimpleSpanProcessor {
-  config;
-  constructor(spanExporter, config) {
-    super(spanExporter);
-    this.config = config;
-  }
-  onStart(span, parentContext) {
-    applyContextAttributes(span);
-    super.onStart(span, parentContext);
-  }
-  onEnd(span) {
-    const maskingConfig = this.config.masking?.spanMasking;
-    if (maskingConfig) {
-      maskReadableSpan(span, maskingConfig);
-    }
-    super.onEnd(span);
-  }
-};
-var BrizzBatchSpanProcessor = class extends import_sdk_trace_base.BatchSpanProcessor {
-  config;
-  constructor(spanExporter, config) {
-    super(spanExporter);
-    this.config = config;
-  }
-  onStart(span, parentContext) {
-    applyContextAttributes(span);
-    super.onStart(span, parentContext);
-  }
-  onEnd(span) {
-    const maskingConfig = this.config.masking?.spanMasking;
-    if (maskingConfig) {
-      maskReadableSpan(span, maskingConfig);
-    }
-    super.onEnd(span);
-  }
-};
-function maskReadableSpan(span, config) {
-  const attrs = span.attributes;
-  if (!attrs || Object.keys(attrs).length === 0) {
-    return;
-  }
-  let rules = config.rules ? [...config.rules] : [];
-  if (!config.disableDefaultRules) {
-    rules = [...rules, ...DEFAULT_MASKING_RULES];
-  }
-  try {
-    const input = {};
-    for (const [k, v] of Object.entries(attrs)) {
-      input[k] = v;
-    }
-    const masked = maskAttributes(input, rules);
-    for (const [k, v] of Object.entries(masked ?? {})) {
-      if (attrs[k] !== v) {
-        attrs[k] = v;
-      }
-    }
-  } catch (error) {
-    logger.error("Error masking span", { err: error });
-  }
-}
-
-// src/internal/trace/tracing.ts
-var TracingModule = class _TracingModule {
-  static instance = null;
-  spanExporter = null;
-  spanProcessor = null;
-  static getInstance() {
-    if (!_TracingModule.instance) {
-      throw new Error("Brizz must be initialized before accessing TracingModule");
-    }
-    return _TracingModule.instance;
-  }
-  /**
-   * Initialize the tracing module with the provided configuration
-   */
-  setup(config) {
-    logger.info("Setting up tracing module");
-    if (config.disableSpanExporter) {
-      logger.info(
-        "Span exporter disabled via disableSpanExporter; skipping exporter and processor setup"
-      );
-      this.spanExporter = null;
-      this.spanProcessor = null;
-      _TracingModule.instance = this;
-      return;
-    }
-    this.initSpanExporter(config);
-    this.initSpanProcessor(config);
-    _TracingModule.instance = this;
-    logger.info("Tracing module setup completed");
-  }
-  /**
-   * Initialize the span exporter
-   */
-  initSpanExporter(config) {
-    if (this.spanExporter) {
-      logger.debug("Span exporter already initialized, skipping re-initialization");
-      return;
-    }
-    if (config.customSpanExporter) {
-      logger.debug("Using custom span exporter");
-      this.spanExporter = new BrizzSpanExporter(config.customSpanExporter, config);
-      logger.debug("Custom span exporter initialized successfully");
-      return;
-    }
-    const tracesUrl = config.baseUrl.replace(/\/$/, "") + "/v1/traces";
-    logger.debug("Initializing default OTLP span exporter", { url: tracesUrl });
-    const otlpExporter = new import_exporter_trace_otlp_proto.OTLPTraceExporter({
-      url: tracesUrl,
-      headers: config.headers
-    });
-    this.spanExporter = new BrizzSpanExporter(otlpExporter, config);
-    logger.debug("OTLP span exporter initialized successfully");
-  }
-  /**
-   * Initialize the span processor with masking support
-   */
-  initSpanProcessor(config) {
-    if (this.spanProcessor) {
-      logger.debug("Span processor already initialized, skipping re-initialization");
-      return;
-    }
-    if (!this.spanExporter) {
-      throw new Error("Span exporter must be initialized before processor");
-    }
-    logger.debug("Initializing span processor", {
-      disableBatch: config.disableBatch,
-      hasMasking: !!config.masking?.spanMasking
-    });
-    const spanProcessor = config.disableBatch ? new BrizzSimpleSpanProcessor(this.spanExporter, config) : new BrizzBatchSpanProcessor(this.spanExporter, config);
-    logger.debug("Span processor initialized successfully");
-    this.spanProcessor = spanProcessor;
-  }
-  /**
-   * Get the span exporter
-   */
-  getSpanExporter() {
-    if (!this.spanExporter) {
-      throw new Error("Tracing module not initialized");
-    }
-    return this.spanExporter;
-  }
-  /**
-   * Get the span processor
-   */
-  getSpanProcessor() {
-    if (!this.spanProcessor) {
-      throw new Error("Tracing module not initialized");
-    }
-    return this.spanProcessor;
-  }
-  async shutdown() {
-    logger.debug("Shutting down tracing module");
-    if (this.spanProcessor) {
-      await this.spanProcessor.shutdown();
-      this.spanProcessor = null;
-    }
-    if (this.spanExporter) {
-      await this.spanExporter.shutdown();
-      this.spanExporter = null;
-    }
-    _TracingModule.instance = null;
-    logger.debug("Tracing module shutdown completed");
-  }
-};
-function getSpanProcessor() {
-  return TracingModule.getInstance().getSpanProcessor();
-}
-
-// src/internal/sdk.ts
-var _Brizz = class __Brizz {
-  static instance = null;
-  /** Flag indicating if SDK initialization has completed successfully */
-  _initialized = false;
-  /** OpenTelemetry sdk instance */
-  _sdk = null;
-  static getInstance() {
-    if (!__Brizz.instance) {
-      throw new Error("Brizz must be initialized before accessing TracingModule");
-    }
-    return __Brizz.instance;
-  }
-  /**
-   * Initialize the Brizz SDK with the provided configuration.
-   *
-   * @param {IBrizzInitializeOptions} options - Configuration options for the SDK
-   * @throws {Error} - If initialization fails
-   *
-   * @example
-   * ```typescript
-   * Brizz.initialize({
-   *   appName: 'my-app',
-   *   baseUrl: 'http://localhost:4318',
-   *   apiKey: 'your-api-key'
-   * });
-   * ```
-   */
-  initialize(options) {
-    if (this._initialized) {
-      logger.warn("Brizz SDK already initialized");
-      return;
-    }
-    logger.info("Starting Brizz SDK initialization");
-    try {
-      const resolvedConfig = resolveConfig(options);
-      this.initializeModules(resolvedConfig);
-      this.setupInstrumentation(options);
-      this.createAndStartNodeSDK(options, resolvedConfig);
-      this._initialized = true;
-      logger.info("Brizz SDK initialization completed successfully", {
-        moduleSystem: this.detectModuleSystem()
-      });
-    } catch (error) {
-      logger.error("Failed to initialize Brizz SDK", { error });
-      throw new Error(`Failed to initialize SDK: ${String(error)}`, { cause: error });
-    }
-  }
-  /**
-   * Set up instrumentation registry and configure manual modules.
-   * @private
-   */
-  setupInstrumentation(options) {
-    const registry = InstrumentationRegistry.getInstance();
-    if (options.instrumentModules && Object.keys(options.instrumentModules).length > 0) {
-      registry.setManualModules(options.instrumentModules);
-    }
-  }
-  /**
-   * Create and start NodeSDK if not disabled.
-   * Only handles manual instrumentations now - auto instrumentations are loaded at import time.
-   * @private
-   */
-  createAndStartNodeSDK(options, resolvedConfig) {
-    if (options.disableNodeSdk) {
-      logger.info("NodeSDK disabled - only telemetry modules initialized");
-      return;
-    }
-    const registry = InstrumentationRegistry.getInstance();
-    const manualInstrumentations = registry.getManualInstrumentations();
-    const resourceAttributes = {
-      ...resolvedConfig.resourceAttributes,
-      "service.name": resolvedConfig.appName,
-      [BRIZZ_SDK_VERSION]: getSDKVersion(),
-      [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
-    };
-    if (resolvedConfig.environment) {
-      resourceAttributes["deployment.environment"] = resolvedConfig.environment;
-    }
-    if (resolvedConfig.appVersion) {
-      resourceAttributes["service.version"] = resolvedConfig.appVersion;
-    }
-    this._sdk = new import_sdk_node.NodeSDK({
-      spanProcessors: resolvedConfig.disableSpanExporter ? [] : [new InterruptPropagator(), getSpanProcessor()],
-      metricReader: getMetricsReader(),
-      resource: (0, import_resources3.resourceFromAttributes)(resourceAttributes),
-      instrumentations: manualInstrumentations
-    });
-    this._sdk.start();
-    if (manualInstrumentations.length > 0) {
-      logger.info(`NodeSDK started with ${manualInstrumentations.length} manual instrumentations`);
-    } else {
-      logger.info("NodeSDK started - using auto-instrumentations loaded at import time");
-    }
-  }
-  /**
-   * Initialize telemetry modules.
-   *
-   * Sets up the tracing, metrics, and logging modules with their
-   * respective exporters and processors.
-   *
-   * @param {IResolvedBrizzConfig} config - Resolved configuration
-   * @private
-   */
-  initializeModules(config) {
-    logger.info("Initializing telemetry modules");
-    logger.debug("Initializing tracing module");
-    const tracingModule = new TracingModule();
-    tracingModule.setup(config);
-    logger.debug("Initializing metrics module");
-    const metricsModule = new MetricsModule();
-    metricsModule.setup(config);
-    logger.debug("Initializing logging module");
-    const loggingModule = new LoggingModule();
-    loggingModule.setup(config);
-    logger.info("All telemetry modules initialized successfully");
-  }
-  /**
-   * Detect the current module system (ESM or CJS) using reliable indicators
-   *
-   * @returns {string} - 'ESM' or 'CJS'
-   * @private
-   */
-  detectModuleSystem() {
-    const inCJS = typeof module !== "undefined" && typeof exports !== "undefined" && typeof require === "function" && typeof __filename === "string" && typeof __dirname === "string" && this === (typeof exports !== "undefined" ? exports : void 0);
-    return inCJS ? "CJS" : "ESM";
-  }
-  /**
-   * Gracefully shutdown the Brizz SDK.
-   *
-   * This method stops all telemetry collection, flushes any pending data,
-   * and releases resources. Should be called before application termination.
-   *
-   * @returns {Promise<void>} - Resolves when shutdown is complete
-   * @throws {Error} - If shutdown fails
-   *
-   * @example
-   * ```typescript
-   * // Shutdown before app exit
-   * await Brizz.shutdown();
-   * ```
-   */
-  async shutdown() {
-    if (!this._initialized) {
-      logger.warn("Brizz SDK not initialized");
-      return;
-    }
-    try {
-      await this.shutdownModules();
-      await this._sdk?.shutdown();
-      this._initialized = false;
-      this._sdk = null;
-      __Brizz.instance = null;
-      logger.info("Brizz SDK shut down successfully");
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("ENOTFOUND")) {
-        logger.debug(`Network error during shutdown (expected in tests): ${error.message}`);
-      } else {
-        logger.error(`Failed to shutdown Brizz SDK: ${String(error)}`);
-        throw error;
-      }
-    }
-  }
-  /**
-   * Shutdown all telemetry modules.
-   * @private
-   */
-  async shutdownModules() {
-    logger.info("Shutting down telemetry modules");
-    try {
-      try {
-        const tracingModule = TracingModule.getInstance();
-        await tracingModule.shutdown();
-      } catch {
-        logger.debug("Tracing module already shut down or not initialized");
-      }
-      try {
-        const metricsModule = MetricsModule.getInstance();
-        metricsModule.shutdown();
-      } catch {
-        logger.debug("Metrics module already shut down or not initialized");
-      }
-      try {
-        const loggingModule = LoggingModule.getInstance();
-        await loggingModule.shutdown();
-      } catch {
-        logger.debug("Logging module already shut down or not initialized");
-      }
-      logger.info("All telemetry modules shut down successfully");
-    } catch (error) {
-      logger.error("Error shutting down modules", { error });
-      throw error;
-    }
-  }
-};
-var Brizz = new _Brizz();
+var _chunkJB6MA2RVcjs = require('./chunk-JB6MA2RV.cjs');
+require('./chunk-LTXMCGVQ.cjs');
+require('./chunk-GCORRK6B.cjs');
 
 // src/node/loader.ts
-var import_node_module = __toESM(require("module"), 1);
-var import_import_in_the_middle = require("import-in-the-middle");
-var import_meta = {};
+var _module = require('module'); var _module2 = _interopRequireDefault(_module);
+var _importinthemiddle = require('import-in-the-middle');
 var loaderDebug = (() => {
   const isDebug = process.env["BRIZZ_ESM_DEBUG"] === "true" || process.env["BRIZZ_LOG_LEVEL"] === "debug";
   return {
@@ -2457,7 +19,8 @@ var loaderDebug = (() => {
       if (!isDebug) {
         return;
       }
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const now = /* @__PURE__ */ new Date();
+      const timestamp = now.toISOString();
       const dataStr = data ? ` ${JSON.stringify(data)}` : "";
       console.log(`[${timestamp}] [ESM-LOADER] ${msg}${dataStr}`);
     },
@@ -2465,7 +28,8 @@ var loaderDebug = (() => {
       if (!isDebug) {
         return;
       }
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const now = /* @__PURE__ */ new Date();
+      const timestamp = now.toISOString();
       const errorStr = error instanceof Error ? ` ${error.message}` : error ? ` ${JSON.stringify(error)}` : "";
       console.error(`[${timestamp}] [ESM-LOADER] ERROR: ${msg}${errorStr}`);
     }
@@ -2490,36 +54,36 @@ function maybeRegisterESMLoader() {
     loaderDebug.log("ESM loader already registered, skipping");
     return false;
   }
-  globalThis[LOADER_REGISTERED_KEY] = true;
+  Reflect.set(globalThis, LOADER_REGISTERED_KEY, true);
   loaderDebug.log("Starting ESM loader registration...");
   if (!checkLoaderAPISupport()) {
     loaderDebug.log("Node.js version does not support loader API, skipping");
     return false;
   }
-  if (import_meta === void 0 || !import_meta.url) {
+  if (import.meta === void 0 || !import.meta.url) {
     loaderDebug.log("import.meta.url not available, skipping loader registration");
-    globalThis[LOADER_REGISTERED_KEY] = false;
+    Reflect.set(globalThis, LOADER_REGISTERED_KEY, false);
     return false;
   }
   const isTest = process.env["NODE_ENV"] === "test" || process.env["JEST_WORKER_ID"] !== void 0;
   if (isTest) {
     loaderDebug.log("Test environment detected, skipping ESM loader registration");
-    globalThis[LOADER_REGISTERED_KEY] = false;
+    Reflect.set(globalThis, LOADER_REGISTERED_KEY, false);
     return false;
   }
   try {
     loaderDebug.log("Creating MessageChannel for import-in-the-middle...");
-    const { addHookMessagePort } = (0, import_import_in_the_middle.createAddHookMessageChannel)();
+    const { addHookMessagePort: hookMessagePort } = _importinthemiddle.createAddHookMessageChannel.call(void 0, );
     loaderDebug.log("Registering import-in-the-middle/hook.mjs...");
-    import_node_module.default.register("import-in-the-middle/hook.mjs", import_meta.url, {
-      data: { addHookMessagePort },
-      transferList: [addHookMessagePort]
+    _module2.default.register("import-in-the-middle/hook.mjs", import.meta.url, {
+      data: { addHookMessagePort: hookMessagePort },
+      transferList: [hookMessagePort]
     });
     loaderDebug.log("ESM loader successfully registered!");
     return true;
   } catch (error) {
     loaderDebug.error("Failed to register ESM loader:", error);
-    globalThis[LOADER_REGISTERED_KEY] = false;
+    Reflect.set(globalThis, LOADER_REGISTERED_KEY, false);
     return false;
   }
 }
@@ -2528,63 +92,17 @@ if (globalThis[LOADER_REGISTERED_KEY] !== true) {
   maybeRegisterESMLoader();
 }
 
-// src/node/runtime.ts
-function detectRuntime() {
-  const [major, minor] = process.versions.node.split(".").map(Number);
-  const noNodeJSGlobals = typeof __filename === "undefined" && typeof __dirname === "undefined";
-  const noModuleSystem = typeof module === "undefined" && typeof exports === "undefined";
-  const hasRequire = typeof require === "function";
-  const isESM = noNodeJSGlobals && noModuleSystem;
-  const isCJS = hasRequire && typeof module !== "undefined" && typeof exports !== "undefined" && typeof __filename === "string" && typeof __dirname === "string";
-  const supportsLoaderAPI = (major ?? 0) >= 21 || (major ?? 0) === 20 && (minor ?? 0) >= 6 || (major ?? 0) === 18 && (minor ?? 0) >= 19;
-  const supportsRegister = (
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    !!process.features?.typescript || !!globalThis.module?.register
-  );
-  logger.debug("Runtime detection results:", {
-    nodeVersion: `${major ?? 0}.${minor ?? 0}`,
-    isESM,
-    isCJS,
-    supportsLoaderAPI,
-    supportsRegister,
-    detectionLogic: {
-      noNodeJSGlobals,
-      noModuleSystem,
-      hasRequire,
-      esmCondition: `${noNodeJSGlobals} && ${noModuleSystem} = ${isESM}`,
-      cjsCondition: `require && module && exports && __filename && __dirname = ${isCJS}`
-    },
-    checks: {
-      __filename: typeof __filename,
-      __dirname: typeof __dirname,
-      require: typeof require,
-      module: typeof module,
-      exports: typeof exports,
-      "process.features": process.features,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      "globalThis.module": globalThis.module
-    }
-  });
-  return {
-    isESM,
-    isCJS,
-    nodeVersion: process.versions.node,
-    supportsLoaderAPI,
-    supportsRegister
-  };
-}
-
 // src/preload.ts
-var runtime = detectRuntime();
+var runtime = _chunkNUTJMVD4cjs.detectRuntime.call(void 0, );
 if (runtime.isESM && runtime.supportsLoaderAPI) {
   maybeRegisterESMLoader();
 }
 try {
-  const logLevel = process.env["BRIZZ_LOG_LEVEL"] || DEFAULT_LOG_LEVEL.toString();
+  const logLevel = process.env["BRIZZ_LOG_LEVEL"] || _chunkJB6MA2RVcjs.DEFAULT_LOG_LEVEL.toString();
   if (process.env["BRIZZ_DSN"]) {
-    Brizz.initialize({ logLevel, disableNodeSdk: false });
+    _chunkNUTJMVD4cjs.Brizz.initialize({ logLevel, disableNodeSdk: false });
   } else {
-    Brizz.initialize({
+    _chunkNUTJMVD4cjs.Brizz.initialize({
       apiKey: process.env["BRIZZ_API_KEY"],
       baseUrl: process.env["BRIZZ_BASE_URL"],
       appName: process.env["BRIZZ_APP_NAME"] || process.env["OTEL_SERVICE_NAME"],
@@ -2592,7 +110,7 @@ try {
       disableNodeSdk: false
     });
   }
-  logger.info(`SDK auto-initialized for ${runtime.isESM ? "ESM" : "CJS"} runtime`);
+  _chunkJB6MA2RVcjs.logger.info(`SDK auto-initialized for ${runtime.isESM ? "ESM" : "CJS"} runtime`);
 } catch (error) {
-  logger.warn("Failed to auto-initialize SDK:", { error });
+  _chunkJB6MA2RVcjs.logger.warn("Failed to auto-initialize SDK:", { error });
 }