braintrust 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,8 +1,3197 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20;var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29; var _class30; var _class31;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkCDBUTZMHjs = require('./chunk-CDBUTZMH.js');
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+function suppressTracing(context2) {
+  return context2.setValue(SUPPRESS_TRACING_KEY, true);
+}
+function isTracingSuppressed(context2) {
+  return context2.getValue(SUPPRESS_TRACING_KEY) === true;
+}
+var SUPPRESS_TRACING_KEY;
+var init_suppress_tracing = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    SUPPRESS_TRACING_KEY = _chunkCDBUTZMHjs.createContextKey.call(void 0, "OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/attributes.js
+function sanitizeAttributes(attributes) {
+  const out = {};
+  if (typeof attributes !== "object" || attributes == null) {
+    return out;
+  }
+  for (const [key, val] of Object.entries(attributes)) {
+    if (!isAttributeKey(key)) {
+      _chunkCDBUTZMHjs.diag.warn(`Invalid attribute key: ${key}`);
+      continue;
+    }
+    if (!isAttributeValue(val)) {
+      _chunkCDBUTZMHjs.diag.warn(`Invalid attribute value set for key: ${key}`);
+      continue;
+    }
+    if (Array.isArray(val)) {
+      out[key] = val.slice();
+    } else {
+      out[key] = val;
+    }
+  }
+  return out;
+}
+function isAttributeKey(key) {
+  return typeof key === "string" && key.length > 0;
+}
+function isAttributeValue(val) {
+  if (val == null) {
+    return true;
+  }
+  if (Array.isArray(val)) {
+    return isHomogeneousAttributeValueArray(val);
+  }
+  return isValidPrimitiveAttributeValue(val);
+}
+function isHomogeneousAttributeValueArray(arr) {
+  let type;
+  for (const element of arr) {
+    if (element == null)
+      continue;
+    if (!type) {
+      if (isValidPrimitiveAttributeValue(element)) {
+        type = typeof element;
+        continue;
+      }
+      return false;
+    }
+    if (typeof element === type) {
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function isValidPrimitiveAttributeValue(val) {
+  switch (typeof val) {
+    case "number":
+    case "boolean":
+    case "string":
+      return true;
+  }
+  return false;
+}
+var init_attributes = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/attributes.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+function loggingErrorHandler() {
+  return (ex) => {
+    _chunkCDBUTZMHjs.diag.error(stringifyException(ex));
+  };
+}
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  const result = {};
+  let current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach((propertyName) => {
+      if (result[propertyName])
+        return;
+      const value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
+var init_logging_error_handler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch (e2) {
+  }
+}
+var delegateHandler;
+var init_global_error_handler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js"() {
+    "use strict";
+    init_logging_error_handler();
+    delegateHandler = loggingErrorHandler();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+var _util = require('util');
+function getNumberFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (isNaN(value)) {
+    _chunkCDBUTZMHjs.diag.warn(`Unknown value ${_util.inspect.call(void 0, raw)} for ${key}, expected a number, using defaults`);
+    return void 0;
+  }
+  return value;
+}
+function getStringFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  return raw;
+}
+var init_environment = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/performance.js
+var _perf_hooks = require('perf_hooks');
+var otperformance;
+var init_performance = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/performance.js"() {
+    "use strict";
+    otperformance = _perf_hooks.performance;
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION;
+var init_version = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/version.js"() {
+    "use strict";
+    VERSION = "2.0.1";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js
+var init_SemanticAttributes = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/SemanticAttributes.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js
+var init_trace = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/trace/index.js"() {
+    "use strict";
+    init_SemanticAttributes();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js
+var init_SemanticResourceAttributes = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/SemanticResourceAttributes.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js
+var init_resource = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/resource/index.js"() {
+    "use strict";
+    init_SemanticResourceAttributes();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
+var ATTR_EXCEPTION_MESSAGE, ATTR_EXCEPTION_STACKTRACE, ATTR_EXCEPTION_TYPE, ATTR_SERVICE_NAME, ATTR_TELEMETRY_SDK_LANGUAGE, TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_VERSION;
+var init_stable_attributes = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js"() {
+    "use strict";
+    ATTR_EXCEPTION_MESSAGE = "exception.message";
+    ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
+    ATTR_EXCEPTION_TYPE = "exception.type";
+    ATTR_SERVICE_NAME = "service.name";
+    ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+    TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS = "nodejs";
+    ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
+    ATTR_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_metrics.js
+var init_stable_metrics = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_metrics.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/index.js
+var init_esm2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.32.0/node_modules/@opentelemetry/semantic-conventions/build/esm/index.js"() {
+    "use strict";
+    init_trace();
+    init_resource();
+    init_stable_attributes();
+    init_stable_metrics();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/semconv.js
+var ATTR_PROCESS_RUNTIME_NAME;
+var init_semconv = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/semconv.js"() {
+    "use strict";
+    ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
+var SDK_INFO;
+var init_sdk_info = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js"() {
+    "use strict";
+    init_version();
+    init_esm2();
+    init_semconv();
+    SDK_INFO = {
+      [ATTR_TELEMETRY_SDK_NAME]: "opentelemetry",
+      [ATTR_PROCESS_RUNTIME_NAME]: "node",
+      [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+      [ATTR_TELEMETRY_SDK_VERSION]: VERSION
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/timer-util.js
+function unrefTimer(timer) {
+  timer.unref();
+}
+var init_timer_util = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/timer-util.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/index.js
+var init_node = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_environment();
+    init_performance();
+    init_sdk_info();
+    init_timer_util();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/index.js
+var init_platform = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/platform/index.js"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/time.js
+function millisToHrTime(epochMillis) {
+  const epochSeconds = epochMillis / 1e3;
+  const seconds = Math.trunc(epochSeconds);
+  const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS);
+  return [seconds, nanos];
+}
+function getTimeOrigin() {
+  let timeOrigin = otperformance.timeOrigin;
+  if (typeof timeOrigin !== "number") {
+    const perf = otperformance;
+    timeOrigin = perf.timing && perf.timing.fetchStart;
+  }
+  return timeOrigin;
+}
+function hrTime(performanceNow) {
+  const timeOrigin = millisToHrTime(getTimeOrigin());
+  const now2 = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
+  return addHrTimes(timeOrigin, now2);
+}
+function hrTimeDuration(startTime, endTime) {
+  let seconds = endTime[0] - startTime[0];
+  let nanos = endTime[1] - startTime[1];
+  if (nanos < 0) {
+    seconds -= 1;
+    nanos += SECOND_TO_NANOSECONDS;
+  }
+  return [seconds, nanos];
+}
+function hrTimeToMicroseconds(time) {
+  return time[0] * 1e6 + time[1] / 1e3;
+}
+function isTimeInputHrTime(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function isTimeInput(value) {
+  return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date;
+}
+function addHrTimes(time1, time2) {
+  const out = [time1[0] + time2[0], time1[1] + time2[1]];
+  if (out[1] >= SECOND_TO_NANOSECONDS) {
+    out[1] -= SECOND_TO_NANOSECONDS;
+    out[0] += 1;
+  }
+  return out;
+}
+var NANOSECOND_DIGITS, NANOSECOND_DIGITS_IN_MILLIS, MILLISECONDS_TO_NANOSECONDS, SECOND_TO_NANOSECONDS;
+var init_time = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/time.js"() {
+    "use strict";
+    init_platform();
+    NANOSECOND_DIGITS = 9;
+    NANOSECOND_DIGITS_IN_MILLIS = 6;
+    MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+    SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+var init_ExportResult = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
+    "use strict";
+    (function(ExportResultCode3) {
+      ExportResultCode3[ExportResultCode3["SUCCESS"] = 0] = "SUCCESS";
+      ExportResultCode3[ExportResultCode3["FAILED"] = 1] = "FAILED";
+    })(ExportResultCode || (ExportResultCode = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) !== objectTag) {
+    return false;
+  }
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function getRawTag(value) {
+  const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  let unmasked = false;
+  try {
+    value[symToStringTag] = void 0;
+    unmasked = true;
+  } catch (e) {
+  }
+  const result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var objectTag, nullTag, undefinedTag, funcProto, funcToString, objectCtorString, getPrototypeOf, objectProto, hasOwnProperty, symToStringTag, nativeObjectToString;
+var init_lodash_merge = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js"() {
+    "use strict";
+    objectTag = "[object Object]";
+    nullTag = "[object Null]";
+    undefinedTag = "[object Undefined]";
+    funcProto = Function.prototype;
+    funcToString = funcProto.toString;
+    objectCtorString = funcToString.call(Object);
+    getPrototypeOf = Object.getPrototypeOf;
+    objectProto = Object.prototype;
+    hasOwnProperty = objectProto.hasOwnProperty;
+    symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+    nativeObjectToString = objectProto.toString;
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/merge.js
+function merge(...args) {
+  let result = args.shift();
+  const objects = /* @__PURE__ */ new WeakMap();
+  while (args.length > 0) {
+    result = mergeTwoObjects(result, args.shift(), 0, objects);
+  }
+  return result;
+}
+function takeValue(value) {
+  if (isArray2(value)) {
+    return value.slice();
+  }
+  return value;
+}
+function mergeTwoObjects(one, two, level = 0, objects) {
+  let result;
+  if (level > MAX_LEVEL) {
+    return void 0;
+  }
+  level++;
+  if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) {
+    result = takeValue(two);
+  } else if (isArray2(one)) {
+    result = one.slice();
+    if (isArray2(two)) {
+      for (let i = 0, j = two.length; i < j; i++) {
+        result.push(takeValue(two[i]));
+      }
+    } else if (isObject2(two)) {
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        result[key] = takeValue(two[key]);
+      }
+    }
+  } else if (isObject2(one)) {
+    if (isObject2(two)) {
+      if (!shouldMerge(one, two)) {
+        return two;
+      }
+      result = Object.assign({}, one);
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        const twoValue = two[key];
+        if (isPrimitive(twoValue)) {
+          if (typeof twoValue === "undefined") {
+            delete result[key];
+          } else {
+            result[key] = twoValue;
+          }
+        } else {
+          const obj1 = result[key];
+          const obj2 = twoValue;
+          if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
+            delete result[key];
+          } else {
+            if (isObject2(obj1) && isObject2(obj2)) {
+              const arr1 = objects.get(obj1) || [];
+              const arr2 = objects.get(obj2) || [];
+              arr1.push({ obj: one, key });
+              arr2.push({ obj: two, key });
+              objects.set(obj1, arr1);
+              objects.set(obj2, arr2);
+            }
+            result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
+          }
+        }
+      }
+    } else {
+      result = two;
+    }
+  }
+  return result;
+}
+function wasObjectReferenced(obj, key, objects) {
+  const arr = objects.get(obj[key]) || [];
+  for (let i = 0, j = arr.length; i < j; i++) {
+    const info = arr[i];
+    if (info.key === key && info.obj === obj) {
+      return true;
+    }
+  }
+  return false;
+}
+function isArray2(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject2(value) {
+  return !isPrimitive(value) && !isArray2(value) && !isFunction(value) && typeof value === "object";
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
+}
+function shouldMerge(one, two) {
+  if (!isPlainObject(one) || !isPlainObject(two)) {
+    return false;
+  }
+  return true;
+}
+var MAX_LEVEL;
+var init_merge = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/merge.js"() {
+    "use strict";
+    init_lodash_merge();
+    MAX_LEVEL = 20;
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred;
+var init_promise = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/promise.js"() {
+    "use strict";
+    Deferred = class {
+      
+      
+      
+      constructor() {
+        this._promise = new Promise((resolve, reject2) => {
+          this._resolve = resolve;
+          this._reject = reject2;
+        });
+      }
+      get promise() {
+        return this._promise;
+      }
+      resolve(val) {
+        this._resolve(val);
+      }
+      reject(err) {
+        this._reject(err);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var BindOnceFuture;
+var init_callback = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/utils/callback.js"() {
+    "use strict";
+    init_promise();
+    BindOnceFuture = (_class = class {
+      
+      
+      __init() {this._isCalled = false}
+      __init2() {this._deferred = new Deferred()}
+      constructor(_callback, _that) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+        this._callback = _callback;
+        this._that = _that;
+      }
+      get isCalled() {
+        return this._isCalled;
+      }
+      get promise() {
+        return this._deferred.promise;
+      }
+      call(...args) {
+        if (!this._isCalled) {
+          this._isCalled = true;
+          try {
+            Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err));
+          } catch (err) {
+            this._deferred.reject(err);
+          }
+        }
+        return this._deferred.promise;
+      }
+    }, _class);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+function _export(exporter, arg) {
+  return new Promise((resolve) => {
+    _chunkCDBUTZMHjs.context.with(suppressTracing(_chunkCDBUTZMHjs.context.active()), () => {
+      exporter.export(arg, (result) => {
+        resolve(result);
+      });
+    });
+  });
+}
+var init_exporter = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/internal/exporter.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_suppress_tracing();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/index.js
+var internal;
+var init_esm3 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/index.js"() {
+    "use strict";
+    init_attributes();
+    init_global_error_handler();
+    init_time();
+    init_ExportResult();
+    init_platform();
+    init_suppress_tracing();
+    init_merge();
+    init_callback();
+    init_exporter();
+    internal = {
+      _export
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/platform/node/default-service-name.js
+function defaultServiceName() {
+  return `unknown_service:${process.argv0}`;
+}
+var init_default_service_name = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/platform/node/default-service-name.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/platform/node/index.js
+var init_node2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_default_service_name();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/platform/index.js
+var init_platform2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/platform/index.js"() {
+    "use strict";
+    init_node2();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/utils.js
+var isPromiseLike;
+var init_utils = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/utils.js"() {
+    "use strict";
+    isPromiseLike = (val) => {
+      return val !== null && typeof val === "object" && typeof val.then === "function";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+function resourceFromAttributes(attributes) {
+  return ResourceImpl.FromAttributeList(Object.entries(attributes));
+}
+function defaultResource() {
+  return resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: defaultServiceName(),
+    [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE],
+    [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[ATTR_TELEMETRY_SDK_NAME],
+    [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[ATTR_TELEMETRY_SDK_VERSION]
+  });
+}
+function guardedRawAttributes(attributes) {
+  return attributes.map(([k, v]) => {
+    if (isPromiseLike(v)) {
+      return [
+        k,
+        v.catch((err) => {
+          _chunkCDBUTZMHjs.diag.debug("promise rejection for resource attribute: %s - %s", k, err);
+          return void 0;
+        })
+      ];
+    }
+    return [k, v];
+  });
+}
+var ResourceImpl;
+var init_ResourceImpl = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_esm3();
+    init_esm2();
+    init_platform2();
+    init_utils();
+    ResourceImpl = (_class2 = class _ResourceImpl {
+      
+      __init3() {this._asyncAttributesPending = false}
+      
+      static FromAttributeList(attributes) {
+        const res = new _ResourceImpl({});
+        res._rawAttributes = guardedRawAttributes(attributes);
+        res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+        return res;
+      }
+      constructor(resource) {;_class2.prototype.__init3.call(this);
+        const attributes = _nullishCoalesce(resource.attributes, () => ( {}));
+        this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+          if (isPromiseLike(v)) {
+            this._asyncAttributesPending = true;
+          }
+          return [k, v];
+        });
+        this._rawAttributes = guardedRawAttributes(this._rawAttributes);
+      }
+      get asyncAttributesPending() {
+        return this._asyncAttributesPending;
+      }
+      async waitForAsyncAttributes() {
+        if (!this.asyncAttributesPending) {
+          return;
+        }
+        for (let i = 0; i < this._rawAttributes.length; i++) {
+          const [k, v] = this._rawAttributes[i];
+          this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+        }
+        this._asyncAttributesPending = false;
+      }
+      get attributes() {
+        if (this.asyncAttributesPending) {
+          _chunkCDBUTZMHjs.diag.error("Accessing resource attributes before async attributes settled");
+        }
+        if (this._memoizedAttributes) {
+          return this._memoizedAttributes;
+        }
+        const attrs = {};
+        for (const [k, v] of this._rawAttributes) {
+          if (isPromiseLike(v)) {
+            _chunkCDBUTZMHjs.diag.debug(`Unsettled resource attribute ${k} skipped`);
+            continue;
+          }
+          if (v != null) {
+            attrs[k] ??= v;
+          }
+        }
+        if (!this._asyncAttributesPending) {
+          this._memoizedAttributes = attrs;
+        }
+        return attrs;
+      }
+      getRawAttributes() {
+        return this._rawAttributes;
+      }
+      merge(resource) {
+        if (resource == null)
+          return this;
+        return _ResourceImpl.FromAttributeList([
+          ...resource.getRawAttributes(),
+          ...this.getRawAttributes()
+        ]);
+      }
+    }, _class2);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/index.js
+var init_esm4 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+resources@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/resources/build/esm/index.js"() {
+    "use strict";
+    init_ResourceImpl();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js
+var ExceptionEventName;
+var init_enums = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js"() {
+    "use strict";
+    ExceptionEventName = "exception";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js
+var SpanImpl2;
+var init_Span = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_esm3();
+    init_esm2();
+    init_enums();
+    SpanImpl2 = (_class3 = class {
+      // Below properties are included to implement ReadableSpan for export
+      // purposes but are not intended to be written-to directly.
+      
+      
+      
+      __init4() {this.attributes = {}}
+      __init5() {this.links = []}
+      __init6() {this.events = []}
+      
+      
+      
+      __init7() {this._droppedAttributesCount = 0}
+      __init8() {this._droppedEventsCount = 0}
+      __init9() {this._droppedLinksCount = 0}
+      
+      __init10() {this.status = {
+        code: _chunkCDBUTZMHjs.SpanStatusCode.UNSET
+      }}
+      __init11() {this.endTime = [0, 0]}
+      __init12() {this._ended = false}
+      __init13() {this._duration = [-1, -1]}
+      
+      
+      
+      
+      
+      
+      /**
+       * Constructs a new SpanImpl instance.
+       */
+      constructor(opts) {;_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);
+        const now2 = Date.now();
+        this._spanContext = opts.spanContext;
+        this._performanceStartTime = otperformance.now();
+        this._performanceOffset = now2 - (this._performanceStartTime + getTimeOrigin());
+        this._startTimeProvided = opts.startTime != null;
+        this._spanLimits = opts.spanLimits;
+        this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit || 0;
+        this._spanProcessor = opts.spanProcessor;
+        this.name = opts.name;
+        this.parentSpanContext = opts.parentSpanContext;
+        this.kind = opts.kind;
+        this.links = opts.links || [];
+        this.startTime = this._getTime(_nullishCoalesce(opts.startTime, () => ( now2)));
+        this.resource = opts.resource;
+        this.instrumentationScope = opts.scope;
+        if (opts.attributes != null) {
+          this.setAttributes(opts.attributes);
+        }
+        this._spanProcessor.onStart(this, opts.context);
+      }
+      spanContext() {
+        return this._spanContext;
+      }
+      setAttribute(key, value) {
+        if (value == null || this._isSpanEnded())
+          return this;
+        if (key.length === 0) {
+          _chunkCDBUTZMHjs.diag.warn(`Invalid attribute key: ${key}`);
+          return this;
+        }
+        if (!isAttributeValue(value)) {
+          _chunkCDBUTZMHjs.diag.warn(`Invalid attribute value set for key: ${key}`);
+          return this;
+        }
+        const { attributeCountLimit } = this._spanLimits;
+        if (attributeCountLimit !== void 0 && Object.keys(this.attributes).length >= attributeCountLimit && !Object.prototype.hasOwnProperty.call(this.attributes, key)) {
+          this._droppedAttributesCount++;
+          return this;
+        }
+        this.attributes[key] = this._truncateToSize(value);
+        return this;
+      }
+      setAttributes(attributes) {
+        for (const [k, v] of Object.entries(attributes)) {
+          this.setAttribute(k, v);
+        }
+        return this;
+      }
+      /**
+       *
+       * @param name Span Name
+       * @param [attributesOrStartTime] Span attributes or start time
+       *     if type is {@type TimeInput} and 3rd param is undefined
+       * @param [timeStamp] Specified time stamp for the event
+       */
+      addEvent(name, attributesOrStartTime, timeStamp) {
+        if (this._isSpanEnded())
+          return this;
+        const { eventCountLimit } = this._spanLimits;
+        if (eventCountLimit === 0) {
+          _chunkCDBUTZMHjs.diag.warn("No events allowed.");
+          this._droppedEventsCount++;
+          return this;
+        }
+        if (eventCountLimit !== void 0 && this.events.length >= eventCountLimit) {
+          if (this._droppedEventsCount === 0) {
+            _chunkCDBUTZMHjs.diag.debug("Dropping extra events.");
+          }
+          this.events.shift();
+          this._droppedEventsCount++;
+        }
+        if (isTimeInput(attributesOrStartTime)) {
+          if (!isTimeInput(timeStamp)) {
+            timeStamp = attributesOrStartTime;
+          }
+          attributesOrStartTime = void 0;
+        }
+        const attributes = sanitizeAttributes(attributesOrStartTime);
+        this.events.push({
+          name,
+          attributes,
+          time: this._getTime(timeStamp),
+          droppedAttributesCount: 0
+        });
+        return this;
+      }
+      addLink(link) {
+        this.links.push(link);
+        return this;
+      }
+      addLinks(links) {
+        this.links.push(...links);
+        return this;
+      }
+      setStatus(status) {
+        if (this._isSpanEnded())
+          return this;
+        this.status = { ...status };
+        if (this.status.message != null && typeof status.message !== "string") {
+          _chunkCDBUTZMHjs.diag.warn(`Dropping invalid status.message of type '${typeof status.message}', expected 'string'`);
+          delete this.status.message;
+        }
+        return this;
+      }
+      updateName(name) {
+        if (this._isSpanEnded())
+          return this;
+        this.name = name;
+        return this;
+      }
+      end(endTime) {
+        if (this._isSpanEnded()) {
+          _chunkCDBUTZMHjs.diag.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
+          return;
+        }
+        this._ended = true;
+        this.endTime = this._getTime(endTime);
+        this._duration = hrTimeDuration(this.startTime, this.endTime);
+        if (this._duration[0] < 0) {
+          _chunkCDBUTZMHjs.diag.warn("Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.", this.startTime, this.endTime);
+          this.endTime = this.startTime.slice();
+          this._duration = [0, 0];
+        }
+        if (this._droppedEventsCount > 0) {
+          _chunkCDBUTZMHjs.diag.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
+        }
+        this._spanProcessor.onEnd(this);
+      }
+      _getTime(inp) {
+        if (typeof inp === "number" && inp <= otperformance.now()) {
+          return hrTime(inp + this._performanceOffset);
+        }
+        if (typeof inp === "number") {
+          return millisToHrTime(inp);
+        }
+        if (inp instanceof Date) {
+          return millisToHrTime(inp.getTime());
+        }
+        if (isTimeInputHrTime(inp)) {
+          return inp;
+        }
+        if (this._startTimeProvided) {
+          return millisToHrTime(Date.now());
+        }
+        const msDuration = otperformance.now() - this._performanceStartTime;
+        return addHrTimes(this.startTime, millisToHrTime(msDuration));
+      }
+      isRecording() {
+        return this._ended === false;
+      }
+      recordException(exception, time) {
+        const attributes = {};
+        if (typeof exception === "string") {
+          attributes[ATTR_EXCEPTION_MESSAGE] = exception;
+        } else if (exception) {
+          if (exception.code) {
+            attributes[ATTR_EXCEPTION_TYPE] = exception.code.toString();
+          } else if (exception.name) {
+            attributes[ATTR_EXCEPTION_TYPE] = exception.name;
+          }
+          if (exception.message) {
+            attributes[ATTR_EXCEPTION_MESSAGE] = exception.message;
+          }
+          if (exception.stack) {
+            attributes[ATTR_EXCEPTION_STACKTRACE] = exception.stack;
+          }
+        }
+        if (attributes[ATTR_EXCEPTION_TYPE] || attributes[ATTR_EXCEPTION_MESSAGE]) {
+          this.addEvent(ExceptionEventName, attributes, time);
+        } else {
+          _chunkCDBUTZMHjs.diag.warn(`Failed to record an exception ${exception}`);
+        }
+      }
+      get duration() {
+        return this._duration;
+      }
+      get ended() {
+        return this._ended;
+      }
+      get droppedAttributesCount() {
+        return this._droppedAttributesCount;
+      }
+      get droppedEventsCount() {
+        return this._droppedEventsCount;
+      }
+      get droppedLinksCount() {
+        return this._droppedLinksCount;
+      }
+      _isSpanEnded() {
+        if (this._ended) {
+          const error2 = new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
+          _chunkCDBUTZMHjs.diag.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error2);
+        }
+        return this._ended;
+      }
+      // Utility function to truncate given value within size
+      // for value type of string, will truncate to given limit
+      // for type of non-string, will return same value
+      _truncateToLimitUtil(value, limit) {
+        if (value.length <= limit) {
+          return value;
+        }
+        return value.substring(0, limit);
+      }
+      /**
+       * If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then
+       * return string with truncated to {@code attributeValueLengthLimit} characters
+       *
+       * If the given attribute value is array of strings then
+       * return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters
+       *
+       * Otherwise return same Attribute {@code value}
+       *
+       * @param value Attribute value
+       * @returns truncated attribute value if required, otherwise same value
+       */
+      _truncateToSize(value) {
+        const limit = this._attributeValueLengthLimit;
+        if (limit <= 0) {
+          _chunkCDBUTZMHjs.diag.warn(`Attribute value limit must be positive, got ${limit}`);
+          return value;
+        }
+        if (typeof value === "string") {
+          return this._truncateToLimitUtil(value, limit);
+        }
+        if (Array.isArray(value)) {
+          return value.map((val) => typeof val === "string" ? this._truncateToLimitUtil(val, limit) : val);
+        }
+        return value;
+      }
+    }, _class3);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js
+var SamplingDecision2;
+var init_Sampler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js"() {
+    "use strict";
+    (function(SamplingDecision3) {
+      SamplingDecision3[SamplingDecision3["NOT_RECORD"] = 0] = "NOT_RECORD";
+      SamplingDecision3[SamplingDecision3["RECORD"] = 1] = "RECORD";
+      SamplingDecision3[SamplingDecision3["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+    })(SamplingDecision2 || (SamplingDecision2 = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js
+var AlwaysOffSampler;
+var init_AlwaysOffSampler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js"() {
+    "use strict";
+    init_Sampler();
+    AlwaysOffSampler = class {
+      shouldSample() {
+        return {
+          decision: SamplingDecision2.NOT_RECORD
+        };
+      }
+      toString() {
+        return "AlwaysOffSampler";
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js
+var AlwaysOnSampler;
+var init_AlwaysOnSampler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js"() {
+    "use strict";
+    init_Sampler();
+    AlwaysOnSampler = class {
+      shouldSample() {
+        return {
+          decision: SamplingDecision2.RECORD_AND_SAMPLED
+        };
+      }
+      toString() {
+        return "AlwaysOnSampler";
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js
+var ParentBasedSampler;
+var init_ParentBasedSampler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_esm3();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    ParentBasedSampler = class {
+      
+      
+      
+      
+      
+      constructor(config) {
+        this._root = config.root;
+        if (!this._root) {
+          globalErrorHandler(new Error("ParentBasedSampler must have a root sampler configured"));
+          this._root = new AlwaysOnSampler();
+        }
+        this._remoteParentSampled = _nullishCoalesce(config.remoteParentSampled, () => ( new AlwaysOnSampler()));
+        this._remoteParentNotSampled = _nullishCoalesce(config.remoteParentNotSampled, () => ( new AlwaysOffSampler()));
+        this._localParentSampled = _nullishCoalesce(config.localParentSampled, () => ( new AlwaysOnSampler()));
+        this._localParentNotSampled = _nullishCoalesce(config.localParentNotSampled, () => ( new AlwaysOffSampler()));
+      }
+      shouldSample(context2, traceId, spanName, spanKind, attributes, links) {
+        const parentContext = _chunkCDBUTZMHjs.trace.getSpanContext(context2);
+        if (!parentContext || !_chunkCDBUTZMHjs.isSpanContextValid.call(void 0, parentContext)) {
+          return this._root.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+        }
+        if (parentContext.isRemote) {
+          if (parentContext.traceFlags & _chunkCDBUTZMHjs.TraceFlags.SAMPLED) {
+            return this._remoteParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+          }
+          return this._remoteParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+        }
+        if (parentContext.traceFlags & _chunkCDBUTZMHjs.TraceFlags.SAMPLED) {
+          return this._localParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+        }
+        return this._localParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+      }
+      toString() {
+        return `ParentBased{root=${this._root.toString()}, remoteParentSampled=${this._remoteParentSampled.toString()}, remoteParentNotSampled=${this._remoteParentNotSampled.toString()}, localParentSampled=${this._localParentSampled.toString()}, localParentNotSampled=${this._localParentNotSampled.toString()}}`;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js
+var TraceIdRatioBasedSampler;
+var init_TraceIdRatioBasedSampler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_Sampler();
+    TraceIdRatioBasedSampler = class {
+      
+      
+      constructor(_ratio = 0) {
+        this._ratio = _ratio;
+        this._ratio = this._normalize(_ratio);
+        this._upperBound = Math.floor(this._ratio * 4294967295);
+      }
+      shouldSample(context2, traceId) {
+        return {
+          decision: _chunkCDBUTZMHjs.isValidTraceId.call(void 0, traceId) && this._accumulate(traceId) < this._upperBound ? SamplingDecision2.RECORD_AND_SAMPLED : SamplingDecision2.NOT_RECORD
+        };
+      }
+      toString() {
+        return `TraceIdRatioBased{${this._ratio}}`;
+      }
+      _normalize(ratio) {
+        if (typeof ratio !== "number" || isNaN(ratio))
+          return 0;
+        return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio;
+      }
+      _accumulate(traceId) {
+        let accumulation = 0;
+        for (let i = 0; i < traceId.length / 8; i++) {
+          const pos = i * 8;
+          const part = parseInt(traceId.slice(pos, pos + 8), 16);
+          accumulation = (accumulation ^ part) >>> 0;
+        }
+        return accumulation;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js
+function loadDefaultConfig() {
+  return {
+    sampler: buildSamplerFromEnv(),
+    forceFlushTimeoutMillis: 3e4,
+    generalLimits: {
+      attributeValueLengthLimit: _nullishCoalesce(getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT"), () => ( Infinity)),
+      attributeCountLimit: _nullishCoalesce(getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT"), () => ( 128))
+    },
+    spanLimits: {
+      attributeValueLengthLimit: _nullishCoalesce(getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT"), () => ( Infinity)),
+      attributeCountLimit: _nullishCoalesce(getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT"), () => ( 128)),
+      linkCountLimit: _nullishCoalesce(getNumberFromEnv("OTEL_SPAN_LINK_COUNT_LIMIT"), () => ( 128)),
+      eventCountLimit: _nullishCoalesce(getNumberFromEnv("OTEL_SPAN_EVENT_COUNT_LIMIT"), () => ( 128)),
+      attributePerEventCountLimit: _nullishCoalesce(getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT"), () => ( 128)),
+      attributePerLinkCountLimit: _nullishCoalesce(getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT"), () => ( 128))
+    }
+  };
+}
+function buildSamplerFromEnv() {
+  const sampler = _nullishCoalesce(getStringFromEnv("OTEL_TRACES_SAMPLER"), () => ( "parentbased_always_on"));
+  switch (sampler) {
+    case "always_on":
+      return new AlwaysOnSampler();
+    case "always_off":
+      return new AlwaysOffSampler();
+    case "parentbased_always_on":
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+    case "parentbased_always_off":
+      return new ParentBasedSampler({
+        root: new AlwaysOffSampler()
+      });
+    case "traceidratio":
+      return new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv());
+    case "parentbased_traceidratio":
+      return new ParentBasedSampler({
+        root: new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv())
+      });
+    default:
+      _chunkCDBUTZMHjs.diag.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${"parentbased_always_on"}".`);
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+  }
+}
+function getSamplerProbabilityFromEnv() {
+  const probability = getNumberFromEnv("OTEL_TRACES_SAMPLER_ARG");
+  if (probability == null) {
+    _chunkCDBUTZMHjs.diag.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`);
+    return DEFAULT_RATIO;
+  }
+  if (probability < 0 || probability > 1) {
+    _chunkCDBUTZMHjs.diag.error(`OTEL_TRACES_SAMPLER_ARG=${probability} was given, but it is out of range ([0..1]), defaulting to ${DEFAULT_RATIO}.`);
+    return DEFAULT_RATIO;
+  }
+  return probability;
+}
+var DEFAULT_RATIO;
+var init_config = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_esm3();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    init_ParentBasedSampler();
+    init_TraceIdRatioBasedSampler();
+    DEFAULT_RATIO = 1;
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/utility.js
+function mergeConfig(userConfig) {
+  const perInstanceDefaults = {
+    sampler: buildSamplerFromEnv()
+  };
+  const DEFAULT_CONFIG = loadDefaultConfig();
+  const target = Object.assign({}, DEFAULT_CONFIG, perInstanceDefaults, userConfig);
+  target.generalLimits = Object.assign({}, DEFAULT_CONFIG.generalLimits, userConfig.generalLimits || {});
+  target.spanLimits = Object.assign({}, DEFAULT_CONFIG.spanLimits, userConfig.spanLimits || {});
+  return target;
+}
+function reconfigureLimits(userConfig) {
+  const spanLimits = Object.assign({}, userConfig.spanLimits);
+  spanLimits.attributeCountLimit = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([userConfig, 'access', _2 => _2.spanLimits, 'optionalAccess', _3 => _3.attributeCountLimit]), () => ( _optionalChain([userConfig, 'access', _4 => _4.generalLimits, 'optionalAccess', _5 => _5.attributeCountLimit]))), () => ( getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT"))), () => ( getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT"))), () => ( DEFAULT_ATTRIBUTE_COUNT_LIMIT));
+  spanLimits.attributeValueLengthLimit = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([userConfig, 'access', _6 => _6.spanLimits, 'optionalAccess', _7 => _7.attributeValueLengthLimit]), () => ( _optionalChain([userConfig, 'access', _8 => _8.generalLimits, 'optionalAccess', _9 => _9.attributeValueLengthLimit]))), () => ( getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT"))), () => ( getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT"))), () => ( DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT));
+  return Object.assign({}, userConfig, { spanLimits });
+}
+var DEFAULT_ATTRIBUTE_COUNT_LIMIT, DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+var init_utility = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/utility.js"() {
+    "use strict";
+    init_config();
+    init_esm3();
+    DEFAULT_ATTRIBUTE_COUNT_LIMIT = 128;
+    DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = Infinity;
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
+var BatchSpanProcessorBase;
+var init_BatchSpanProcessorBase = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_esm3();
+    BatchSpanProcessorBase = (_class4 = class {
+      
+      
+      
+      
+      
+      __init14() {this._isExporting = false}
+      __init15() {this._finishedSpans = []}
+      
+      
+      __init16() {this._droppedSpansCount = 0}
+      constructor(_exporter, config) {;_class4.prototype.__init14.call(this);_class4.prototype.__init15.call(this);_class4.prototype.__init16.call(this);
+        this._exporter = _exporter;
+        this._maxExportBatchSize = typeof _optionalChain([config, 'optionalAccess', _10 => _10.maxExportBatchSize]) === "number" ? config.maxExportBatchSize : _nullishCoalesce(getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE"), () => ( 512));
+        this._maxQueueSize = typeof _optionalChain([config, 'optionalAccess', _11 => _11.maxQueueSize]) === "number" ? config.maxQueueSize : _nullishCoalesce(getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE"), () => ( 2048));
+        this._scheduledDelayMillis = typeof _optionalChain([config, 'optionalAccess', _12 => _12.scheduledDelayMillis]) === "number" ? config.scheduledDelayMillis : _nullishCoalesce(getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY"), () => ( 5e3));
+        this._exportTimeoutMillis = typeof _optionalChain([config, 'optionalAccess', _13 => _13.exportTimeoutMillis]) === "number" ? config.exportTimeoutMillis : _nullishCoalesce(getNumberFromEnv("OTEL_BSP_EXPORT_TIMEOUT"), () => ( 3e4));
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        if (this._maxExportBatchSize > this._maxQueueSize) {
+          _chunkCDBUTZMHjs.diag.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+          this._maxExportBatchSize = this._maxQueueSize;
+        }
+      }
+      forceFlush() {
+        if (this._shutdownOnce.isCalled) {
+          return this._shutdownOnce.promise;
+        }
+        return this._flushAll();
+      }
+      // does nothing.
+      onStart(_span, _parentContext) {
+      }
+      onEnd(span) {
+        if (this._shutdownOnce.isCalled) {
+          return;
+        }
+        if ((span.spanContext().traceFlags & _chunkCDBUTZMHjs.TraceFlags.SAMPLED) === 0) {
+          return;
+        }
+        this._addToBuffer(span);
+      }
+      shutdown() {
+        return this._shutdownOnce.call();
+      }
+      _shutdown() {
+        return Promise.resolve().then(() => {
+          return this.onShutdown();
+        }).then(() => {
+          return this._flushAll();
+        }).then(() => {
+          return this._exporter.shutdown();
+        });
+      }
+      /** Add a span in the buffer. */
+      _addToBuffer(span) {
+        if (this._finishedSpans.length >= this._maxQueueSize) {
+          if (this._droppedSpansCount === 0) {
+            _chunkCDBUTZMHjs.diag.debug("maxQueueSize reached, dropping spans");
+          }
+          this._droppedSpansCount++;
+          return;
+        }
+        if (this._droppedSpansCount > 0) {
+          _chunkCDBUTZMHjs.diag.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
+          this._droppedSpansCount = 0;
+        }
+        this._finishedSpans.push(span);
+        this._maybeStartTimer();
+      }
+      /**
+       * Send all spans to the exporter respecting the batch size limit
+       * This function is used only on forceFlush or shutdown,
+       * for all other cases _flush should be used
+       * */
+      _flushAll() {
+        return new Promise((resolve, reject2) => {
+          const promises = [];
+          const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
+          for (let i = 0, j = count; i < j; i++) {
+            promises.push(this._flushOneBatch());
+          }
+          Promise.all(promises).then(() => {
+            resolve();
+          }).catch(reject2);
+        });
+      }
+      _flushOneBatch() {
+        this._clearTimer();
+        if (this._finishedSpans.length === 0) {
+          return Promise.resolve();
+        }
+        return new Promise((resolve, reject2) => {
+          const timer = setTimeout(() => {
+            reject2(new Error("Timeout"));
+          }, this._exportTimeoutMillis);
+          _chunkCDBUTZMHjs.context.with(suppressTracing(_chunkCDBUTZMHjs.context.active()), () => {
+            let spans;
+            if (this._finishedSpans.length <= this._maxExportBatchSize) {
+              spans = this._finishedSpans;
+              this._finishedSpans = [];
+            } else {
+              spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
+            }
+            const doExport = () => this._exporter.export(spans, (result) => {
+              clearTimeout(timer);
+              if (result.code === ExportResultCode.SUCCESS) {
+                resolve();
+              } else {
+                reject2(_nullishCoalesce(result.error, () => ( new Error("BatchSpanProcessor: span export failed"))));
+              }
+            });
+            let pendingResources = null;
+            for (let i = 0, len = spans.length; i < len; i++) {
+              const span = spans[i];
+              if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) {
+                pendingResources ??= [];
+                pendingResources.push(span.resource.waitForAsyncAttributes());
+              }
+            }
+            if (pendingResources === null) {
+              doExport();
+            } else {
+              Promise.all(pendingResources).then(doExport, (err) => {
+                globalErrorHandler(err);
+                reject2(err);
+              });
+            }
+          });
+        });
+      }
+      _maybeStartTimer() {
+        if (this._isExporting)
+          return;
+        const flush2 = () => {
+          this._isExporting = true;
+          this._flushOneBatch().finally(() => {
+            this._isExporting = false;
+            if (this._finishedSpans.length > 0) {
+              this._clearTimer();
+              this._maybeStartTimer();
+            }
+          }).catch((e) => {
+            this._isExporting = false;
+            globalErrorHandler(e);
+          });
+        };
+        if (this._finishedSpans.length >= this._maxExportBatchSize) {
+          return flush2();
+        }
+        if (this._timer !== void 0)
+          return;
+        this._timer = setTimeout(() => flush2(), this._scheduledDelayMillis);
+        unrefTimer(this._timer);
+      }
+      _clearTimer() {
+        if (this._timer !== void 0) {
+          clearTimeout(this._timer);
+          this._timer = void 0;
+        }
+      }
+    }, _class4);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js
+var BatchSpanProcessor;
+var init_BatchSpanProcessor = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js"() {
+    "use strict";
+    init_BatchSpanProcessorBase();
+    BatchSpanProcessor = class extends BatchSpanProcessorBase {
+      onShutdown() {
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js
+function getIdGenerator(bytes) {
+  return function generateId() {
+    for (let i = 0; i < bytes / 4; i++) {
+      SHARED_BUFFER.writeUInt32BE(Math.random() * 2 ** 32 >>> 0, i * 4);
+    }
+    for (let i = 0; i < bytes; i++) {
+      if (SHARED_BUFFER[i] > 0) {
+        break;
+      } else if (i === bytes - 1) {
+        SHARED_BUFFER[bytes - 1] = 1;
+      }
+    }
+    return SHARED_BUFFER.toString("hex", 0, bytes);
+  };
+}
+var SPAN_ID_BYTES, TRACE_ID_BYTES, RandomIdGenerator, SHARED_BUFFER;
+var init_RandomIdGenerator = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js"() {
+    "use strict";
+    SPAN_ID_BYTES = 8;
+    TRACE_ID_BYTES = 16;
+    RandomIdGenerator = (_class5 = class {constructor() { _class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this); }
+      /**
+       * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
+       * characters corresponding to 128 bits.
+       */
+      __init17() {this.generateTraceId = getIdGenerator(TRACE_ID_BYTES)}
+      /**
+       * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
+       * characters corresponding to 64 bits.
+       */
+      __init18() {this.generateSpanId = getIdGenerator(SPAN_ID_BYTES)}
+    }, _class5);
+    SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/index.js
+var init_node3 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_BatchSpanProcessor();
+    init_RandomIdGenerator();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/index.js
+var init_platform3 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/index.js"() {
+    "use strict";
+    init_node3();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js
+var Tracer;
+var init_Tracer = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_esm3();
+    init_Span();
+    init_utility();
+    init_platform3();
+    Tracer = class {
+      
+      
+      
+      
+      
+      
+      
+      /**
+       * Constructs a new Tracer instance.
+       */
+      constructor(instrumentationScope, config, resource, spanProcessor) {
+        const localConfig = mergeConfig(config);
+        this._sampler = localConfig.sampler;
+        this._generalLimits = localConfig.generalLimits;
+        this._spanLimits = localConfig.spanLimits;
+        this._idGenerator = config.idGenerator || new RandomIdGenerator();
+        this._resource = resource;
+        this._spanProcessor = spanProcessor;
+        this.instrumentationScope = instrumentationScope;
+      }
+      /**
+       * Starts a new Span or returns the default NoopSpan based on the sampling
+       * decision.
+       */
+      startSpan(name, options = {}, context2 = _chunkCDBUTZMHjs.context.active()) {
+        if (options.root) {
+          context2 = _chunkCDBUTZMHjs.trace.deleteSpan(context2);
+        }
+        const parentSpan = _chunkCDBUTZMHjs.trace.getSpan(context2);
+        if (isTracingSuppressed(context2)) {
+          _chunkCDBUTZMHjs.diag.debug("Instrumentation suppressed, returning Noop Span");
+          const nonRecordingSpan = _chunkCDBUTZMHjs.trace.wrapSpanContext(_chunkCDBUTZMHjs.INVALID_SPAN_CONTEXT);
+          return nonRecordingSpan;
+        }
+        const parentSpanContext = _optionalChain([parentSpan, 'optionalAccess', _14 => _14.spanContext, 'call', _15 => _15()]);
+        const spanId = this._idGenerator.generateSpanId();
+        let validParentSpanContext;
+        let traceId;
+        let traceState;
+        if (!parentSpanContext || !_chunkCDBUTZMHjs.trace.isSpanContextValid(parentSpanContext)) {
+          traceId = this._idGenerator.generateTraceId();
+        } else {
+          traceId = parentSpanContext.traceId;
+          traceState = parentSpanContext.traceState;
+          validParentSpanContext = parentSpanContext;
+        }
+        const spanKind = _nullishCoalesce(options.kind, () => ( _chunkCDBUTZMHjs.SpanKind.INTERNAL));
+        const links = (_nullishCoalesce(options.links, () => ( []))).map((link) => {
+          return {
+            context: link.context,
+            attributes: sanitizeAttributes(link.attributes)
+          };
+        });
+        const attributes = sanitizeAttributes(options.attributes);
+        const samplingResult = this._sampler.shouldSample(context2, traceId, name, spanKind, attributes, links);
+        traceState = _nullishCoalesce(samplingResult.traceState, () => ( traceState));
+        const traceFlags = samplingResult.decision === _chunkCDBUTZMHjs.SamplingDecision.RECORD_AND_SAMPLED ? _chunkCDBUTZMHjs.TraceFlags.SAMPLED : _chunkCDBUTZMHjs.TraceFlags.NONE;
+        const spanContext = { traceId, spanId, traceFlags, traceState };
+        if (samplingResult.decision === _chunkCDBUTZMHjs.SamplingDecision.NOT_RECORD) {
+          _chunkCDBUTZMHjs.diag.debug("Recording is off, propagating context in a non-recording span");
+          const nonRecordingSpan = _chunkCDBUTZMHjs.trace.wrapSpanContext(spanContext);
+          return nonRecordingSpan;
+        }
+        const initAttributes = sanitizeAttributes(Object.assign(attributes, samplingResult.attributes));
+        const span = new SpanImpl2({
+          resource: this._resource,
+          scope: this.instrumentationScope,
+          context: context2,
+          spanContext,
+          name,
+          kind: spanKind,
+          links,
+          parentSpanContext: validParentSpanContext,
+          attributes: initAttributes,
+          startTime: options.startTime,
+          spanProcessor: this._spanProcessor,
+          spanLimits: this._spanLimits
+        });
+        return span;
+      }
+      startActiveSpan(name, arg2, arg3, arg4) {
+        let opts;
+        let ctx;
+        let fn;
+        if (arguments.length < 2) {
+          return;
+        } else if (arguments.length === 2) {
+          fn = arg2;
+        } else if (arguments.length === 3) {
+          opts = arg2;
+          fn = arg3;
+        } else {
+          opts = arg2;
+          ctx = arg3;
+          fn = arg4;
+        }
+        const parentContext = _nullishCoalesce(ctx, () => ( _chunkCDBUTZMHjs.context.active()));
+        const span = this.startSpan(name, opts, parentContext);
+        const contextWithSpanSet = _chunkCDBUTZMHjs.trace.setSpan(parentContext, span);
+        return _chunkCDBUTZMHjs.context.with(contextWithSpanSet, fn, void 0, span);
+      }
+      /** Returns the active {@link GeneralLimits}. */
+      getGeneralLimits() {
+        return this._generalLimits;
+      }
+      /** Returns the active {@link SpanLimits}. */
+      getSpanLimits() {
+        return this._spanLimits;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js
+var MultiSpanProcessor;
+var init_MultiSpanProcessor = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js"() {
+    "use strict";
+    init_esm3();
+    MultiSpanProcessor = class {
+      
+      constructor(_spanProcessors) {
+        this._spanProcessors = _spanProcessors;
+      }
+      forceFlush() {
+        const promises = [];
+        for (const spanProcessor of this._spanProcessors) {
+          promises.push(spanProcessor.forceFlush());
+        }
+        return new Promise((resolve) => {
+          Promise.all(promises).then(() => {
+            resolve();
+          }).catch((error2) => {
+            globalErrorHandler(error2 || new Error("MultiSpanProcessor: forceFlush failed"));
+            resolve();
+          });
+        });
+      }
+      onStart(span, context2) {
+        for (const spanProcessor of this._spanProcessors) {
+          spanProcessor.onStart(span, context2);
+        }
+      }
+      onEnd(span) {
+        for (const spanProcessor of this._spanProcessors) {
+          spanProcessor.onEnd(span);
+        }
+      }
+      shutdown() {
+        const promises = [];
+        for (const spanProcessor of this._spanProcessors) {
+          promises.push(spanProcessor.shutdown());
+        }
+        return new Promise((resolve, reject2) => {
+          Promise.all(promises).then(() => {
+            resolve();
+          }, reject2);
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js
+var ForceFlushState, BasicTracerProvider;
+var init_BasicTracerProvider = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js"() {
+    "use strict";
+    init_esm3();
+    init_esm4();
+    init_Tracer();
+    init_config();
+    init_MultiSpanProcessor();
+    init_utility();
+    (function(ForceFlushState2) {
+      ForceFlushState2[ForceFlushState2["resolved"] = 0] = "resolved";
+      ForceFlushState2[ForceFlushState2["timeout"] = 1] = "timeout";
+      ForceFlushState2[ForceFlushState2["error"] = 2] = "error";
+      ForceFlushState2[ForceFlushState2["unresolved"] = 3] = "unresolved";
+    })(ForceFlushState || (ForceFlushState = {}));
+    BasicTracerProvider = (_class6 = class {
+      
+      __init19() {this._tracers = /* @__PURE__ */ new Map()}
+      
+      
+      constructor(config = {}) {;_class6.prototype.__init19.call(this);
+        const mergedConfig = merge({}, loadDefaultConfig(), reconfigureLimits(config));
+        this._resource = _nullishCoalesce(mergedConfig.resource, () => ( defaultResource()));
+        this._config = Object.assign({}, mergedConfig, {
+          resource: this._resource
+        });
+        const spanProcessors = [];
+        if (_optionalChain([config, 'access', _16 => _16.spanProcessors, 'optionalAccess', _17 => _17.length])) {
+          spanProcessors.push(...config.spanProcessors);
+        }
+        this._activeSpanProcessor = new MultiSpanProcessor(spanProcessors);
+      }
+      getTracer(name, version, options) {
+        const key = `${name}@${version || ""}:${_optionalChain([options, 'optionalAccess', _18 => _18.schemaUrl]) || ""}`;
+        if (!this._tracers.has(key)) {
+          this._tracers.set(key, new Tracer({ name, version, schemaUrl: _optionalChain([options, 'optionalAccess', _19 => _19.schemaUrl]) }, this._config, this._resource, this._activeSpanProcessor));
+        }
+        return this._tracers.get(key);
+      }
+      forceFlush() {
+        const timeout = this._config.forceFlushTimeoutMillis;
+        const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => {
+          return new Promise((resolve) => {
+            let state;
+            const timeoutInterval = setTimeout(() => {
+              resolve(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+              state = ForceFlushState.timeout;
+            }, timeout);
+            spanProcessor.forceFlush().then(() => {
+              clearTimeout(timeoutInterval);
+              if (state !== ForceFlushState.timeout) {
+                state = ForceFlushState.resolved;
+                resolve(state);
+              }
+            }).catch((error2) => {
+              clearTimeout(timeoutInterval);
+              state = ForceFlushState.error;
+              resolve(error2);
+            });
+          });
+        });
+        return new Promise((resolve, reject2) => {
+          Promise.all(promises).then((results) => {
+            const errors = results.filter((result) => result !== ForceFlushState.resolved);
+            if (errors.length > 0) {
+              reject2(errors);
+            } else {
+              resolve();
+            }
+          }).catch((error2) => reject2([error2]));
+        });
+      }
+      shutdown() {
+        return this._activeSpanProcessor.shutdown();
+      }
+    }, _class6);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js
+var ConsoleSpanExporter;
+var init_ConsoleSpanExporter = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js"() {
+    "use strict";
+    init_esm3();
+    ConsoleSpanExporter = class {
+      /**
+       * Export spans.
+       * @param spans
+       * @param resultCallback
+       */
+      export(spans, resultCallback) {
+        return this._sendSpans(spans, resultCallback);
+      }
+      /**
+       * Shutdown the exporter.
+       */
+      shutdown() {
+        this._sendSpans([]);
+        return this.forceFlush();
+      }
+      /**
+       * Exports any pending spans in exporter
+       */
+      forceFlush() {
+        return Promise.resolve();
+      }
+      /**
+       * converts span info into more readable format
+       * @param span
+       */
+      _exportInfo(span) {
+        return {
+          resource: {
+            attributes: span.resource.attributes
+          },
+          instrumentationScope: span.instrumentationScope,
+          traceId: span.spanContext().traceId,
+          parentSpanContext: span.parentSpanContext,
+          traceState: _optionalChain([span, 'access', _20 => _20.spanContext, 'call', _21 => _21(), 'access', _22 => _22.traceState, 'optionalAccess', _23 => _23.serialize, 'call', _24 => _24()]),
+          name: span.name,
+          id: span.spanContext().spanId,
+          kind: span.kind,
+          timestamp: hrTimeToMicroseconds(span.startTime),
+          duration: hrTimeToMicroseconds(span.duration),
+          attributes: span.attributes,
+          status: span.status,
+          events: span.events,
+          links: span.links
+        };
+      }
+      /**
+       * Showing spans in console
+       * @param spans
+       * @param done
+       */
+      _sendSpans(spans, done) {
+        for (const span of spans) {
+          console.dir(this._exportInfo(span), { depth: 3 });
+        }
+        if (done) {
+          return done({ code: ExportResultCode.SUCCESS });
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js
+var InMemorySpanExporter;
+var init_InMemorySpanExporter = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js"() {
+    "use strict";
+    init_esm3();
+    InMemorySpanExporter = (_class7 = class {constructor() { _class7.prototype.__init20.call(this);_class7.prototype.__init21.call(this); }
+      __init20() {this._finishedSpans = []}
+      /**
+       * Indicates if the exporter has been "shutdown."
+       * When false, exported spans will not be stored in-memory.
+       */
+      __init21() {this._stopped = false}
+      export(spans, resultCallback) {
+        if (this._stopped)
+          return resultCallback({
+            code: ExportResultCode.FAILED,
+            error: new Error("Exporter has been stopped")
+          });
+        this._finishedSpans.push(...spans);
+        setTimeout(() => resultCallback({ code: ExportResultCode.SUCCESS }), 0);
+      }
+      shutdown() {
+        this._stopped = true;
+        this._finishedSpans = [];
+        return this.forceFlush();
+      }
+      /**
+       * Exports any pending spans in the exporter
+       */
+      forceFlush() {
+        return Promise.resolve();
+      }
+      reset() {
+        this._finishedSpans = [];
+      }
+      getFinishedSpans() {
+        return this._finishedSpans;
+      }
+    }, _class7);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js
+var SimpleSpanProcessor;
+var init_SimpleSpanProcessor = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_esm3();
+    SimpleSpanProcessor = class {
+      
+      
+      
+      constructor(_exporter) {
+        this._exporter = _exporter;
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        this._pendingExports = /* @__PURE__ */ new Set();
+      }
+      async forceFlush() {
+        await Promise.all(Array.from(this._pendingExports));
+        if (this._exporter.forceFlush) {
+          await this._exporter.forceFlush();
+        }
+      }
+      onStart(_span, _parentContext) {
+      }
+      onEnd(span) {
+        if (this._shutdownOnce.isCalled) {
+          return;
+        }
+        if ((span.spanContext().traceFlags & _chunkCDBUTZMHjs.TraceFlags.SAMPLED) === 0) {
+          return;
+        }
+        const pendingExport = this._doExport(span).catch((err) => globalErrorHandler(err));
+        this._pendingExports.add(pendingExport);
+        pendingExport.finally(() => this._pendingExports.delete(pendingExport));
+      }
+      async _doExport(span) {
+        if (span.resource.asyncAttributesPending) {
+          await _optionalChain([span, 'access', _25 => _25.resource, 'access', _26 => _26.waitForAsyncAttributes, 'optionalCall', _27 => _27()]);
+        }
+        const result = await internal._export(this._exporter, [span]);
+        if (result.code !== ExportResultCode.SUCCESS) {
+          throw _nullishCoalesce(result.error, () => ( new Error(`SimpleSpanProcessor: span export failed (status ${result})`)));
+        }
+      }
+      shutdown() {
+        return this._shutdownOnce.call();
+      }
+      _shutdown() {
+        return this._exporter.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js
+var NoopSpanProcessor;
+var init_NoopSpanProcessor = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js"() {
+    "use strict";
+    NoopSpanProcessor = class {
+      onStart(_span, _context) {
+      }
+      onEnd(_span) {
+      }
+      shutdown() {
+        return Promise.resolve();
+      }
+      forceFlush() {
+        return Promise.resolve();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js
+var esm_exports2 = {};
+_chunkCDBUTZMHjs.__export.call(void 0, esm_exports2, {
+  AlwaysOffSampler: () => AlwaysOffSampler,
+  AlwaysOnSampler: () => AlwaysOnSampler,
+  BasicTracerProvider: () => BasicTracerProvider,
+  BatchSpanProcessor: () => BatchSpanProcessor,
+  ConsoleSpanExporter: () => ConsoleSpanExporter,
+  InMemorySpanExporter: () => InMemorySpanExporter,
+  NoopSpanProcessor: () => NoopSpanProcessor,
+  ParentBasedSampler: () => ParentBasedSampler,
+  RandomIdGenerator: () => RandomIdGenerator,
+  SamplingDecision: () => SamplingDecision2,
+  SimpleSpanProcessor: () => SimpleSpanProcessor,
+  TraceIdRatioBasedSampler: () => TraceIdRatioBasedSampler
+});
+var init_esm5 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.0.1_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js"() {
+    "use strict";
+    init_BasicTracerProvider();
+    init_platform3();
+    init_ConsoleSpanExporter();
+    init_InMemorySpanExporter();
+    init_SimpleSpanProcessor();
+    init_NoopSpanProcessor();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    init_ParentBasedSampler();
+    init_TraceIdRatioBasedSampler();
+    init_Sampler();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
+var OTLPExporterBase;
+var init_OTLPExporterBase = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js"() {
+    "use strict";
+    OTLPExporterBase = class {
+      
+      constructor(_delegate) {
+        this._delegate = _delegate;
+      }
+      /**
+       * Export items.
+       * @param items
+       * @param resultCallback
+       */
+      export(items, resultCallback) {
+        this._delegate.export(items, resultCallback);
+      }
+      forceFlush() {
+        return this._delegate.forceFlush();
+      }
+      shutdown() {
+        return this._delegate.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js
+var OTLPExporterError;
+var init_types = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js"() {
+    "use strict";
+    OTLPExporterError = (_class8 = class extends Error {
+      
+      __init22() {this.name = "OTLPExporterError"}
+      
+      constructor(message, code, data) {
+        super(message);_class8.prototype.__init22.call(this);;
+        this.data = data;
+        this.code = code;
+      }
+    }, _class8);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js
+function validateTimeoutMillis(timeoutMillis) {
+  if (Number.isFinite(timeoutMillis) && timeoutMillis > 0) {
+    return timeoutMillis;
+  }
+  throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`);
+}
+function wrapStaticHeadersInFunction(headers) {
+  if (headers == null) {
+    return void 0;
+  }
+  return () => headers;
+}
+function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    timeoutMillis: validateTimeoutMillis(_nullishCoalesce(_nullishCoalesce(userProvidedConfiguration.timeoutMillis, () => ( fallbackConfiguration.timeoutMillis)), () => ( defaultConfiguration.timeoutMillis))),
+    concurrencyLimit: _nullishCoalesce(_nullishCoalesce(userProvidedConfiguration.concurrencyLimit, () => ( fallbackConfiguration.concurrencyLimit)), () => ( defaultConfiguration.concurrencyLimit)),
+    compression: _nullishCoalesce(_nullishCoalesce(userProvidedConfiguration.compression, () => ( fallbackConfiguration.compression)), () => ( defaultConfiguration.compression))
+  };
+}
+function getSharedConfigurationDefaults() {
+  return {
+    timeoutMillis: 1e4,
+    concurrencyLimit: 30,
+    compression: "none"
+  };
+}
+var init_shared_configuration = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js
+function createBoundedQueueExportPromiseHandler(options) {
+  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
+}
+var BoundedQueueExportPromiseHandler;
+var init_bounded_queue_export_promise_handler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js"() {
+    "use strict";
+    BoundedQueueExportPromiseHandler = (_class9 = class {
+      
+      __init23() {this._sendingPromises = []}
+      /**
+       * @param concurrencyLimit maximum promises allowed in a queue at the same time.
+       */
+      constructor(concurrencyLimit) {;_class9.prototype.__init23.call(this);
+        this._concurrencyLimit = concurrencyLimit;
+      }
+      pushPromise(promise) {
+        if (this.hasReachedLimit()) {
+          throw new Error("Concurrency Limit reached");
+        }
+        this._sendingPromises.push(promise);
+        const popPromise = () => {
+          const index = this._sendingPromises.indexOf(promise);
+          this._sendingPromises.splice(index, 1);
+        };
+        promise.then(popPromise, popPromise);
+      }
+      hasReachedLimit() {
+        return this._sendingPromises.length >= this._concurrencyLimit;
+      }
+      async awaitAll() {
+        await Promise.all(this._sendingPromises);
+      }
+    }, _class9);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var BAGGAGE_KEY_PAIR_SEPARATOR, BAGGAGE_PROPERTIES_SEPARATOR, BAGGAGE_ITEMS_SEPARATOR;
+var init_constants = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/baggage/constants.js"() {
+    "use strict";
+    BAGGAGE_KEY_PAIR_SEPARATOR = "=";
+    BAGGAGE_PROPERTIES_SEPARATOR = ";";
+    BAGGAGE_ITEMS_SEPARATOR = ",";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+function parsePairKeyValue(entry) {
+  const valueProps = entry.split(BAGGAGE_PROPERTIES_SEPARATOR);
+  if (valueProps.length <= 0)
+    return;
+  const keyPairPart = valueProps.shift();
+  if (!keyPairPart)
+    return;
+  const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
+  if (separatorIndex <= 0)
+    return;
+  const key = decodeURIComponent(keyPairPart.substring(0, separatorIndex).trim());
+  const value = decodeURIComponent(keyPairPart.substring(separatorIndex + 1).trim());
+  let metadata;
+  if (valueProps.length > 0) {
+    metadata = _chunkCDBUTZMHjs.baggageEntryMetadataFromString.call(void 0, valueProps.join(BAGGAGE_PROPERTIES_SEPARATOR));
+  }
+  return { key, value, metadata };
+}
+function parseKeyPairsIntoRecord(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return {};
+  return value.split(BAGGAGE_ITEMS_SEPARATOR).map((entry) => {
+    return parsePairKeyValue(entry);
+  }).filter((keyPair) => keyPair !== void 0 && keyPair.value.length > 0).reduce((headers, keyPair) => {
+    headers[keyPair.key] = keyPair.value;
+    return headers;
+  }, {});
+}
+var init_utils2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/baggage/utils.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_constants();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/time.js
+function hrTimeToNanoseconds2(time) {
+  return time[0] * SECOND_TO_NANOSECONDS2 + time[1];
+}
+var NANOSECOND_DIGITS2, NANOSECOND_DIGITS_IN_MILLIS2, MILLISECONDS_TO_NANOSECONDS2, SECOND_TO_NANOSECONDS2;
+var init_time2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/common/time.js"() {
+    "use strict";
+    NANOSECOND_DIGITS2 = 9;
+    NANOSECOND_DIGITS_IN_MILLIS2 = 6;
+    MILLISECONDS_TO_NANOSECONDS2 = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS2);
+    SECOND_TO_NANOSECONDS2 = Math.pow(10, NANOSECOND_DIGITS2);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode2;
+var init_ExportResult2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
+    "use strict";
+    (function(ExportResultCode3) {
+      ExportResultCode3[ExportResultCode3["SUCCESS"] = 0] = "SUCCESS";
+      ExportResultCode3[ExportResultCode3["FAILED"] = 1] = "FAILED";
+    })(ExportResultCode2 || (ExportResultCode2 = {}));
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/index.js
+var init_esm6 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+core@2.0.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/core/build/esm/index.js"() {
+    "use strict";
+    init_time2();
+    init_ExportResult2();
+    init_utils2();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js
+function isPartialSuccessResponse(response) {
+  return Object.prototype.hasOwnProperty.call(response, "partialSuccess");
+}
+function createLoggingPartialSuccessResponseHandler() {
+  return {
+    handleResponse(response) {
+      if (response == null || !isPartialSuccessResponse(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) {
+        return;
+      }
+      _chunkCDBUTZMHjs.diag.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess));
+    }
+  };
+}
+var init_logging_response_handler = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
+function createOtlpExportDelegate(components, settings) {
+  return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, settings.timeout);
+}
+var OTLPExportDelegate;
+var init_otlp_export_delegate = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js"() {
+    "use strict";
+    init_esm6();
+    init_types();
+    init_logging_response_handler();
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    OTLPExportDelegate = class {
+      
+      
+      
+      
+      
+      
+      constructor(_transport, _serializer, _responseHandler, _promiseQueue, _timeout) {
+        this._transport = _transport;
+        this._serializer = _serializer;
+        this._responseHandler = _responseHandler;
+        this._promiseQueue = _promiseQueue;
+        this._timeout = _timeout;
+        this._diagLogger = _chunkCDBUTZMHjs.diag.createComponentLogger({
+          namespace: "OTLPExportDelegate"
+        });
+      }
+      export(internalRepresentation, resultCallback) {
+        this._diagLogger.debug("items to be sent", internalRepresentation);
+        if (this._promiseQueue.hasReachedLimit()) {
+          resultCallback({
+            code: ExportResultCode2.FAILED,
+            error: new Error("Concurrent export limit reached")
+          });
+          return;
+        }
+        const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
+        if (serializedRequest == null) {
+          resultCallback({
+            code: ExportResultCode2.FAILED,
+            error: new Error("Nothing to send")
+          });
+          return;
+        }
+        this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then((response) => {
+          if (response.status === "success") {
+            if (response.data != null) {
+              try {
+                this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data));
+              } catch (e) {
+                this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", e, response.data);
+              }
+            }
+            resultCallback({
+              code: ExportResultCode2.SUCCESS
+            });
+            return;
+          } else if (response.status === "failure" && response.error) {
+            resultCallback({
+              code: ExportResultCode2.FAILED,
+              error: response.error
+            });
+            return;
+          } else if (response.status === "retryable") {
+            resultCallback({
+              code: ExportResultCode2.FAILED,
+              error: new OTLPExporterError("Export failed with retryable status")
+            });
+          } else {
+            resultCallback({
+              code: ExportResultCode2.FAILED,
+              error: new OTLPExporterError("Export failed with unknown error")
+            });
+          }
+        }, (reason) => resultCallback({
+          code: ExportResultCode2.FAILED,
+          error: reason
+        })));
+      }
+      forceFlush() {
+        return this._promiseQueue.awaitAll();
+      }
+      async shutdown() {
+        this._diagLogger.debug("shutdown started");
+        await this.forceFlush();
+        this._transport.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/index.js
+var init_esm7 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/index.js"() {
+    "use strict";
+    init_OTLPExporterBase();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/version.js
+var VERSION2;
+var init_version2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/version.js"() {
+    "use strict";
+    VERSION2 = "0.200.0";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/common/hex-to-binary.js
+function intValue(charCode) {
+  if (charCode >= 48 && charCode <= 57) {
+    return charCode - 48;
+  }
+  if (charCode >= 97 && charCode <= 102) {
+    return charCode - 87;
+  }
+  return charCode - 55;
+}
+function hexToBinary(hexStr) {
+  const buf = new Uint8Array(hexStr.length / 2);
+  let offset = 0;
+  for (let i = 0; i < hexStr.length; i += 2) {
+    const hi = intValue(hexStr.charCodeAt(i));
+    const lo = intValue(hexStr.charCodeAt(i + 1));
+    buf[offset++] = hi << 4 | lo;
+  }
+  return buf;
+}
+var init_hex_to_binary = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/common/hex-to-binary.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
+function hrTimeToNanos(hrTime3) {
+  const NANOSECONDS = BigInt(1e9);
+  return BigInt(hrTime3[0]) * NANOSECONDS + BigInt(hrTime3[1]);
+}
+function toLongBits(value) {
+  const low = Number(BigInt.asUintN(32, value));
+  const high = Number(BigInt.asUintN(32, value >> BigInt(32)));
+  return { low, high };
+}
+function encodeAsLongBits(hrTime3) {
+  const nanos = hrTimeToNanos(hrTime3);
+  return toLongBits(nanos);
+}
+function encodeAsString(hrTime3) {
+  const nanos = hrTimeToNanos(hrTime3);
+  return nanos.toString();
+}
+function identity(value) {
+  return value;
+}
+function optionalHexToBinary(str) {
+  if (str === void 0)
+    return void 0;
+  return hexToBinary(str);
+}
+function getOtlpEncoder(options) {
+  if (options === void 0) {
+    return DEFAULT_ENCODER;
+  }
+  const useLongBits = _nullishCoalesce(options.useLongBits, () => ( true));
+  const useHex = _nullishCoalesce(options.useHex, () => ( false));
+  return {
+    encodeHrTime: useLongBits ? encodeAsLongBits : encodeTimestamp,
+    encodeSpanContext: useHex ? identity : hexToBinary,
+    encodeOptionalSpanContext: useHex ? identity : optionalHexToBinary
+  };
+}
+var encodeTimestamp, DEFAULT_ENCODER;
+var init_utils3 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js"() {
+    "use strict";
+    init_esm6();
+    init_hex_to_binary();
+    encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds2;
+    DEFAULT_ENCODER = {
+      encodeHrTime: encodeAsLongBits,
+      encodeSpanContext: hexToBinary,
+      encodeOptionalSpanContext: optionalHexToBinary
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
+function createResource(resource) {
+  return {
+    attributes: toAttributes(resource.attributes),
+    droppedAttributesCount: 0
+  };
+}
+function createInstrumentationScope(scope) {
+  return {
+    name: scope.name,
+    version: scope.version
+  };
+}
+function toAttributes(attributes) {
+  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key]));
+}
+function toKeyValue(key, value) {
+  return {
+    key,
+    value: toAnyValue(value)
+  };
+}
+function toAnyValue(value) {
+  const t = typeof value;
+  if (t === "string")
+    return { stringValue: value };
+  if (t === "number") {
+    if (!Number.isInteger(value))
+      return { doubleValue: value };
+    return { intValue: value };
+  }
+  if (t === "boolean")
+    return { boolValue: value };
+  if (value instanceof Uint8Array)
+    return { bytesValue: value };
+  if (Array.isArray(value))
+    return { arrayValue: { values: value.map(toAnyValue) } };
+  if (t === "object" && value != null)
+    return {
+      kvlistValue: {
+        values: Object.entries(value).map(([k, v]) => toKeyValue(k, v))
+      }
+    };
+  return {};
+}
+var init_internal = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js
+function sdkSpanToOtlpSpan(span, encoder) {
+  const ctx = span.spanContext();
+  const status = span.status;
+  const parentSpanId = _optionalChain([span, 'access', _28 => _28.parentSpanContext, 'optionalAccess', _29 => _29.spanId]) ? encoder.encodeSpanContext(_optionalChain([span, 'access', _30 => _30.parentSpanContext, 'optionalAccess', _31 => _31.spanId])) : void 0;
+  return {
+    traceId: encoder.encodeSpanContext(ctx.traceId),
+    spanId: encoder.encodeSpanContext(ctx.spanId),
+    parentSpanId,
+    traceState: _optionalChain([ctx, 'access', _32 => _32.traceState, 'optionalAccess', _33 => _33.serialize, 'call', _34 => _34()]),
+    name: span.name,
+    // Span kind is offset by 1 because the API does not define a value for unset
+    kind: span.kind == null ? 0 : span.kind + 1,
+    startTimeUnixNano: encoder.encodeHrTime(span.startTime),
+    endTimeUnixNano: encoder.encodeHrTime(span.endTime),
+    attributes: toAttributes(span.attributes),
+    droppedAttributesCount: span.droppedAttributesCount,
+    events: span.events.map((event) => toOtlpSpanEvent(event, encoder)),
+    droppedEventsCount: span.droppedEventsCount,
+    status: {
+      // API and proto enums share the same values
+      code: status.code,
+      message: status.message
+    },
+    links: span.links.map((link) => toOtlpLink(link, encoder)),
+    droppedLinksCount: span.droppedLinksCount
+  };
+}
+function toOtlpLink(link, encoder) {
+  return {
+    attributes: link.attributes ? toAttributes(link.attributes) : [],
+    spanId: encoder.encodeSpanContext(link.context.spanId),
+    traceId: encoder.encodeSpanContext(link.context.traceId),
+    traceState: _optionalChain([link, 'access', _35 => _35.context, 'access', _36 => _36.traceState, 'optionalAccess', _37 => _37.serialize, 'call', _38 => _38()]),
+    droppedAttributesCount: link.droppedAttributesCount || 0
+  };
+}
+function toOtlpSpanEvent(timedEvent, encoder) {
+  return {
+    attributes: timedEvent.attributes ? toAttributes(timedEvent.attributes) : [],
+    name: timedEvent.name,
+    timeUnixNano: encoder.encodeHrTime(timedEvent.time),
+    droppedAttributesCount: timedEvent.droppedAttributesCount || 0
+  };
+}
+function createExportTraceServiceRequest(spans, options) {
+  const encoder = getOtlpEncoder(options);
+  return {
+    resourceSpans: spanRecordsToResourceSpans(spans, encoder)
+  };
+}
+function createResourceMap(readableSpans) {
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const record of readableSpans) {
+    let ilsMap = resourceMap.get(record.resource);
+    if (!ilsMap) {
+      ilsMap = /* @__PURE__ */ new Map();
+      resourceMap.set(record.resource, ilsMap);
+    }
+    const instrumentationScopeKey = `${record.instrumentationScope.name}@${record.instrumentationScope.version || ""}:${record.instrumentationScope.schemaUrl || ""}`;
+    let records = ilsMap.get(instrumentationScopeKey);
+    if (!records) {
+      records = [];
+      ilsMap.set(instrumentationScopeKey, records);
+    }
+    records.push(record);
+  }
+  return resourceMap;
+}
+function spanRecordsToResourceSpans(readableSpans, encoder) {
+  const resourceMap = createResourceMap(readableSpans);
+  const out = [];
+  const entryIterator = resourceMap.entries();
+  let entry = entryIterator.next();
+  while (!entry.done) {
+    const [resource, ilmMap] = entry.value;
+    const scopeResourceSpans = [];
+    const ilmIterator = ilmMap.values();
+    let ilmEntry = ilmIterator.next();
+    while (!ilmEntry.done) {
+      const scopeSpans = ilmEntry.value;
+      if (scopeSpans.length > 0) {
+        const spans = scopeSpans.map((readableSpan) => sdkSpanToOtlpSpan(readableSpan, encoder));
+        scopeResourceSpans.push({
+          scope: createInstrumentationScope(scopeSpans[0].instrumentationScope),
+          spans,
+          schemaUrl: scopeSpans[0].instrumentationScope.schemaUrl
+        });
+      }
+      ilmEntry = ilmIterator.next();
+    }
+    const transformedSpans = {
+      resource: createResource(resource),
+      scopeSpans: scopeResourceSpans,
+      schemaUrl: void 0
+    };
+    out.push(transformedSpans);
+    entry = entryIterator.next();
+  }
+  return out;
+}
+var init_internal2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js"() {
+    "use strict";
+    init_internal();
+    init_utils3();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js
+var JsonTraceSerializer;
+var init_trace2 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js"() {
+    "use strict";
+    init_internal2();
+    JsonTraceSerializer = {
+      serializeRequest: (arg) => {
+        const request3 = createExportTraceServiceRequest(arg, {
+          useHex: true,
+          useLongBits: false
+        });
+        const encoder = new TextEncoder();
+        return encoder.encode(JSON.stringify(request3));
+      },
+      deserializeResponse: (arg) => {
+        const decoder = new TextDecoder();
+        return JSON.parse(decoder.decode(arg));
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/index.js
+var init_json = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/index.js"() {
+    "use strict";
+    init_trace2();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/index.js
+var init_esm8 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-transformer/build/esm/index.js"() {
+    "use strict";
+    init_json();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js
+function isExportRetryable(statusCode) {
+  const retryCodes = [429, 502, 503, 504];
+  return retryCodes.includes(statusCode);
+}
+function parseRetryAfterToMills(retryAfter) {
+  if (retryAfter == null) {
+    return void 0;
+  }
+  const seconds = Number.parseInt(retryAfter, 10);
+  if (Number.isInteger(seconds)) {
+    return seconds > 0 ? seconds * 1e3 : -1;
+  }
+  const delay = new Date(retryAfter).getTime() - Date.now();
+  if (delay >= 0) {
+    return delay;
+  }
+  return 0;
+}
+var init_is_export_retryable = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
+var http_transport_utils_exports = {};
+_chunkCDBUTZMHjs.__export.call(void 0, http_transport_utils_exports, {
+  compressAndSend: () => compressAndSend,
+  createHttpAgent: () => createHttpAgent,
+  sendWithHttp: () => sendWithHttp
+});
+var _http = require('http'); var http = _interopRequireWildcard(_http);
+var _https = require('https'); var https = _interopRequireWildcard(_https);
+var _zlib = require('zlib'); var zlib2 = _interopRequireWildcard(_zlib); var zlib = _interopRequireWildcard(_zlib);
+var _stream = require('stream');
+function sendWithHttp(params, agent, data, onDone, timeoutMillis) {
+  const parsedUrl = new URL(params.url);
+  const nodeVersion = Number(process.versions.node.split(".")[0]);
+  const options = {
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port,
+    path: parsedUrl.pathname,
+    method: "POST",
+    headers: {
+      ...params.headers()
+    },
+    agent
+  };
+  const request3 = parsedUrl.protocol === "http:" ? http.request : https.request;
+  const req = request3(options, (res) => {
+    const responseData = [];
+    res.on("data", (chunk) => responseData.push(chunk));
+    res.on("end", () => {
+      if (res.statusCode && res.statusCode < 299) {
+        onDone({
+          status: "success",
+          data: Buffer.concat(responseData)
+        });
+      } else if (res.statusCode && isExportRetryable(res.statusCode)) {
+        onDone({
+          status: "retryable",
+          retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
+        });
+      } else {
+        const error2 = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
+        onDone({
+          status: "failure",
+          error: error2
+        });
+      }
+    });
+  });
+  req.setTimeout(timeoutMillis, () => {
+    req.destroy();
+    onDone({
+      status: "failure",
+      error: new Error("Request Timeout")
+    });
+  });
+  req.on("error", (error2) => {
+    onDone({
+      status: "failure",
+      error: error2
+    });
+  });
+  const reportTimeoutErrorEvent = nodeVersion >= 14 ? "close" : "abort";
+  req.on(reportTimeoutErrorEvent, () => {
+    onDone({
+      status: "failure",
+      error: new Error("Request timed out")
+    });
+  });
+  compressAndSend(req, params.compression, data, (error2) => {
+    onDone({
+      status: "failure",
+      error: error2
+    });
+  });
+}
+function compressAndSend(req, compression, data, onError) {
+  let dataStream = readableFromUint8Array(data);
+  if (compression === "gzip") {
+    req.setHeader("Content-Encoding", "gzip");
+    dataStream = dataStream.on("error", onError).pipe(zlib2.createGzip()).on("error", onError);
+  }
+  dataStream.pipe(req).on("error", onError);
+}
+function readableFromUint8Array(buff) {
+  const readable = new (0, _stream.Readable)();
+  readable.push(buff);
+  readable.push(null);
+  return readable;
+}
+function createHttpAgent(rawUrl, agentOptions) {
+  const parsedUrl = new URL(rawUrl);
+  const Agent3 = parsedUrl.protocol === "http:" ? http.Agent : https.Agent;
+  return new Agent3(agentOptions);
+}
+var init_http_transport_utils = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js"() {
+    "use strict";
+    init_is_export_retryable();
+    init_types();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js
+function createHttpExporterTransport(parameters) {
+  return new HttpExporterTransport(parameters);
+}
+var HttpExporterTransport;
+var init_http_exporter_transport = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js"() {
+    "use strict";
+    HttpExporterTransport = (_class10 = class {
+      
+      __init24() {this._utils = null}
+      constructor(_parameters) {;_class10.prototype.__init24.call(this);
+        this._parameters = _parameters;
+      }
+      async send(data, timeoutMillis) {
+        const { agent, send } = this._loadUtils();
+        return new Promise((resolve) => {
+          send(this._parameters, agent, data, (result) => {
+            resolve(result);
+          }, timeoutMillis);
+        });
+      }
+      shutdown() {
+      }
+      _loadUtils() {
+        let utils = this._utils;
+        if (utils === null) {
+          const {
+            sendWithHttp: sendWithHttp2,
+            createHttpAgent: createHttpAgent2
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+          } = (init_http_transport_utils(), _chunkCDBUTZMHjs.__toCommonJS.call(void 0, http_transport_utils_exports));
+          utils = this._utils = {
+            agent: createHttpAgent2(this._parameters.url, this._parameters.agentOptions),
+            send: sendWithHttp2
+          };
+        }
+        return utils;
+      }
+    }, _class10);
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js
+function getJitter() {
+  return Math.random() * (2 * JITTER) - JITTER;
+}
+function createRetryingTransport(options) {
+  return new RetryingTransport(options.transport);
+}
+var MAX_ATTEMPTS, INITIAL_BACKOFF, MAX_BACKOFF, BACKOFF_MULTIPLIER, JITTER, RetryingTransport;
+var init_retrying_transport = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js"() {
+    "use strict";
+    MAX_ATTEMPTS = 5;
+    INITIAL_BACKOFF = 1e3;
+    MAX_BACKOFF = 5e3;
+    BACKOFF_MULTIPLIER = 1.5;
+    JITTER = 0.2;
+    RetryingTransport = class {
+      
+      constructor(_transport) {
+        this._transport = _transport;
+      }
+      retry(data, timeoutMillis, inMillis) {
+        return new Promise((resolve, reject2) => {
+          setTimeout(() => {
+            this._transport.send(data, timeoutMillis).then(resolve, reject2);
+          }, inMillis);
+        });
+      }
+      async send(data, timeoutMillis) {
+        const deadline = Date.now() + timeoutMillis;
+        let result = await this._transport.send(data, timeoutMillis);
+        let attempts = MAX_ATTEMPTS;
+        let nextBackoff = INITIAL_BACKOFF;
+        while (result.status === "retryable" && attempts > 0) {
+          attempts--;
+          const backoff = Math.max(Math.min(nextBackoff, MAX_BACKOFF) + getJitter(), 0);
+          nextBackoff = nextBackoff * BACKOFF_MULTIPLIER;
+          const retryInMillis = _nullishCoalesce(result.retryInMillis, () => ( backoff));
+          const remainingTimeoutMillis = deadline - Date.now();
+          if (retryInMillis > remainingTimeoutMillis) {
+            return result;
+          }
+          result = await this.retry(data, remainingTimeoutMillis, retryInMillis);
+        }
+        return result;
+      }
+      shutdown() {
+        return this._transport.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js
+function createOtlpHttpExportDelegate(options, serializer) {
+  return createOtlpExportDelegate({
+    transport: createRetryingTransport({
+      transport: createHttpExporterTransport(options)
+    }),
+    serializer,
+    promiseHandler: createBoundedQueueExportPromiseHandler(options)
+  }, { timeout: options.timeoutMillis });
+}
+var init_otlp_http_export_delegate = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js"() {
+    "use strict";
+    init_otlp_export_delegate();
+    init_http_exporter_transport();
+    init_bounded_queue_export_promise_handler();
+    init_retrying_transport();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js
+function parseAndValidateTimeoutFromEnv(timeoutEnvVar) {
+  const envTimeout = _optionalChain([process, 'access', _39 => _39.env, 'access', _40 => _40[timeoutEnvVar], 'optionalAccess', _41 => _41.trim, 'call', _42 => _42()]);
+  if (envTimeout != null && envTimeout !== "") {
+    const definedTimeout = Number(envTimeout);
+    if (Number.isFinite(definedTimeout) && definedTimeout > 0) {
+      return definedTimeout;
+    }
+    _chunkCDBUTZMHjs.diag.warn(`Configuration: ${timeoutEnvVar} is invalid, expected number greater than 0 (actual: ${envTimeout})`);
+  }
+  return void 0;
+}
+function getTimeoutFromEnv(signalIdentifier) {
+  const specificTimeout = parseAndValidateTimeoutFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_TIMEOUT`);
+  const nonSpecificTimeout = parseAndValidateTimeoutFromEnv("OTEL_EXPORTER_OTLP_TIMEOUT");
+  return _nullishCoalesce(specificTimeout, () => ( nonSpecificTimeout));
+}
+function parseAndValidateCompressionFromEnv(compressionEnvVar) {
+  const compression = _optionalChain([process, 'access', _43 => _43.env, 'access', _44 => _44[compressionEnvVar], 'optionalAccess', _45 => _45.trim, 'call', _46 => _46()]);
+  if (compression === "") {
+    return void 0;
+  }
+  if (compression == null || compression === "none" || compression === "gzip") {
+    return compression;
+  }
+  _chunkCDBUTZMHjs.diag.warn(`Configuration: ${compressionEnvVar} is invalid, expected 'none' or 'gzip' (actual: '${compression}')`);
+  return void 0;
+}
+function getCompressionFromEnv(signalIdentifier) {
+  const specificCompression = parseAndValidateCompressionFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_COMPRESSION`);
+  const nonSpecificCompression = parseAndValidateCompressionFromEnv("OTEL_EXPORTER_OTLP_COMPRESSION");
+  return _nullishCoalesce(specificCompression, () => ( nonSpecificCompression));
+}
+function getSharedConfigurationFromEnvironment(signalIdentifier) {
+  return {
+    timeoutMillis: getTimeoutFromEnv(signalIdentifier),
+    compression: getCompressionFromEnv(signalIdentifier)
+  };
+}
+var init_shared_env_configuration = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js
+function validateAndNormalizeHeaders(partialHeaders) {
+  return () => {
+    const headers = {};
+    Object.entries(_nullishCoalesce(_optionalChain([partialHeaders, 'optionalCall', _47 => _47()]), () => ( {}))).forEach(([key, value]) => {
+      if (typeof value !== "undefined") {
+        headers[key] = String(value);
+      } else {
+        _chunkCDBUTZMHjs.diag.warn(`Header "${key}" has invalid value (${value}) and will be ignored`);
+      }
+    });
+    return headers;
+  };
+}
+var init_util = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js"() {
+    "use strict";
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js
+function mergeHeaders(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
+  const requiredHeaders = {
+    ...defaultHeaders()
+  };
+  const headers = {};
+  return () => {
+    if (fallbackHeaders != null) {
+      Object.assign(headers, fallbackHeaders());
+    }
+    if (userProvidedHeaders != null) {
+      Object.assign(headers, userProvidedHeaders());
+    }
+    return Object.assign(headers, requiredHeaders);
+  };
+}
+function validateUserProvidedUrl(url) {
+  if (url == null) {
+    return void 0;
+  }
+  try {
+    new URL(url);
+    return url;
+  } catch (e) {
+    throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
+  }
+}
+function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    ...mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+    headers: mergeHeaders(validateAndNormalizeHeaders(userProvidedConfiguration.headers), fallbackConfiguration.headers, defaultConfiguration.headers),
+    url: _nullishCoalesce(_nullishCoalesce(validateUserProvidedUrl(userProvidedConfiguration.url), () => ( fallbackConfiguration.url)), () => ( defaultConfiguration.url)),
+    agentOptions: _nullishCoalesce(_nullishCoalesce(userProvidedConfiguration.agentOptions, () => ( fallbackConfiguration.agentOptions)), () => ( defaultConfiguration.agentOptions))
+  };
+}
+function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
+  return {
+    ...getSharedConfigurationDefaults(),
+    headers: () => requiredHeaders,
+    url: "http://localhost:4318/" + signalResourcePath,
+    agentOptions: { keepAlive: true }
+  };
+}
+var init_otlp_http_configuration = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js"() {
+    "use strict";
+    init_shared_configuration();
+    init_util();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-env-configuration.js
+function getStaticHeadersFromEnv(signalIdentifier) {
+  const signalSpecificRawHeaders = _optionalChain([process, 'access', _48 => _48.env, 'access', _49 => _49[`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`], 'optionalAccess', _50 => _50.trim, 'call', _51 => _51()]);
+  const nonSignalSpecificRawHeaders = _optionalChain([process, 'access', _52 => _52.env, 'access', _53 => _53["OTEL_EXPORTER_OTLP_HEADERS"], 'optionalAccess', _54 => _54.trim, 'call', _55 => _55()]);
+  const signalSpecificHeaders = parseKeyPairsIntoRecord(signalSpecificRawHeaders);
+  const nonSignalSpecificHeaders = parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders);
+  if (Object.keys(signalSpecificHeaders).length === 0 && Object.keys(nonSignalSpecificHeaders).length === 0) {
+    return void 0;
+  }
+  return Object.assign({}, parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders), parseKeyPairsIntoRecord(signalSpecificRawHeaders));
+}
+function appendRootPathToUrlIfNeeded(url) {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.toString();
+  } catch (e3) {
+    _chunkCDBUTZMHjs.diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
+    return void 0;
+  }
+}
+function appendResourcePathToUrl(url, path3) {
+  try {
+    new URL(url);
+  } catch (e4) {
+    _chunkCDBUTZMHjs.diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
+    return void 0;
+  }
+  if (!url.endsWith("/")) {
+    url = url + "/";
+  }
+  url += path3;
+  try {
+    new URL(url);
+  } catch (e5) {
+    _chunkCDBUTZMHjs.diag.warn(`Configuration: Provided URL appended with '${path3}' is not a valid URL, using 'undefined' instead of '${url}'`);
+    return void 0;
+  }
+  return url;
+}
+function getNonSpecificUrlFromEnv(signalResourcePath) {
+  const envUrl = _optionalChain([process, 'access', _56 => _56.env, 'access', _57 => _57.OTEL_EXPORTER_OTLP_ENDPOINT, 'optionalAccess', _58 => _58.trim, 'call', _59 => _59()]);
+  if (envUrl == null || envUrl === "") {
+    return void 0;
+  }
+  return appendResourcePathToUrl(envUrl, signalResourcePath);
+}
+function getSpecificUrlFromEnv(signalIdentifier) {
+  const envUrl = _optionalChain([process, 'access', _60 => _60.env, 'access', _61 => _61[`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`], 'optionalAccess', _62 => _62.trim, 'call', _63 => _63()]);
+  if (envUrl == null || envUrl === "") {
+    return void 0;
+  }
+  return appendRootPathToUrlIfNeeded(envUrl);
+}
+function getHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath) {
+  return {
+    ...getSharedConfigurationFromEnvironment(signalIdentifier),
+    url: _nullishCoalesce(getSpecificUrlFromEnv(signalIdentifier), () => ( getNonSpecificUrlFromEnv(signalResourcePath))),
+    headers: wrapStaticHeadersInFunction(getStaticHeadersFromEnv(signalIdentifier))
+  };
+}
+var init_otlp_http_env_configuration = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-env-configuration.js"() {
+    "use strict";
+    init_esm6();
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_shared_env_configuration();
+    init_shared_configuration();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js
+function convertLegacyAgentOptions(config) {
+  if (_optionalChain([config, 'optionalAccess', _64 => _64.keepAlive]) != null) {
+    if (config.httpAgentOptions != null) {
+      if (config.httpAgentOptions.keepAlive == null) {
+        config.httpAgentOptions.keepAlive = config.keepAlive;
+      }
+    } else {
+      config.httpAgentOptions = {
+        keepAlive: config.keepAlive
+      };
+    }
+  }
+  return config.httpAgentOptions;
+}
+function convertLegacyHttpOptions(config, signalIdentifier, signalResourcePath, requiredHeaders) {
+  if (config.metadata) {
+    _chunkCDBUTZMHjs.diag.warn("Metadata cannot be set when using http");
+  }
+  return mergeOtlpHttpConfigurationWithDefaults({
+    url: config.url,
+    headers: wrapStaticHeadersInFunction(config.headers),
+    concurrencyLimit: config.concurrencyLimit,
+    timeoutMillis: config.timeoutMillis,
+    compression: config.compression,
+    agentOptions: convertLegacyAgentOptions(config)
+  }, getHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath), getHttpConfigurationDefaults(requiredHeaders, signalResourcePath));
+}
+var init_convert_legacy_node_http_options = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js"() {
+    "use strict";
+    init_otlp_http_configuration();
+    init_otlp_http_env_configuration();
+    _chunkCDBUTZMHjs.init_esm.call(void 0, );
+    init_shared_configuration();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/index-node-http.js
+var init_index_node_http = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/otlp-exporter-base/build/esm/index-node-http.js"() {
+    "use strict";
+    init_otlp_http_export_delegate();
+    init_convert_legacy_node_http_options();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/OTLPTraceExporter.js
+var OTLPTraceExporter;
+var init_OTLPTraceExporter = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/OTLPTraceExporter.js"() {
+    "use strict";
+    init_esm7();
+    init_version2();
+    init_esm8();
+    init_index_node_http();
+    OTLPTraceExporter = class extends OTLPExporterBase {
+      constructor(config = {}) {
+        super(createOtlpHttpExportDelegate(convertLegacyHttpOptions(config, "TRACES", "v1/traces", {
+          "User-Agent": `OTel-OTLP-Exporter-JavaScript/${VERSION2}`,
+          "Content-Type": "application/json"
+        }), JsonTraceSerializer));
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/index.js
+var init_node4 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_OTLPTraceExporter();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/index.js
+var init_platform4 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/index.js"() {
+    "use strict";
+    init_node4();
+  }
+});
+
+// ../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/index.js
+var esm_exports3 = {};
+_chunkCDBUTZMHjs.__export.call(void 0, esm_exports3, {
+  OTLPTraceExporter: () => OTLPTraceExporter
+});
+var init_esm9 = _chunkCDBUTZMHjs.__esm.call(void 0, {
+  "../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.200.0_@opentelemetry+api@1.9.0/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/index.js"() {
+    "use strict";
+    init_platform4();
+  }
+});
 
 // src/node.ts
 var _async_hooks = require('async_hooks');
@@ -57,7 +3246,7 @@ async function getBaseBranch(remote = void 0) {
     if (git === null) {
       throw new Error("Not in a git repo");
     }
-    const remoteName = await _asyncNullishCoalesce(remote, async () => ( await _asyncOptionalChain([(await git.getRemotes()), 'access', async _2 => _2[0], 'optionalAccess', async _3 => _3.name])));
+    const remoteName = await _asyncNullishCoalesce(remote, async () => ( await _asyncOptionalChain([(await git.getRemotes()), 'access', async _65 => _65[0], 'optionalAccess', async _66 => _66.name])));
     if (!remoteName) {
       throw new Error("No remote found");
     }
@@ -79,7 +3268,7 @@ async function getBaseBranch(remote = void 0) {
           throw new Error(`Could not find HEAD branch in remote ${remoteName}`);
         }
         branch = match[1];
-      } catch (e2) {
+      } catch (e6) {
         branch = "main";
       }
     }
@@ -106,7 +3295,7 @@ async function getBaseBranchAncestor(remote = void 0) {
     return void 0;
   }
 }
-async function getPastNAncestors(n = 10, remote = void 0) {
+async function getPastNAncestors(n = 1e3, remote = void 0) {
   const git = await currentRepo();
   if (git === null) {
     return [];
@@ -123,7 +3312,7 @@ async function getPastNAncestors(n = 10, remote = void 0) {
   if (!ancestor) {
     return [];
   }
-  const commits = await git.log({ from: ancestor, to: "HEAD" });
+  const commits = await git.log({ from: ancestor, to: "HEAD", maxCount: n });
   return commits.all.map((c) => c.hash);
 }
 async function attempt(fn) {
@@ -150,7 +3339,7 @@ async function getRepoInfo(settings) {
     return repo;
   }
   let sanitized = {};
-  _optionalChain([settings, 'access', _4 => _4.fields, 'optionalAccess', _5 => _5.forEach, 'call', _6 => _6((field) => {
+  _optionalChain([settings, 'access', _67 => _67.fields, 'optionalAccess', _68 => _68.forEach, 'call', _69 => _69((field) => {
     sanitized = { ...sanitized, [field]: repo[field] };
   })]);
   return sanitized;
@@ -208,11 +3397,11 @@ async function repoInfo() {
 
 // src/stackutil.ts
 function getStackTrace() {
-  const trace = new Error().stack;
-  if (typeof trace !== "string") {
+  const trace2 = new Error().stack;
+  if (typeof trace2 !== "string") {
     return [];
   }
-  const traceLines = trace.split("\n");
+  const traceLines = trace2.split("\n");
   const out = [];
   const stackFrameRegex = /at(.*)\((.*):(\d+):(\d+)\)/;
   for (const traceLine of traceLines.slice(1)) {
@@ -236,9 +3425,9 @@ function getCallerLocation() {
   const entries = getStackTrace();
   for (const frame of entries) {
     if (thisDir === void 0) {
-      thisDir = _optionalChain([isomorph_default, 'access', _7 => _7.pathDirname, 'optionalCall', _8 => _8(frame.fileName)]);
+      thisDir = _optionalChain([isomorph_default, 'access', _70 => _70.pathDirname, 'optionalCall', _71 => _71(frame.fileName)]);
     }
-    if (_optionalChain([isomorph_default, 'access', _9 => _9.pathDirname, 'optionalCall', _10 => _10(frame.fileName)]) !== thisDir) {
+    if (_optionalChain([isomorph_default, 'access', _72 => _72.pathDirname, 'optionalCall', _73 => _73(frame.fileName)]) !== thisDir) {
       return {
         caller_functionname: frame.functionName,
         caller_filename: frame.fileName,
@@ -254,11 +3443,11 @@ var _uuid = require('uuid');
 
 // src/queue.ts
 var DEFAULT_QUEUE_SIZE = 15e3;
-var Queue = (_class = class {
-  __init() {this.items = []}
+var Queue = (_class11 = class {
+  __init25() {this.items = []}
   
-  __init2() {this.enforceSizeLimit = false}
-  constructor(maxSize) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+  __init26() {this.enforceSizeLimit = false}
+  constructor(maxSize) {;_class11.prototype.__init25.call(this);_class11.prototype.__init26.call(this);
     if (maxSize < 1) {
       console.warn(
         `maxSize ${maxSize} is <1, using default ${DEFAULT_QUEUE_SIZE}`
@@ -306,7 +3495,7 @@ var Queue = (_class = class {
   get capacity() {
     return this.maxSize;
   }
-}, _class);
+}, _class11);
 
 // src/logger.ts
 
@@ -902,13 +4091,13 @@ function getCurrentUnixTimestamp() {
 function isEmpty(a) {
   return a === void 0 || a === null;
 }
-var LazyValue = (_class2 = class {
+var LazyValue = (_class12 = class {
   
-  __init3() {this.resolvedValue = void 0}
-  __init4() {this.value = {
+  __init27() {this.resolvedValue = void 0}
+  __init28() {this.value = {
     computedState: "uninitialized"
   }}
-  constructor(callable) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+  constructor(callable) {;_class12.prototype.__init27.call(this);_class12.prototype.__init28.call(this);
     this.callable = callable;
   }
   get() {
@@ -936,13 +4125,13 @@ var LazyValue = (_class2 = class {
   get hasSucceeded() {
     return this.value.computedState === "succeeded";
   }
-}, _class2);
-var SyncLazyValue = (_class3 = class {
+}, _class12);
+var SyncLazyValue = (_class13 = class {
   
-  __init5() {this.value = {
+  __init29() {this.value = {
     computedState: "uninitialized"
   }}
-  constructor(callable) {;_class3.prototype.__init5.call(this);
+  constructor(callable) {;_class13.prototype.__init29.call(this);
     this.callable = callable;
   }
   get() {
@@ -958,7 +4147,7 @@ var SyncLazyValue = (_class3 = class {
   get hasSucceeded() {
     return this.value.computedState === "succeeded";
   }
-}, _class3);
+}, _class13);
 function addAzureBlobHeaders(headers, url) {
   if (url.includes("blob.core.windows.net")) {
     headers["x-ms-blob-type"] = "BlockBlob";
@@ -986,11 +4175,11 @@ function objectIsEmpty(obj) {
 // src/mustache-utils.ts
 
 
-function lintTemplate(template, context) {
+function lintTemplate(template, context2) {
   const variables = getMustacheVars(template);
   for (const variable of variables) {
     const arrPathsReplaced = variable[1].replaceAll(/\.\d+/g, ".0");
-    const fieldExists = _core.getObjValueByPath.call(void 0, context, arrPathsReplaced.split(".")) !== void 0;
+    const fieldExists = _core.getObjValueByPath.call(void 0, context2, arrPathsReplaced.split(".")) !== void 0;
     if (!fieldExists) {
       throw new Error(`Variable '${variable[1]}' does not exist.`);
     }
@@ -1001,19 +4190,19 @@ function getMustacheVars(prompt) {
     return _mustache2.default.parse(prompt).filter(
       (span) => span[0] === "name" || span[0] === "&"
     );
-  } catch (e3) {
+  } catch (e7) {
     return [];
   }
 }
 
 // src/logger.ts
-var NoopSpan = (_class4 = class {
+var NoopSpan = (_class14 = class {
   
   
   
   
-  __init6() {this.kind = "span"}
-  constructor() {;_class4.prototype.__init6.call(this);
+  __init30() {this.kind = "span"}
+  constructor() {;_class14.prototype.__init30.call(this);
     this.id = "";
     this.spanId = "";
     this.rootSpanId = "";
@@ -1030,7 +4219,7 @@ var NoopSpan = (_class4 = class {
     return this;
   }
   end(args) {
-    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _11 => _11.endTime]), () => ( getCurrentUnixTimestamp()));
+    return _nullishCoalesce(_optionalChain([args, 'optionalAccess', _74 => _74.endTime]), () => ( getCurrentUnixTimestamp()));
   }
   async export() {
     return "";
@@ -1054,7 +4243,7 @@ var NoopSpan = (_class4 = class {
   state() {
     return _internalGetGlobalState();
   }
-}, _class4);
+}, _class14);
 var NOOP_SPAN = new NoopSpan();
 var NOOP_SPAN_PERMALINK = "https://braintrust.dev/noop-span";
 var loginSchema = _zod.z.strictObject({
@@ -1068,8 +4257,8 @@ var loginSchema = _zod.z.strictObject({
   gitMetadataSettings: _typespecs.gitMetadataSettingsSchema.nullish()
 });
 var stateNonce = 0;
-var BraintrustState = (_class5 = class _BraintrustState {
-  constructor(loginParams) {;_class5.prototype.__init7.call(this);_class5.prototype.__init8.call(this);_class5.prototype.__init9.call(this);_class5.prototype.__init10.call(this);_class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);
+var BraintrustState = (_class15 = class _BraintrustState {
+  constructor(loginParams) {;_class15.prototype.__init31.call(this);_class15.prototype.__init32.call(this);_class15.prototype.__init33.call(this);_class15.prototype.__init34.call(this);_class15.prototype.__init35.call(this);_class15.prototype.__init36.call(this);_class15.prototype.__init37.call(this);_class15.prototype.__init38.call(this);_class15.prototype.__init39.call(this);_class15.prototype.__init40.call(this);_class15.prototype.__init41.call(this);_class15.prototype.__init42.call(this);_class15.prototype.__init43.call(this);
     this.loginParams = loginParams;
     this.id = `${(/* @__PURE__ */ new Date()).toLocaleString()}-${stateNonce++}`;
     this.currentExperiment = void 0;
@@ -1108,20 +4297,20 @@ var BraintrustState = (_class5 = class _BraintrustState {
   // possibility of multiple loggers floating around, which may not log in a
   // deterministic order.
   
-  __init7() {this._overrideBgLogger = null}
-  __init8() {this.appUrl = null}
-  __init9() {this.appPublicUrl = null}
-  __init10() {this.loginToken = null}
-  __init11() {this.orgId = null}
-  __init12() {this.orgName = null}
-  __init13() {this.apiUrl = null}
-  __init14() {this.proxyUrl = null}
-  __init15() {this.loggedIn = false}
+  __init31() {this._overrideBgLogger = null}
+  __init32() {this.appUrl = null}
+  __init33() {this.appPublicUrl = null}
+  __init34() {this.loginToken = null}
+  __init35() {this.orgId = null}
+  __init36() {this.orgName = null}
+  __init37() {this.apiUrl = null}
+  __init38() {this.proxyUrl = null}
+  __init39() {this.loggedIn = false}
   
-  __init16() {this.fetch = globalThis.fetch}
-  __init17() {this._appConn = null}
-  __init18() {this._apiConn = null}
-  __init19() {this._proxyConn = null}
+  __init40() {this.fetch = globalThis.fetch}
+  __init41() {this._appConn = null}
+  __init42() {this._apiConn = null}
+  __init43() {this._proxyConn = null}
   
   resetLoginInfo() {
     this.appUrl = null;
@@ -1204,8 +4393,8 @@ var BraintrustState = (_class5 = class _BraintrustState {
   setFetch(fetch2) {
     this.loginParams.fetch = fetch2;
     this.fetch = fetch2;
-    _optionalChain([this, 'access', _12 => _12._apiConn, 'optionalAccess', _13 => _13.setFetch, 'call', _14 => _14(fetch2)]);
-    _optionalChain([this, 'access', _15 => _15._appConn, 'optionalAccess', _16 => _16.setFetch, 'call', _17 => _17(fetch2)]);
+    _optionalChain([this, 'access', _75 => _75._apiConn, 'optionalAccess', _76 => _76.setFetch, 'call', _77 => _77(fetch2)]);
+    _optionalChain([this, 'access', _78 => _78._appConn, 'optionalAccess', _79 => _79.setFetch, 'call', _80 => _80(fetch2)]);
   }
   async login(loginParams) {
     if (this.apiUrl && !loginParams.forceLogin) {
@@ -1271,7 +4460,7 @@ var BraintrustState = (_class5 = class _BraintrustState {
   enforceQueueSizeLimit(enforce) {
     this._bgLogger.get().enforceQueueSizeLimit(enforce);
   }
-}, _class5);
+}, _class15);
 var _globalState;
 function useTestBackgroundLogger() {
   const state = _internalGetGlobalState();
@@ -1283,7 +4472,7 @@ function useTestBackgroundLogger() {
   return logger;
 }
 function clearTestBackgroundLogger() {
-  _optionalChain([_internalGetGlobalState, 'call', _18 => _18(), 'optionalAccess', _19 => _19.setOverrideBgLogger, 'call', _20 => _20(null)]);
+  _optionalChain([_internalGetGlobalState, 'call', _81 => _81(), 'optionalAccess', _82 => _82.setOverrideBgLogger, 'call', _83 => _83(null)]);
 }
 function _internalSetInitialState() {
   if (_globalState) {
@@ -1918,9 +5107,9 @@ async function permalink(slug, opts) {
   if (slug === "") {
     return NOOP_SPAN_PERMALINK;
   }
-  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _21 => _21.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _84 => _84.state]), () => ( _globalState));
   const getOrgName = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _22 => _22.orgName])) {
+    if (_optionalChain([opts, 'optionalAccess', _85 => _85.orgName])) {
       return opts.orgName;
     }
     await state.login({});
@@ -1930,7 +5119,7 @@ async function permalink(slug, opts) {
     return state.orgName;
   };
   const getAppUrl = async () => {
-    if (_optionalChain([opts, 'optionalAccess', _23 => _23.appUrl])) {
+    if (_optionalChain([opts, 'optionalAccess', _86 => _86.appUrl])) {
       return opts.appUrl;
     }
     await state.login({});
@@ -2008,7 +5197,7 @@ function startSpanParentArgs(args) {
     propagatedEvent: argPropagatedEvent
   };
 }
-var Logger = (_class6 = class {
+var Logger = (_class16 = class {
   
   
   
@@ -2017,8 +5206,8 @@ var Logger = (_class6 = class {
   
   
   // For type identification.
-  __init20() {this.kind = "logger"}
-  constructor(state, lazyMetadata, logOptions = {}) {;_class6.prototype.__init20.call(this);
+  __init44() {this.kind = "logger"}
+  constructor(state, lazyMetadata, logOptions = {}) {;_class16.prototype.__init44.call(this);
     this.lazyMetadata = lazyMetadata;
     this._asyncFlush = logOptions.asyncFlush;
     this.computeMetadataArgs = logOptions.computeMetadataArgs;
@@ -2060,7 +5249,7 @@ var Logger = (_class6 = class {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _24 => _24.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _87 => _87.allowConcurrentWithSpans])) {
       throw new Error(
         "Cannot run toplevel `log` method while using spans. To log to the span, call `logger.traced` and then log with `span.log`"
       );
@@ -2128,12 +5317,12 @@ var Logger = (_class6 = class {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _25 => _25.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _88 => _88.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: this.computeMetadataArgs,
-        parentSpanIds: _optionalChain([args, 'optionalAccess', _26 => _26.parentSpanIds]),
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _27 => _27.propagatedEvent])
+        parentSpanIds: _optionalChain([args, 'optionalAccess', _89 => _89.parentSpanIds]),
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _90 => _90.propagatedEvent])
       }),
       defaultRootType: _core.SpanTypeAttribute.TASK
     });
@@ -2191,7 +5380,7 @@ var Logger = (_class6 = class {
   get asyncFlush() {
     return this._asyncFlush;
   }
-}, _class6);
+}, _class16);
 function castLogger(logger, asyncFlush) {
   if (logger === void 0) return void 0;
   if (asyncFlush !== void 0 && !!asyncFlush !== !!logger.asyncFlush) {
@@ -2207,8 +5396,8 @@ function constructLogs3Data(items) {
 function now() {
   return (/* @__PURE__ */ new Date()).getTime();
 }
-var TestBackgroundLogger = (_class7 = class {constructor() { _class7.prototype.__init21.call(this); }
-  __init21() {this.items = []}
+var TestBackgroundLogger = (_class17 = class {constructor() { _class17.prototype.__init45.call(this); }
+  __init45() {this.items = []}
   log(items) {
     this.items.push(items);
   }
@@ -2227,30 +5416,30 @@ var TestBackgroundLogger = (_class7 = class {constructor() { _class7.prototype._
     const batch = _core.mergeRowBatch.call(void 0, events);
     return batch.flat();
   }
-}, _class7);
+}, _class17);
 var BACKGROUND_LOGGER_BASE_SLEEP_TIME_S = 1;
-var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
+var HTTPBackgroundLogger = (_class18 = class _HTTPBackgroundLogger {
   
   
-  __init22() {this.activeFlush = Promise.resolve()}
-  __init23() {this.activeFlushResolved = true}
-  __init24() {this.activeFlushError = void 0}
+  __init46() {this.activeFlush = Promise.resolve()}
+  __init47() {this.activeFlushResolved = true}
+  __init48() {this.activeFlushError = void 0}
   
-  __init25() {this.syncFlush = false}
+  __init49() {this.syncFlush = false}
   // 6 MB for the AWS lambda gateway (from our own testing).
-  __init26() {this.maxRequestSize = 6 * 1024 * 1024}
-  __init27() {this.defaultBatchSize = 100}
-  __init28() {this.numTries = 3}
-  __init29() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
-  __init30() {this.queueDropLoggingPeriod = 60}
-  __init31() {this.failedPublishPayloadsDir = void 0}
-  __init32() {this.allPublishPayloadsDir = void 0}
-  __init33() {this._disabled = false}
-  __init34() {this.queueDropLoggingState = {
+  __init50() {this.maxRequestSize = 6 * 1024 * 1024}
+  __init51() {this.defaultBatchSize = 100}
+  __init52() {this.numTries = 3}
+  __init53() {this.queueDropExceedingMaxsize = DEFAULT_QUEUE_SIZE}
+  __init54() {this.queueDropLoggingPeriod = 60}
+  __init55() {this.failedPublishPayloadsDir = void 0}
+  __init56() {this.allPublishPayloadsDir = void 0}
+  __init57() {this._disabled = false}
+  __init58() {this.queueDropLoggingState = {
     numDropped: 0,
     lastLoggedTimestamp: 0
   }}
-  constructor(apiConn, opts) {;_class8.prototype.__init22.call(this);_class8.prototype.__init23.call(this);_class8.prototype.__init24.call(this);_class8.prototype.__init25.call(this);_class8.prototype.__init26.call(this);_class8.prototype.__init27.call(this);_class8.prototype.__init28.call(this);_class8.prototype.__init29.call(this);_class8.prototype.__init30.call(this);_class8.prototype.__init31.call(this);_class8.prototype.__init32.call(this);_class8.prototype.__init33.call(this);_class8.prototype.__init34.call(this);
+  constructor(apiConn, opts) {;_class18.prototype.__init46.call(this);_class18.prototype.__init47.call(this);_class18.prototype.__init48.call(this);_class18.prototype.__init49.call(this);_class18.prototype.__init50.call(this);_class18.prototype.__init51.call(this);_class18.prototype.__init52.call(this);_class18.prototype.__init53.call(this);_class18.prototype.__init54.call(this);_class18.prototype.__init55.call(this);_class18.prototype.__init56.call(this);_class18.prototype.__init57.call(this);_class18.prototype.__init58.call(this);
     opts = _nullishCoalesce(opts, () => ( {}));
     this.apiConn = apiConn;
     const syncFlushEnv = Number(isomorph_default.getEnv("BRAINTRUST_SYNC_FLUSH"));
@@ -2336,7 +5525,7 @@ var HTTPBackgroundLogger = (_class8 = class _HTTPBackgroundLogger {
       this.queue.clear();
       return;
     }
-    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _28 => _28.batchSize]), () => ( this.defaultBatchSize));
+    const batchSize = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _91 => _91.batchSize]), () => ( this.defaultBatchSize));
     const wrappedItems = this.queue.drain();
     const [allItems, attachments] = await this.unwrapLazyValues(wrappedItems);
     if (allItems.length === 0) {
@@ -2556,10 +5745,10 @@ Error: ${errorText}`;
         } catch (err) {
           if (err instanceof AggregateError) {
             for (const e of err.errors) {
-              _optionalChain([this, 'access', _29 => _29.onFlushError, 'optionalCall', _30 => _30(e)]);
+              _optionalChain([this, 'access', _92 => _92.onFlushError, 'optionalCall', _93 => _93(e)]);
             }
           } else {
-            _optionalChain([this, 'access', _31 => _31.onFlushError, 'optionalCall', _32 => _32(err)]);
+            _optionalChain([this, 'access', _94 => _94.onFlushError, 'optionalCall', _95 => _95(err)]);
           }
           this.activeFlushError = err;
         } finally {
@@ -2582,7 +5771,7 @@ Error: ${errorText}`;
   enforceQueueSizeLimit(enforce) {
     this.queue.enforceQueueSizeLimit(enforce);
   }
-}, _class8);
+}, _class18);
 function init(projectOrOptions, optionalOptions) {
   const options = (() => {
     if (typeof projectOrOptions === "string") {
@@ -3156,19 +6345,19 @@ async function summarize(options = {}) {
   return await e.summarize(options);
 }
 function currentExperiment(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _33 => _33.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _96 => _96.state]), () => ( _globalState));
   return state.currentExperiment;
 }
 function currentLogger(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _34 => _34.state]), () => ( _globalState));
-  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _35 => _35.asyncFlush]));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _97 => _97.state]), () => ( _globalState));
+  return castLogger(state.currentLogger, _optionalChain([options, 'optionalAccess', _98 => _98.asyncFlush]));
 }
 function currentSpan(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _36 => _36.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _99 => _99.state]), () => ( _globalState));
   return _nullishCoalesce(state.currentSpan.getStore(), () => ( NOOP_SPAN));
 }
 function getSpanParentObject(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _37 => _37.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _100 => _100.state]), () => ( _globalState));
   const parentSpan = currentSpan({ state });
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
@@ -3200,7 +6389,7 @@ function traced(callback, args) {
   const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runCatchFinally(
     () => {
-      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _38 => _38.setCurrent]), () => ( true))) {
+      if (_nullishCoalesce(_optionalChain([args, 'optionalAccess', _101 => _101.setCurrent]), () => ( true))) {
         return withCurrent(span, callback);
       } else {
         return callback(span);
@@ -3212,7 +6401,7 @@ function traced(callback, args) {
     },
     () => span.end()
   );
-  if (_optionalChain([args, 'optionalAccess', _39 => _39.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _40 => _40.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _102 => _102.asyncFlush]) === void 0 || _optionalChain([args, 'optionalAccess', _103 => _103.asyncFlush])) {
     return ret;
   } else {
     return (async () => {
@@ -3232,7 +6421,7 @@ function wrapTraced(fn, args) {
   };
   const hasExplicitInput = args && args.event && "input" in args.event && args.event.input !== void 0;
   const hasExplicitOutput = args && args.event && args.event.output !== void 0;
-  if (_optionalChain([args, 'optionalAccess', _41 => _41.asyncFlush])) {
+  if (_optionalChain([args, 'optionalAccess', _104 => _104.asyncFlush])) {
     return (...fnArgs) => traced((span) => {
       if (!hasExplicitInput) {
         span.log({ input: fnArgs });
@@ -3270,15 +6459,15 @@ function startSpan(args) {
   return startSpanAndIsLogger(args).span;
 }
 async function flush(options) {
-  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _42 => _42.state]), () => ( _globalState));
+  const state = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _105 => _105.state]), () => ( _globalState));
   return await state.bgLogger().flush();
 }
 function setFetch(fetch2) {
   _globalState.setFetch(fetch2);
 }
 function startSpanAndIsLogger(args) {
-  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _43 => _43.state]), () => ( _globalState));
-  const parentStr = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _44 => _44.parent]), () => ( state.currentParent.getStore()));
+  const state = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _106 => _106.state]), () => ( _globalState));
+  const parentStr = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _107 => _107.parent]), () => ( state.currentParent.getStore()));
   const components = parentStr ? _core.SpanComponentsV3.fromStr(parentStr) : void 0;
   if (components) {
     const parentSpanIds = components.data.row_id ? {
@@ -3294,18 +6483,18 @@ function startSpanAndIsLogger(args) {
       ),
       parentComputeObjectMetadataArgs: _nullishCoalesce(components.data.compute_object_metadata_args, () => ( void 0)),
       parentSpanIds,
-      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _45 => _45.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _108 => _108.propagatedEvent]), () => ( // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       (_nullishCoalesce(components.data.propagated_event, () => ( void 0)))))
     });
     return {
       span,
       isSyncFlushLogger: components.data.object_type === _core.SpanObjectTypeV3.PROJECT_LOGS && // Since there's no parent logger here, we're free to choose the async flush
       // behavior, and therefore propagate along whatever we get from the arguments
-      _optionalChain([args, 'optionalAccess', _46 => _46.asyncFlush]) === false
+      _optionalChain([args, 'optionalAccess', _109 => _109.asyncFlush]) === false
     };
   } else {
     const parentObject = getSpanParentObject({
-      asyncFlush: _optionalChain([args, 'optionalAccess', _47 => _47.asyncFlush])
+      asyncFlush: _optionalChain([args, 'optionalAccess', _110 => _110.asyncFlush])
     });
     const span = parentObject.startSpan(args);
     return {
@@ -3447,10 +6636,10 @@ function extractAttachments(event, attachments) {
       event[key] = value.reference;
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _48 => _48.type]) === _typespecs.BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
+    if (_optionalChain([value, 'optionalAccess', _111 => _111.type]) === _typespecs.BRAINTRUST_ATTACHMENT && value.key && !value.uploader) {
       continue;
     }
-    if (_optionalChain([value, 'optionalAccess', _49 => _49.reference, 'optionalAccess', _50 => _50.type]) === _typespecs.BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _51 => _51.uploader])) {
+    if (_optionalChain([value, 'optionalAccess', _112 => _112.reference, 'optionalAccess', _113 => _113.type]) === _typespecs.BRAINTRUST_ATTACHMENT && _optionalChain([value, 'optionalAccess', _114 => _114.uploader])) {
       const attachment = new Attachment({
         data: value.dataDebugString,
         filename: value.reference.filename,
@@ -3516,14 +6705,14 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
 }
 var INTERNAL_BTQL_LIMIT = 1e3;
 var MAX_BTQL_ITERATIONS = 1e4;
-var ObjectFetcher = (_class9 = class {
-  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class9.prototype.__init35.call(this);
+var ObjectFetcher = (_class19 = class {
+  constructor(objectType, pinnedVersion, mutateRecord, _internal_btql) {;_class19.prototype.__init59.call(this);
     this.objectType = objectType;
     this.pinnedVersion = pinnedVersion;
     this.mutateRecord = mutateRecord;
     this._internal_btql = _internal_btql;
   }
-  __init35() {this._fetchedData = void 0}
+  __init59() {this._fetchedData = void 0}
   get id() {
     throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
   }
@@ -3588,7 +6777,7 @@ var ObjectFetcher = (_class9 = class {
           throw new Error("Too many BTQL iterations");
         }
       }
-      this._fetchedData = this.mutateRecord ? _optionalChain([data, 'optionalAccess', _52 => _52.map, 'call', _53 => _53(this.mutateRecord)]) : data;
+      this._fetchedData = this.mutateRecord ? _optionalChain([data, 'optionalAccess', _115 => _115.map, 'call', _116 => _116(this.mutateRecord)]) : data;
     }
     return this._fetchedData || [];
   }
@@ -3610,8 +6799,8 @@ var ObjectFetcher = (_class9 = class {
       return maxVersion;
     }
   }
-}, _class9);
-var Experiment = (_class10 = class extends ObjectFetcher {
+}, _class19);
+var Experiment = (_class20 = class extends ObjectFetcher {
   
   
   
@@ -3619,9 +6808,9 @@ var Experiment = (_class10 = class extends ObjectFetcher {
   
   
   // For type identification.
-  __init36() {this.kind = "experiment"}
+  __init60() {this.kind = "experiment"}
   constructor(state, lazyMetadata, dataset) {
-    super("experiment", void 0, (r) => enrichAttachments(r, state));_class10.prototype.__init36.call(this);;
+    super("experiment", void 0, (r) => enrichAttachments(r, state));_class20.prototype.__init60.call(this);;
     this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
     this.lastStartTime = getCurrentUnixTimestamp();
@@ -3669,7 +6858,7 @@ var Experiment = (_class10 = class extends ObjectFetcher {
    * @returns The `id` of the logged event.
    */
   log(event, options) {
-    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _54 => _54.allowConcurrentWithSpans])) {
+    if (this.calledStartSpan && !_optionalChain([options, 'optionalAccess', _117 => _117.allowConcurrentWithSpans])) {
       throw new Error(
         "Cannot run toplevel `log` method while using spans. To log to the span, call `experiment.traced` and then log with `span.log`"
       );
@@ -3722,12 +6911,12 @@ var Experiment = (_class10 = class extends ObjectFetcher {
       state: this.state,
       ...startSpanParentArgs({
         state: this.state,
-        parent: _optionalChain([args, 'optionalAccess', _55 => _55.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _118 => _118.parent]),
         parentObjectType: this.parentObjectType(),
         parentObjectId: this.lazyId,
         parentComputeObjectMetadataArgs: void 0,
         parentSpanIds: void 0,
-        propagatedEvent: _optionalChain([args, 'optionalAccess', _56 => _56.propagatedEvent])
+        propagatedEvent: _optionalChain([args, 'optionalAccess', _119 => _119.propagatedEvent])
       }),
       defaultRootType: _core.SpanTypeAttribute.EVAL
     });
@@ -3873,7 +7062,7 @@ View complete results in Braintrust or run experiment.summarize() again.`
     );
     return this.id;
   }
-}, _class10);
+}, _class20);
 var ReadonlyExperiment = class extends ObjectFetcher {
   constructor(state, lazyMetadata) {
     super("experiment", void 0, (r) => enrichAttachments(r, state));
@@ -3915,7 +7104,7 @@ var executionCounter = 0;
 function newId() {
   return _uuid.v4.call(void 0, );
 }
-var SpanImpl = (_class11 = class _SpanImpl {
+var SpanImpl = (_class21 = class _SpanImpl {
   
   
   
@@ -3928,8 +7117,8 @@ var SpanImpl = (_class11 = class _SpanImpl {
   
   
   
-  __init37() {this.kind = "span"}
-  constructor(args) {;_class11.prototype.__init37.call(this);
+  __init61() {this.kind = "span"}
+  constructor(args) {;_class21.prototype.__init61.call(this);
     this._state = args.state;
     const spanAttributes = _nullishCoalesce(args.spanAttributes, () => ( {}));
     const rawEvent = _nullishCoalesce(args.event, () => ( {}));
@@ -4019,10 +7208,10 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...serializableInternalData,
       [_core.IS_MERGE_FIELD]: this.isMerge
     });
-    if (_optionalChain([partialRecord, 'access', _57 => _57.metrics, 'optionalAccess', _58 => _58.end])) {
-      this.loggedEndTime = _optionalChain([partialRecord, 'access', _59 => _59.metrics, 'optionalAccess', _60 => _60.end]);
+    if (_optionalChain([partialRecord, 'access', _120 => _120.metrics, 'optionalAccess', _121 => _121.end])) {
+      this.loggedEndTime = _optionalChain([partialRecord, 'access', _122 => _122.metrics, 'optionalAccess', _123 => _123.end]);
     }
-    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _61 => _61._spanParents, 'optionalAccess', _62 => _62.length])) {
+    if ((_nullishCoalesce(partialRecord.tags, () => ( []))).length > 0 && _optionalChain([this, 'access', _124 => _124._spanParents, 'optionalAccess', _125 => _125.length])) {
       throw new Error("Tags can only be logged to the root span");
     }
     const computeRecord = async () => ({
@@ -4067,18 +7256,18 @@ var SpanImpl = (_class11 = class _SpanImpl {
     );
   }
   startSpan(args) {
-    const parentSpanIds = _optionalChain([args, 'optionalAccess', _63 => _63.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
+    const parentSpanIds = _optionalChain([args, 'optionalAccess', _126 => _126.parent]) ? void 0 : { spanId: this._spanId, rootSpanId: this._rootSpanId };
     return new _SpanImpl({
       state: this._state,
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _64 => _64.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _127 => _127.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _65 => _65.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _128 => _128.propagatedEvent]), () => ( this.propagatedEvent))
       })
     });
   }
@@ -4092,12 +7281,12 @@ var SpanImpl = (_class11 = class _SpanImpl {
       ...args,
       ...startSpanParentArgs({
         state: this._state,
-        parent: _optionalChain([args, 'optionalAccess', _66 => _66.parent]),
+        parent: _optionalChain([args, 'optionalAccess', _129 => _129.parent]),
         parentObjectType: this.parentObjectType,
         parentObjectId: this.parentObjectId,
         parentComputeObjectMetadataArgs: this.parentComputeObjectMetadataArgs,
         parentSpanIds,
-        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _67 => _67.propagatedEvent]), () => ( this.propagatedEvent))
+        propagatedEvent: _nullishCoalesce(_optionalChain([args, 'optionalAccess', _130 => _130.propagatedEvent]), () => ( this.propagatedEvent))
       }),
       spanId
     });
@@ -4106,7 +7295,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
     let endTime;
     let internalData = {};
     if (!this.loggedEndTime) {
-      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _68 => _68.endTime]), () => ( getCurrentUnixTimestamp()));
+      endTime = _nullishCoalesce(_optionalChain([args, 'optionalAccess', _131 => _131.endTime]), () => ( getCurrentUnixTimestamp()));
       internalData = { metrics: { end: endTime } };
     } else {
       endTime = this.loggedEndTime;
@@ -4149,8 +7338,8 @@ var SpanImpl = (_class11 = class _SpanImpl {
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
       case _core.SpanObjectTypeV3.PROJECT_LOGS: {
-        const projectID = _optionalChain([args, 'optionalAccess', _69 => _69.project_id]) || this.parentObjectId.getSync().value;
-        const projectName = _optionalChain([args, 'optionalAccess', _70 => _70.project_name]);
+        const projectID = _optionalChain([args, 'optionalAccess', _132 => _132.project_id]) || this.parentObjectId.getSync().value;
+        const projectName = _optionalChain([args, 'optionalAccess', _133 => _133.project_name]);
         if (projectID) {
           return `${baseUrl}/object?object_type=project_logs&object_id=${projectID}&id=${this._id}`;
         } else if (projectName) {
@@ -4160,7 +7349,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
         }
       }
       case _core.SpanObjectTypeV3.EXPERIMENT: {
-        const expID = _optionalChain([args, 'optionalAccess', _71 => _71.experiment_id]) || _optionalChain([this, 'access', _72 => _72.parentObjectId, 'optionalAccess', _73 => _73.getSync, 'call', _74 => _74(), 'optionalAccess', _75 => _75.value]);
+        const expID = _optionalChain([args, 'optionalAccess', _134 => _134.experiment_id]) || _optionalChain([this, 'access', _135 => _135.parentObjectId, 'optionalAccess', _136 => _136.getSync, 'call', _137 => _137(), 'optionalAccess', _138 => _138.value]);
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
         } else {
@@ -4186,7 +7375,7 @@ var SpanImpl = (_class11 = class _SpanImpl {
   state() {
     return this._state;
   }
-}, _class11);
+}, _class21);
 function splitLoggingData({
   event,
   internalData
@@ -4217,7 +7406,7 @@ function splitLoggingData({
   }
   return [serializableInternalData, lazyInternalData];
 }
-var Dataset = (_class12 = class extends ObjectFetcher {
+var Dataset = (_class22 = class extends ObjectFetcher {
   constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql) {
     const isLegacyDataset = _nullishCoalesce(legacy, () => ( _core.DEFAULT_IS_LEGACY_DATASET));
     if (isLegacyDataset) {
@@ -4236,13 +7425,13 @@ var Dataset = (_class12 = class extends ObjectFetcher {
         )
       ),
       _internal_btql
-    );_class12.prototype.__init38.call(this);_class12.prototype.__init39.call(this);;
+    );_class22.prototype.__init62.call(this);_class22.prototype.__init63.call(this);;
     this.state = state;
     this.lazyMetadata = lazyMetadata;
   }
   
-  __init38() {this.__braintrust_dataset_marker = true}
-  __init39() {this.newRecords = 0}
+  __init62() {this.__braintrust_dataset_marker = true}
+  __init63() {this.newRecords = 0}
   get id() {
     return (async () => {
       return (await this.lazyMetadata.get()).dataset.id;
@@ -4457,7 +7646,7 @@ var Dataset = (_class12 = class extends ObjectFetcher {
   static isDataset(data) {
     return typeof data === "object" && data !== null && "__braintrust_dataset_marker" in data;
   }
-}, _class12);
+}, _class22);
 function renderMessage(render, message) {
   return {
     ...message,
@@ -4564,15 +7753,15 @@ function renderPromptParams(params, args, options) {
   }
   return params;
 }
-var Prompt = (_class13 = class _Prompt {
-  constructor(metadata, defaults, noTrace) {;_class13.prototype.__init40.call(this);_class13.prototype.__init41.call(this);
+var Prompt = (_class23 = class _Prompt {
+  constructor(metadata, defaults, noTrace) {;_class23.prototype.__init64.call(this);_class23.prototype.__init65.call(this);
     this.metadata = metadata;
     this.defaults = defaults;
     this.noTrace = noTrace;
   }
   
-  __init40() {this.hasParsedPromptData = false}
-  __init41() {this.__braintrust_prompt_marker = true}
+  __init64() {this.hasParsedPromptData = false}
+  __init65() {this.__braintrust_prompt_marker = true}
   get id() {
     return this.metadata.id;
   }
@@ -4586,13 +7775,13 @@ var Prompt = (_class13 = class _Prompt {
     return "slug" in this.metadata ? this.metadata.slug : this.metadata.id;
   }
   get prompt() {
-    return _optionalChain([this, 'access', _76 => _76.getParsedPromptData, 'call', _77 => _77(), 'optionalAccess', _78 => _78.prompt]);
+    return _optionalChain([this, 'access', _139 => _139.getParsedPromptData, 'call', _140 => _140(), 'optionalAccess', _141 => _141.prompt]);
   }
   get version() {
     return this.metadata[_core.TRANSACTION_ID_FIELD];
   }
   get options() {
-    return _optionalChain([this, 'access', _79 => _79.getParsedPromptData, 'call', _80 => _80(), 'optionalAccess', _81 => _81.options]) || {};
+    return _optionalChain([this, 'access', _142 => _142.getParsedPromptData, 'call', _143 => _143(), 'optionalAccess', _144 => _144.options]) || {};
   }
   get promptData() {
     return this.getParsedPromptData();
@@ -4743,7 +7932,7 @@ var Prompt = (_class13 = class _Prompt {
       return {
         type: "chat",
         messages,
-        ..._optionalChain([prompt, 'access', _82 => _82.tools, 'optionalAccess', _83 => _83.trim, 'call', _84 => _84()]) ? {
+        ..._optionalChain([prompt, 'access', _145 => _145.tools, 'optionalAccess', _146 => _146.trim, 'call', _147 => _147()]) ? {
           tools: render(prompt.tools)
         } : void 0
       };
@@ -4788,7 +7977,7 @@ var Prompt = (_class13 = class _Prompt {
       false
     );
   }
-}, _class13);
+}, _class23);
 var TEST_API_KEY = "___TEST_API_KEY__THIS_IS_NOT_REAL___";
 async function simulateLoginForTests() {
   return await login({
@@ -4811,8 +8000,8 @@ var _exportsForTestingOnly = {
 };
 
 // src/node.ts
-var _util = require('util');
-var _zlib = require('zlib'); var zlib = _interopRequireWildcard(_zlib);
+
+
 function configureNode() {
   isomorph_default.getRepoInfo = getRepoInfo;
   isomorph_default.getPastNAncestors = getPastNAncestors;
@@ -4840,10 +8029,13 @@ function configureNode() {
 
 // src/exports-node.ts
 var exports_node_exports = {};
-__export(exports_node_exports, {
+_chunkCDBUTZMHjs.__export.call(void 0, exports_node_exports, {
+  AISpanProcessor: () => AISpanProcessor,
   Attachment: () => Attachment,
   BaseAttachment: () => BaseAttachment,
   BaseExperiment: () => BaseExperiment,
+  BraintrustExporter: () => BraintrustExporter,
+  BraintrustSpanProcessor: () => BraintrustSpanProcessor,
   BraintrustState: () => BraintrustState,
   BraintrustStream: () => BraintrustStream,
   CodeFunction: () => CodeFunction,
@@ -4978,7 +8170,7 @@ async function invoke(args) {
       `Invalid function ID arguments: ${functionId.error.message}`
     );
   }
-  const request = {
+  const request3 = {
     ...functionId.data,
     input,
     messages,
@@ -4989,7 +8181,7 @@ async function invoke(args) {
     mode,
     strict
   };
-  const resp = await state.proxyConn().post(`function/invoke`, request, {
+  const resp = await state.proxyConn().post(`function/invoke`, request3, {
     headers: {
       Accept: stream ? "text/event-stream" : "application/json"
     }
@@ -5891,12 +9083,12 @@ function groupByLimit(coll, limit, iteratee, callback) {
     });
   }, (err, mapResults) => {
     var result = {};
-    var { hasOwnProperty } = Object.prototype;
+    var { hasOwnProperty: hasOwnProperty2 } = Object.prototype;
     for (var i = 0; i < mapResults.length; i++) {
       if (mapResults[i]) {
         var { key } = mapResults[i];
         var { val } = mapResults[i];
-        if (hasOwnProperty.call(result, key)) {
+        if (hasOwnProperty2.call(result, key)) {
           result[key].push(val);
         } else {
           result[key] = [val];
@@ -6077,10 +9269,10 @@ function fitNameToSpaces(name, length) {
   }
   return padded.substring(0, length - 3) + "...";
 }
-var BarProgressReporter = (_class14 = class {
+var BarProgressReporter = (_class24 = class {
   
-  __init42() {this.bars = {}}
-  constructor() {;_class14.prototype.__init42.call(this);
+  __init66() {this.bars = {}}
+  constructor() {;_class24.prototype.__init66.call(this);
     this.multiBar = new cliProgress.MultiBar(
       {
         clearOnComplete: false,
@@ -6102,7 +9294,7 @@ var BarProgressReporter = (_class14 = class {
       evaluator: fitNameToSpaces(name, MAX_NAME_LENGTH)
     });
   }
-}, _class14);
+}, _class24);
 
 // src/eval-parameters.ts
 
@@ -6124,15 +9316,15 @@ var ProjectBuilder = class {
   }
 };
 var projects = new ProjectBuilder();
-var Project = (_class15 = class {
+var Project = (_class25 = class {
   
   
   
   
   
-  __init43() {this._publishableCodeFunctions = []}
-  __init44() {this._publishablePrompts = []}
-  constructor(args) {;_class15.prototype.__init43.call(this);_class15.prototype.__init44.call(this);
+  __init67() {this._publishableCodeFunctions = []}
+  __init68() {this._publishablePrompts = []}
+  constructor(args) {;_class25.prototype.__init67.call(this);_class25.prototype.__init68.call(this);
     _initializeSpanContext();
     this.name = "name" in args ? args.name : void 0;
     this.id = "id" in args ? args.id : void 0;
@@ -6175,12 +9367,12 @@ var Project = (_class15 = class {
       functions: functionDefinitions
     });
   }
-}, _class15);
-var ToolBuilder = (_class16 = class {
-  constructor(project) {;_class16.prototype.__init45.call(this);
+}, _class25);
+var ToolBuilder = (_class26 = class {
+  constructor(project) {;_class26.prototype.__init69.call(this);
     this.project = project;
   }
-  __init45() {this.taskCounter = 0}
+  __init69() {this.taskCounter = 0}
   // This type definition is just a catch all so that the implementation can be
   // less specific than the two more specific declarations above.
   create(opts) {
@@ -6205,12 +9397,12 @@ var ToolBuilder = (_class16 = class {
     this.project.addCodeFunction(tool);
     return tool;
   }
-}, _class16);
-var ScorerBuilder = (_class17 = class {
-  constructor(project) {;_class17.prototype.__init46.call(this);
+}, _class26);
+var ScorerBuilder = (_class27 = class {
+  constructor(project) {;_class27.prototype.__init70.call(this);
     this.project = project;
   }
-  __init46() {this.taskCounter = 0}
+  __init70() {this.taskCounter = 0}
   create(opts) {
     this.taskCounter++;
     let resolvedName = opts.name;
@@ -6263,7 +9455,7 @@ var ScorerBuilder = (_class17 = class {
       this.project.addPrompt(codePrompt);
     }
   }
-}, _class17);
+}, _class27);
 var CodeFunction = class {
   constructor(project, opts) {
     this.project = project;
@@ -6427,9 +9619,9 @@ function promptDefinitionToPromptData(promptDefinition, rawTools) {
     }
   };
 }
-var ProjectNameIdMap = (_class18 = class {constructor() { _class18.prototype.__init47.call(this);_class18.prototype.__init48.call(this); }
-  __init47() {this.nameToId = {}}
-  __init48() {this.idToName = {}}
+var ProjectNameIdMap = (_class28 = class {constructor() { _class28.prototype.__init71.call(this);_class28.prototype.__init72.call(this); }
+  __init71() {this.nameToId = {}}
+  __init72() {this.idToName = {}}
   async getId(projectName) {
     if (!(projectName in this.nameToId)) {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
@@ -6462,7 +9654,7 @@ var ProjectNameIdMap = (_class18 = class {constructor() { _class18.prototype.__i
     }
     return this.getId(project.name);
   }
-}, _class18);
+}, _class28);
 
 // src/eval-parameters.ts
 
@@ -6758,14 +9950,20 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
   } else {
     data = dataResult;
   }
-  data = data.filter((d) => filters.every((f) => evaluateFilter(d, f))).flatMap(
-    (datum) => [...Array(_nullishCoalesce(evaluator.trialCount, () => ( 1))).keys()].map(() => datum)
+  const dataWithTrials = data.filter((d) => filters.every((f) => evaluateFilter(d, f))).flatMap(
+    (datum) => [...Array(_nullishCoalesce(evaluator.trialCount, () => ( 1))).keys()].map((trialIndex) => ({
+      datum,
+      trialIndex
+    }))
   );
-  progressReporter.start(evaluator.evalName, data.length);
+  progressReporter.start(evaluator.evalName, dataWithTrials.length);
   const results = [];
   const q = queue(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async (datum) => {
+    async ({
+      datum,
+      trialIndex
+    }) => {
       const eventDataset = experiment ? experiment.dataset : Dataset.isDataset(evaluator.data) ? evaluator.data : void 0;
       const baseEvent = {
         name: "eval",
@@ -6807,14 +10005,15 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                 span,
                 parameters: _nullishCoalesce(parameters, () => ( {})),
                 reportProgress: (event) => {
-                  _optionalChain([stream, 'optionalCall', _85 => _85({
+                  _optionalChain([stream, 'optionalCall', _148 => _148({
                     ...event,
                     id: rootSpan.id,
-                    origin: _optionalChain([baseEvent, 'access', _86 => _86.event, 'optionalAccess', _87 => _87.origin]),
+                    origin: _optionalChain([baseEvent, 'access', _149 => _149.event, 'optionalAccess', _150 => _150.origin]),
                     name: evaluator.evalName,
                     object_type: "task"
                   })]);
-                }
+                },
+                trialIndex
               });
               if (outputResult instanceof Promise) {
                 output = await outputResult;
@@ -6952,7 +10151,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             ...scores
           },
           error: error2,
-          origin: _optionalChain([baseEvent, 'access', _88 => _88.event, 'optionalAccess', _89 => _89.origin])
+          origin: _optionalChain([baseEvent, 'access', _151 => _151.event, 'optionalAccess', _152 => _152.origin])
         });
       };
       if (!experiment) {
@@ -6964,9 +10163,9 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
         return await experiment.traced(callback, baseEvent);
       }
     },
-    Math.max(_nullishCoalesce(evaluator.maxConcurrency, () => ( data.length)), 1)
+    Math.max(_nullishCoalesce(evaluator.maxConcurrency, () => ( dataWithTrials.length)), 1)
   );
-  q.push(data);
+  q.push(dataWithTrials);
   const cancel = async () => {
     await new Promise((_, reject2) => {
       if (evaluator.timeout) {
@@ -7109,7 +10308,7 @@ function formatMetricSummary(summary, longestMetricName) {
 
 // src/graph-framework.ts
 var graph_framework_exports = {};
-__export(graph_framework_exports, {
+_chunkCDBUTZMHjs.__export.call(void 0, graph_framework_exports, {
   AggregatorNode: () => AggregatorNode,
   GateNode: () => GateNode,
   GraphBuilder: () => GraphBuilder,
@@ -7123,24 +10322,24 @@ __export(graph_framework_exports, {
   escapePath: () => escapePath,
   unescapePath: () => unescapePath
 });
-var GraphBuilder = (_class19 = class {
-  __init49() {this.nodes = /* @__PURE__ */ new Map()}
-  __init50() {this.edges = {}}
-  __init51() {this.nodeLikeNodes = /* @__PURE__ */ new Map()}
+var GraphBuilder = (_class29 = class {
+  __init73() {this.nodes = /* @__PURE__ */ new Map()}
+  __init74() {this.edges = {}}
+  __init75() {this.nodeLikeNodes = /* @__PURE__ */ new Map()}
   // Maps node-like objects, like prompts, to their nodes
   // Special nodes
   
   
-  constructor() {;_class19.prototype.__init49.call(this);_class19.prototype.__init50.call(this);_class19.prototype.__init51.call(this);
+  constructor() {;_class29.prototype.__init73.call(this);_class29.prototype.__init74.call(this);_class29.prototype.__init75.call(this);
     this.IN = this.createInputNode();
     this.OUT = this.createOutputNode();
   }
   // Create the final GraphData object
-  async build(context) {
+  async build(context2) {
     const nodes = await Promise.all(
       Array.from(this.nodes.values()).map(async (node) => [
         node.id,
-        await node.build(context)
+        await node.build(context2)
       ])
     );
     return {
@@ -7261,7 +10460,7 @@ var GraphBuilder = (_class19 = class {
     this.nodes.set(id, promptNode);
     return promptNode;
   }
-}, _class19);
+}, _class29);
 function isProxyVariable(node) {
   return typeof node === "object" && node !== null && "__type" in node && // @ts-ignore
   node.__type === "proxy-variable";
@@ -7269,22 +10468,22 @@ function isProxyVariable(node) {
 function proxyVariableToNode(proxy) {
   return [proxy.__node, proxy.__path];
 }
-var BaseNode = (_class20 = class {
-  constructor(graph, id) {;_class20.prototype.__init52.call(this);_class20.prototype.__init53.call(this);
+var BaseNode = (_class30 = class {
+  constructor(graph, id) {;_class30.prototype.__init76.call(this);_class30.prototype.__init77.call(this);
     this.graph = graph;
     this.id = id;
   }
-  __init52() {this.__type = "node"}
-  __init53() {this.dependencies = []}
+  __init76() {this.__type = "node"}
+  __init77() {this.dependencies = []}
   addDependency(dependency) {
     this.dependencies.push(dependency);
   }
-}, _class20);
+}, _class30);
 var InputNode = class extends BaseNode {
   constructor(graph, id) {
     super(graph, id);
   }
-  async build(context) {
+  async build(context2) {
     return {
       type: "input",
       description: "Input to the graph"
@@ -7295,7 +10494,7 @@ var OutputNode = class extends BaseNode {
   constructor(graph, id) {
     super(graph, id);
   }
-  async build(context) {
+  async build(context2) {
     return {
       type: "output",
       description: "Output of the graph"
@@ -7307,10 +10506,10 @@ var PromptNode = class extends BaseNode {
     super(graph, id);
     this.prompt = prompt;
   }
-  async build(context) {
+  async build(context2) {
     return {
       type: "function",
-      function: await context.getFunctionId(this.prompt)
+      function: await context2.getFunctionId(this.prompt)
     };
   }
 };
@@ -7319,7 +10518,7 @@ var GateNode = class extends BaseNode {
     super(graph, id);
     this.condition = condition;
   }
-  async build(context) {
+  async build(context2) {
     return {
       type: "gate",
       description: "Conditional gate",
@@ -7331,7 +10530,7 @@ var AggregatorNode = class extends BaseNode {
   constructor(graph, id) {
     super(graph, id);
   }
-  async build(context) {
+  async build(context2) {
     return {
       type: "aggregator",
       description: "Aggregator"
@@ -7343,7 +10542,7 @@ var PromptTemplateNode = class extends BaseNode {
     super(graph, id);
     this.prompt = prompt;
   }
-  async build(context) {
+  async build(context2) {
     return {
       type: "prompt_template",
       prompt: this.prompt
@@ -7355,7 +10554,7 @@ var LiteralNode = class extends BaseNode {
     super(graph, id);
     this.value = value;
   }
-  async build(context) {
+  async build(context2) {
     return {
       type: "literal",
       value: this.value
@@ -7445,8 +10644,8 @@ function parseSpanFromResponseCreateParams(params) {
 }
 function parseEventFromResponseCreateResult(result) {
   return {
-    output: _optionalChain([result, 'optionalAccess', _90 => _90.output_text]) || "",
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _91 => _91.usage]))
+    output: _optionalChain([result, 'optionalAccess', _153 => _153.output_text]) || "",
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _154 => _154.usage]))
   };
 }
 function traceResponseCreateStream(stream, timedSpan) {
@@ -7463,7 +10662,7 @@ function traceResponseCreateStream(stream, timedSpan) {
       return result;
     }
     const item = result.value;
-    if (!item || !_optionalChain([item, 'optionalAccess', _92 => _92.type]) || !_optionalChain([item, 'optionalAccess', _93 => _93.response])) {
+    if (!item || !_optionalChain([item, 'optionalAccess', _155 => _155.type]) || !_optionalChain([item, 'optionalAccess', _156 => _156.response])) {
       return result;
     }
     const event = parseLogFromItem(item);
@@ -7474,23 +10673,23 @@ function traceResponseCreateStream(stream, timedSpan) {
   };
 }
 function parseLogFromItem(item) {
-  if (!item || !_optionalChain([item, 'optionalAccess', _94 => _94.type]) || !_optionalChain([item, 'optionalAccess', _95 => _95.response])) {
+  if (!item || !_optionalChain([item, 'optionalAccess', _157 => _157.type]) || !_optionalChain([item, 'optionalAccess', _158 => _158.response])) {
     return {};
   }
   const response = item.response;
   switch (item.type) {
     case "response.completed":
       const texts = [];
-      for (const output of _optionalChain([response, 'optionalAccess', _96 => _96.output]) || []) {
-        for (const content of _optionalChain([output, 'optionalAccess', _97 => _97.content]) || []) {
-          if (_optionalChain([content, 'optionalAccess', _98 => _98.type]) === "output_text") {
+      for (const output of _optionalChain([response, 'optionalAccess', _159 => _159.output]) || []) {
+        for (const content of _optionalChain([output, 'optionalAccess', _160 => _160.content]) || []) {
+          if (_optionalChain([content, 'optionalAccess', _161 => _161.type]) === "output_text") {
             texts.push(content.text);
           }
         }
       }
       return {
         output: texts.join(""),
-        metrics: parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _99 => _99.usage]))
+        metrics: parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _162 => _162.usage]))
       };
     default:
       return {};
@@ -7657,8 +10856,8 @@ function wrapOpenAIv4(openai) {
   const embeddingProxy = createEndpointProxy(openai.embeddings, wrapEmbeddings);
   const moderationProxy = createEndpointProxy(openai.moderations, wrapModerations);
   let betaProxy2;
-  if (_optionalChain([openai, 'access', _100 => _100.beta, 'optionalAccess', _101 => _101.chat, 'optionalAccess', _102 => _102.completions, 'optionalAccess', _103 => _103.stream])) {
-    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _104 => _104.beta, 'optionalAccess', _105 => _105.chat, 'access', _106 => _106.completions]), {
+  if (_optionalChain([openai, 'access', _163 => _163.beta, 'optionalAccess', _164 => _164.chat, 'optionalAccess', _165 => _165.completions, 'optionalAccess', _166 => _166.stream])) {
+    const betaChatCompletionProxy = new Proxy(_optionalChain([openai, 'optionalAccess', _167 => _167.beta, 'optionalAccess', _168 => _168.chat, 'access', _169 => _169.completions]), {
       get(target, name, receiver) {
         const baseVal = Reflect.get(target, name, receiver);
         if (name === "parse") {
@@ -7706,7 +10905,7 @@ function wrapOpenAIv4(openai) {
   });
 }
 function logCompletionResponse(startTime, response, span) {
-  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _107 => _107.usage]));
+  const metrics = parseMetricsFromUsage(_optionalChain([response, 'optionalAccess', _170 => _170.usage]));
   metrics.time_to_first_token = getCurrentUnixTimestamp() - startTime;
   span.log({
     output: response.choices,
@@ -7908,7 +11107,7 @@ function parseChatCompletionParams(params) {
 function processEmbeddingResponse(result, span) {
   span.log({
     output: { embedding_length: result.data[0].embedding.length },
-    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _108 => _108.usage]))
+    metrics: parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _171 => _171.usage]))
   });
 }
 function processModerationResponse(result, span) {
@@ -7938,10 +11137,10 @@ function postprocessStreamingResults(allResults) {
     if (result.usage) {
       metrics = {
         ...metrics,
-        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _109 => _109.usage]))
+        ...parseMetricsFromUsage(_optionalChain([result, 'optionalAccess', _172 => _172.usage]))
       };
     }
-    const delta = _optionalChain([result, 'access', _110 => _110.choices, 'optionalAccess', _111 => _111[0], 'optionalAccess', _112 => _112.delta]);
+    const delta = _optionalChain([result, 'access', _173 => _173.choices, 'optionalAccess', _174 => _174[0], 'optionalAccess', _175 => _175.delta]);
     if (!delta) {
       continue;
     }
@@ -8024,7 +11223,7 @@ var WrapperStream = class {
 // src/wrappers/ai-sdk.ts
 function wrapAISDKModel(model) {
   const m = model;
-  if (_optionalChain([m, 'optionalAccess', _113 => _113.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _114 => _114.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _115 => _115.modelId]) === "string") {
+  if (_optionalChain([m, 'optionalAccess', _176 => _176.specificationVersion]) === "v1" && typeof _optionalChain([m, 'optionalAccess', _177 => _177.provider]) === "string" && typeof _optionalChain([m, 'optionalAccess', _178 => _178.modelId]) === "string") {
     return new BraintrustLanguageModelWrapper(m);
   } else {
     console.warn("Unsupported AI SDK model. Not wrapping.");
@@ -8080,10 +11279,10 @@ var BraintrustLanguageModelWrapper = class {
         metrics: {
           time_to_first_token: getCurrentUnixTimestamp() - startTime,
           tokens: !isEmpty(ret.usage) ? ret.usage.promptTokens + ret.usage.completionTokens : void 0,
-          prompt_tokens: _optionalChain([ret, 'access', _116 => _116.usage, 'optionalAccess', _117 => _117.promptTokens]),
-          completion_tokens: _optionalChain([ret, 'access', _118 => _118.usage, 'optionalAccess', _119 => _119.completionTokens]),
+          prompt_tokens: _optionalChain([ret, 'access', _179 => _179.usage, 'optionalAccess', _180 => _180.promptTokens]),
+          completion_tokens: _optionalChain([ret, 'access', _181 => _181.usage, 'optionalAccess', _182 => _182.completionTokens]),
           cached: parseCachedHeader(
-            _nullishCoalesce(_optionalChain([ret, 'access', _120 => _120.rawResponse, 'optionalAccess', _121 => _121.headers, 'optionalAccess', _122 => _122[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _123 => _123.rawResponse, 'optionalAccess', _124 => _124.headers, 'optionalAccess', _125 => _125[LEGACY_CACHED_HEADER]])))
+            _nullishCoalesce(_optionalChain([ret, 'access', _183 => _183.rawResponse, 'optionalAccess', _184 => _184.headers, 'optionalAccess', _185 => _185[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _186 => _186.rawResponse, 'optionalAccess', _187 => _187.headers, 'optionalAccess', _188 => _188[LEGACY_CACHED_HEADER]])))
           )
         }
       });
@@ -8175,10 +11374,10 @@ var BraintrustLanguageModelWrapper = class {
                 metrics: {
                   time_to_first_token,
                   tokens: !isEmpty(usage) ? usage.promptTokens + usage.completionTokens : void 0,
-                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _126 => _126.promptTokens]),
-                  completion_tokens: _optionalChain([usage, 'optionalAccess', _127 => _127.completionTokens]),
+                  prompt_tokens: _optionalChain([usage, 'optionalAccess', _189 => _189.promptTokens]),
+                  completion_tokens: _optionalChain([usage, 'optionalAccess', _190 => _190.completionTokens]),
                   cached: parseCachedHeader(
-                    _nullishCoalesce(_optionalChain([ret, 'access', _128 => _128.rawResponse, 'optionalAccess', _129 => _129.headers, 'optionalAccess', _130 => _130[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _131 => _131.rawResponse, 'optionalAccess', _132 => _132.headers, 'optionalAccess', _133 => _133[LEGACY_CACHED_HEADER]])))
+                    _nullishCoalesce(_optionalChain([ret, 'access', _191 => _191.rawResponse, 'optionalAccess', _192 => _192.headers, 'optionalAccess', _193 => _193[X_CACHED_HEADER]]), () => ( _optionalChain([ret, 'access', _194 => _194.rawResponse, 'optionalAccess', _195 => _195.headers, 'optionalAccess', _196 => _196[LEGACY_CACHED_HEADER]])))
                   )
                 }
               });
@@ -8225,7 +11424,7 @@ function postProcessPrompt(prompt) {
         return [
           {
             role: "assistant",
-            content: _optionalChain([textPart, 'optionalAccess', _134 => _134.text]),
+            content: _optionalChain([textPart, 'optionalAccess', _197 => _197.text]),
             ...toolCallParts.length > 0 ? {
               tool_calls: toolCallParts.map((part) => ({
                 id: part.toolCallId,
@@ -8450,9 +11649,9 @@ function streamNextProxy(stream, sspan) {
       return result;
     }
     const item = result.value;
-    switch (_optionalChain([item, 'optionalAccess', _135 => _135.type])) {
+    switch (_optionalChain([item, 'optionalAccess', _198 => _198.type])) {
       case "message_start":
-        const msg = _optionalChain([item, 'optionalAccess', _136 => _136.message]);
+        const msg = _optionalChain([item, 'optionalAccess', _199 => _199.message]);
         if (msg) {
           const event = parseEventFromMessage(msg);
           totals = { ...totals, ...event.metrics };
@@ -8460,20 +11659,20 @@ function streamNextProxy(stream, sspan) {
         }
         break;
       case "content_block_delta":
-        if (_optionalChain([item, 'access', _137 => _137.delta, 'optionalAccess', _138 => _138.type]) === "text_delta") {
-          const text = _optionalChain([item, 'optionalAccess', _139 => _139.delta, 'optionalAccess', _140 => _140.text]);
+        if (_optionalChain([item, 'access', _200 => _200.delta, 'optionalAccess', _201 => _201.type]) === "text_delta") {
+          const text = _optionalChain([item, 'optionalAccess', _202 => _202.delta, 'optionalAccess', _203 => _203.text]);
           if (text) {
             deltas.push(text);
           }
         }
         break;
       case "message_delta":
-        const usage = _optionalChain([item, 'optionalAccess', _141 => _141.usage]);
+        const usage = _optionalChain([item, 'optionalAccess', _204 => _204.usage]);
         if (usage) {
           const metrics = parseMetricsFromUsage2(usage);
           totals = { ...totals, ...metrics };
         }
-        const delta = _optionalChain([item, 'optionalAccess', _142 => _142.delta]);
+        const delta = _optionalChain([item, 'optionalAccess', _205 => _205.delta]);
         if (delta) {
           metadata = { ...metadata, ...delta };
         }
@@ -8485,8 +11684,8 @@ function streamNextProxy(stream, sspan) {
   };
 }
 function parseEventFromMessage(message) {
-  const output = _optionalChain([message, 'optionalAccess', _143 => _143.content]) || null;
-  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _144 => _144.usage]));
+  const output = _optionalChain([message, 'optionalAccess', _206 => _206.content]) || null;
+  const metrics = parseMetricsFromUsage2(_optionalChain([message, 'optionalAccess', _207 => _207.usage]));
   const metas = ["stop_reason", "stop_sequence"];
   const metadata = {};
   for (const m of metas) {
@@ -8534,6 +11733,231 @@ function coalesceInput(messages, system) {
   return input;
 }
 
+// src/otel.ts
+var otelApi = null;
+var otelSdk = null;
+var OTEL_AVAILABLE = false;
+try {
+  otelApi = (_chunkCDBUTZMHjs.init_esm.call(void 0, ), _chunkCDBUTZMHjs.__toCommonJS.call(void 0, _chunkCDBUTZMHjs.esm_exports));
+  otelSdk = (init_esm5(), _chunkCDBUTZMHjs.__toCommonJS.call(void 0, esm_exports2));
+  OTEL_AVAILABLE = true;
+} catch (error2) {
+  console.warn(
+    "OpenTelemetry packages are not installed. Install them with: npm install @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-http @opentelemetry/resources @opentelemetry/semantic-conventions"
+  );
+  OTEL_AVAILABLE = false;
+}
+var FILTER_PREFIXES = ["gen_ai.", "braintrust.", "llm.", "ai."];
+var AISpanProcessor = class _AISpanProcessor {
+  static checkOtelAvailable() {
+    if (!OTEL_AVAILABLE) {
+      throw new Error(
+        "OpenTelemetry packages are not installed. Install them with: npm install @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-http @opentelemetry/resources @opentelemetry/semantic-conventions"
+      );
+    }
+  }
+  
+  
+  /**
+   * Initialize the filter span processor.
+   *
+   * @param processor - The wrapped span processor that will receive filtered spans
+   * @param customFilter - Optional function that takes a span and returns:
+   *                      true to keep, false to drop,
+   *                      null/undefined to not influence the decision
+   */
+  constructor(processor, customFilter) {
+    _AISpanProcessor.checkOtelAvailable();
+    this.processor = processor;
+    this.customFilter = customFilter;
+  }
+  /**
+   * Forward span start events to the inner processor.
+   */
+  onStart(span, parentContext) {
+    this.processor.onStart(span, parentContext);
+  }
+  /**
+   * Apply filtering logic and conditionally forward span end events.
+   */
+  onEnd(span) {
+    const shouldKeep = this.shouldKeepFilteredSpan(span);
+    if (shouldKeep) {
+      this.processor.onEnd(span);
+    }
+  }
+  /**
+   * Shutdown the inner processor.
+   */
+  shutdown() {
+    return this.processor.shutdown();
+  }
+  /**
+   * Force flush the inner processor.
+   */
+  forceFlush() {
+    return this.processor.forceFlush();
+  }
+  /**
+   * Determine if a span should be kept based on filtering criteria.
+   *
+   * Keep spans if:
+   * 1. It's a root span (no parent)
+   * 2. Custom filter returns true/false (if provided)
+   * 3. Span name starts with 'gen_ai.', 'braintrust.', 'llm.', or 'ai.'
+   * 4. Any attribute name starts with those prefixes
+   */
+  shouldKeepFilteredSpan(span) {
+    if (!span) {
+      return false;
+    }
+    if (!span.parentSpanContext) {
+      return true;
+    }
+    if (this.customFilter) {
+      const customResult = this.customFilter(span);
+      if (customResult === true) {
+        return true;
+      } else if (customResult === false) {
+        return false;
+      }
+    }
+    if (FILTER_PREFIXES.some((prefix) => span.name.startsWith(prefix))) {
+      return true;
+    }
+    const attributes = span.attributes;
+    if (attributes) {
+      const attributeNames = Object.keys(attributes);
+      if (attributeNames.some(
+        (name) => FILTER_PREFIXES.some((prefix) => name.startsWith(prefix))
+      )) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
+  static checkOtelAvailable() {
+    if (!OTEL_AVAILABLE) {
+      throw new Error(
+        "OpenTelemetry packages are not installed. Install them with: npm install @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-http @opentelemetry/resources @opentelemetry/semantic-conventions"
+      );
+    }
+  }
+  
+  
+  constructor(options = {}) {
+    _BraintrustSpanProcessor.checkOtelAvailable();
+    const apiKey = options.apiKey || process.env.BRAINTRUST_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "Braintrust API key is required. Set BRAINTRUST_API_KEY environment variable or pass apiKey option."
+      );
+    }
+    let apiUrl = options.apiUrl || process.env.BRAINTRUST_API_URL || "https://api.braintrust.dev";
+    if (!apiUrl.endsWith("/")) {
+      apiUrl += "/";
+    }
+    let parent = options.parent || process.env.BRAINTRUST_PARENT;
+    if (!parent) {
+      parent = "project_name:default-otel-project";
+      console.info(
+        `No parent specified, using default: ${parent}. Configure with BRAINTRUST_PARENT environment variable or parent parameter.`
+      );
+    }
+    let exporter;
+    try {
+      const {
+        OTLPTraceExporter: OTLPTraceExporter2
+      } = (init_esm9(), _chunkCDBUTZMHjs.__toCommonJS.call(void 0, esm_exports3));
+      const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "x-bt-parent": parent,
+        ...options.headers
+      };
+      exporter = new OTLPTraceExporter2({
+        url: new URL("otel/v1/traces", apiUrl).href,
+        headers
+      });
+    } catch (error2) {
+      throw new Error(
+        "Failed to create OTLP exporter. Make sure @opentelemetry/exporter-trace-otlp-http is installed."
+      );
+    }
+    if (!otelSdk) {
+      throw new Error("OpenTelemetry SDK not available");
+    }
+    this.processor = new otelSdk.BatchSpanProcessor(exporter);
+    if (options.filterAISpans === true) {
+      this.aiSpanProcessor = new AISpanProcessor(
+        this.processor,
+        options.customFilter
+      );
+    } else {
+      this.aiSpanProcessor = this.processor;
+    }
+  }
+  onStart(span, parentContext) {
+    this.aiSpanProcessor.onStart(span, parentContext);
+  }
+  onEnd(span) {
+    this.aiSpanProcessor.onEnd(span);
+  }
+  shutdown() {
+    return this.aiSpanProcessor.shutdown();
+  }
+  forceFlush() {
+    return this.aiSpanProcessor.forceFlush();
+  }
+};
+var BraintrustExporter = (_class31 = class _BraintrustExporter {
+  static checkOtelAvailable() {
+    if (!OTEL_AVAILABLE) {
+      throw new Error(
+        "OpenTelemetry packages are not installed. Install them with: npm install @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/exporter-trace-otlp-http @opentelemetry/resources @opentelemetry/semantic-conventions"
+      );
+    }
+  }
+  
+  __init78() {this.spans = []}
+  __init79() {this.callbacks = []}
+  constructor(options = {}) {;_class31.prototype.__init78.call(this);_class31.prototype.__init79.call(this);
+    _BraintrustExporter.checkOtelAvailable();
+    this.processor = new BraintrustSpanProcessor(options);
+  }
+  /**
+   * Export spans to Braintrust by simulating span processor behavior.
+   */
+  export(spans, resultCallback) {
+    try {
+      spans.forEach((span) => {
+        this.processor.onEnd(span);
+      });
+      this.processor.forceFlush().then(() => {
+        resultCallback({ code: 0 });
+      }).catch((error2) => {
+        resultCallback({ code: 1, error: error2 });
+      });
+    } catch (error2) {
+      resultCallback({ code: 1, error: error2 });
+    }
+  }
+  /**
+   * Shutdown the exporter.
+   */
+  shutdown() {
+    return this.processor.shutdown();
+  }
+  /**
+   * Force flush the exporter.
+   */
+  forceFlush() {
+    return this.processor.forceFlush();
+  }
+}, _class31);
+
 // dev/types.ts
 
 
@@ -8676,4 +12100,7 @@ var index_default = exports_node_exports;
 
 
 
-exports.Attachment = Attachment; exports.BaseAttachment = BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.Dataset = Dataset; exports.ERR_PERMALINK = ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = Experiment; exports.ExternalAttachment = ExternalAttachment; exports.FailedHTTPResponse = FailedHTTPResponse; exports.INTERNAL_BTQL_LIMIT = INTERNAL_BTQL_LIMIT; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.Project = Project; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = Prompt; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.X_CACHED_HEADER = X_CACHED_HEADER; exports._exportsForTestingOnly = _exportsForTestingOnly; exports._internalGetGlobalState = _internalGetGlobalState; exports._internalSetInitialState = _internalSetInitialState; exports.braintrustStreamChunkSchema = braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.createFinalValuePassThroughStream = createFinalValuePassThroughStream; exports.currentExperiment = currentExperiment; exports.currentLogger = currentLogger; exports.currentSpan = currentSpan; exports.default = index_default; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.permalink = permalink; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = setFetch; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.toolFunctionDefinitionSchema = _typespecs.toolFunctionDefinitionSchema; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAnthropic = wrapAnthropic; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;
+
+
+
+exports.AISpanProcessor = AISpanProcessor; exports.Attachment = Attachment; exports.BaseAttachment = BaseAttachment; exports.BaseExperiment = BaseExperiment; exports.BraintrustExporter = BraintrustExporter; exports.BraintrustSpanProcessor = BraintrustSpanProcessor; exports.BraintrustState = BraintrustState; exports.BraintrustStream = BraintrustStream; exports.CodeFunction = CodeFunction; exports.CodePrompt = CodePrompt; exports.Dataset = Dataset; exports.ERR_PERMALINK = ERR_PERMALINK; exports.Eval = Eval; exports.EvalResultWithSummary = EvalResultWithSummary; exports.Experiment = Experiment; exports.ExternalAttachment = ExternalAttachment; exports.FailedHTTPResponse = FailedHTTPResponse; exports.INTERNAL_BTQL_LIMIT = INTERNAL_BTQL_LIMIT; exports.LEGACY_CACHED_HEADER = LEGACY_CACHED_HEADER; exports.LazyValue = LazyValue; exports.Logger = Logger; exports.NOOP_SPAN = NOOP_SPAN; exports.NOOP_SPAN_PERMALINK = NOOP_SPAN_PERMALINK; exports.NoopSpan = NoopSpan; exports.Project = Project; exports.ProjectNameIdMap = ProjectNameIdMap; exports.Prompt = Prompt; exports.PromptBuilder = PromptBuilder; exports.ReadonlyAttachment = ReadonlyAttachment; exports.ReadonlyExperiment = ReadonlyExperiment; exports.Reporter = Reporter; exports.ScorerBuilder = ScorerBuilder; exports.SpanImpl = SpanImpl; exports.TestBackgroundLogger = TestBackgroundLogger; exports.ToolBuilder = ToolBuilder; exports.X_CACHED_HEADER = X_CACHED_HEADER; exports._exportsForTestingOnly = _exportsForTestingOnly; exports._internalGetGlobalState = _internalGetGlobalState; exports._internalSetInitialState = _internalSetInitialState; exports.braintrustStreamChunkSchema = braintrustStreamChunkSchema; exports.buildLocalSummary = buildLocalSummary; exports.createFinalValuePassThroughStream = createFinalValuePassThroughStream; exports.currentExperiment = currentExperiment; exports.currentLogger = currentLogger; exports.currentSpan = currentSpan; exports.default = index_default; exports.defaultErrorScoreHandler = defaultErrorScoreHandler; exports.deserializePlainStringAsJSON = deserializePlainStringAsJSON; exports.devNullWritableStream = devNullWritableStream; exports.evaluatorDefinitionSchema = evaluatorDefinitionSchema; exports.evaluatorDefinitionsSchema = evaluatorDefinitionsSchema; exports.flush = flush; exports.getSpanParentObject = getSpanParentObject; exports.graph = graph_framework_exports; exports.init = init; exports.initDataset = initDataset; exports.initExperiment = initExperiment; exports.initFunction = initFunction; exports.initLogger = initLogger; exports.invoke = invoke; exports.loadPrompt = loadPrompt; exports.log = log; exports.logError = logError; exports.login = login; exports.loginToState = loginToState; exports.newId = newId; exports.parseCachedHeader = parseCachedHeader; exports.permalink = permalink; exports.projects = projects; exports.promptContentsSchema = promptContentsSchema; exports.promptDefinitionSchema = promptDefinitionSchema; exports.promptDefinitionToPromptData = promptDefinitionToPromptData; exports.promptDefinitionWithToolsSchema = promptDefinitionWithToolsSchema; exports.renderMessage = renderMessage; exports.renderPromptParams = renderPromptParams; exports.reportFailures = reportFailures; exports.runEvaluator = runEvaluator; exports.setFetch = setFetch; exports.spanComponentsToObjectId = spanComponentsToObjectId; exports.startSpan = startSpan; exports.summarize = summarize; exports.toolFunctionDefinitionSchema = _typespecs.toolFunctionDefinitionSchema; exports.traceable = traceable; exports.traced = traced; exports.updateSpan = updateSpan; exports.withCurrent = withCurrent; exports.withDataset = withDataset; exports.withExperiment = withExperiment; exports.withLogger = withLogger; exports.withParent = withParent; exports.wrapAISDKModel = wrapAISDKModel; exports.wrapAnthropic = wrapAnthropic; exports.wrapOpenAI = wrapOpenAI; exports.wrapOpenAIv4 = wrapOpenAIv4; exports.wrapTraced = wrapTraced;