agentv 3.1.0 → 3.2.0

package/dist/chunk-SR4I5KET.js

@@ -0,0 +1,1238 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  ATTR_TELEMETRY_SDK_LANGUAGE,
+  ATTR_TELEMETRY_SDK_NAME,
+  ATTR_TELEMETRY_SDK_VERSION,
+  TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+  init_esm as init_esm2
+} from "./chunk-VQ2ZO7XJ.js";
+import {
+  DiagLogLevel,
+  TraceFlags,
+  baggageEntryMetadataFromString,
+  context,
+  createContextKey,
+  diag,
+  init_esm,
+  isSpanContextValid,
+  propagation,
+  trace
+} from "./chunk-LRULMAAA.js";
+import {
+  __esm,
+  __export
+} from "./chunk-5H446C7X.js";
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+import { inspect } from "util";
+function getNumberFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (isNaN(value)) {
+    diag.warn(`Unknown value ${inspect(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;
+}
+function getBooleanFromEnv(key) {
+  const raw = process.env[key]?.trim().toLowerCase();
+  if (raw == null || raw === "") {
+    return false;
+  }
+  if (raw === "true") {
+    return true;
+  } else if (raw === "false") {
+    return false;
+  } else {
+    diag.warn(`Unknown value ${inspect(raw)} for ${key}, expected 'true' or 'false', falling back to 'false' (default)`);
+    return false;
+  }
+}
+function getStringListFromEnv(key) {
+  return getStringFromEnv(key)?.split(",").map((v) => v.trim()).filter((s) => s !== "");
+}
+var init_environment = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js"() {
+    "use strict";
+    init_esm();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/version.js"() {
+    "use strict";
+    VERSION = "2.5.1";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/semconv.js
+var ATTR_PROCESS_RUNTIME_NAME;
+var init_semconv = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/semconv.js"() {
+    "use strict";
+    ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
+var SDK_INFO;
+var init_sdk_info = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/globalThis.js
+var _globalThis;
+var init_globalThis = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/globalThis.js"() {
+    "use strict";
+    _globalThis = globalThis;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/node/index.js
+var otperformance;
+var init_node = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_environment();
+    init_globalThis();
+    init_sdk_info();
+    otperformance = performance;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/index.js
+var init_platform = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/index.js"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+function suppressTracing(context2) {
+  return context2.setValue(SUPPRESS_TRACING_KEY, true);
+}
+function unsuppressTracing(context2) {
+  return context2.deleteValue(SUPPRESS_TRACING_KEY);
+}
+function isTracingSuppressed(context2) {
+  return context2.getValue(SUPPRESS_TRACING_KEY) === true;
+}
+var SUPPRESS_TRACING_KEY;
+var init_suppress_tracing = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js"() {
+    "use strict";
+    init_esm();
+    SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var BAGGAGE_KEY_PAIR_SEPARATOR, BAGGAGE_PROPERTIES_SEPARATOR, BAGGAGE_ITEMS_SEPARATOR, BAGGAGE_HEADER, BAGGAGE_MAX_NAME_VALUE_PAIRS, BAGGAGE_MAX_PER_NAME_VALUE_PAIRS, BAGGAGE_MAX_TOTAL_LENGTH;
+var init_constants = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/constants.js"() {
+    "use strict";
+    BAGGAGE_KEY_PAIR_SEPARATOR = "=";
+    BAGGAGE_PROPERTIES_SEPARATOR = ";";
+    BAGGAGE_ITEMS_SEPARATOR = ",";
+    BAGGAGE_HEADER = "baggage";
+    BAGGAGE_MAX_NAME_VALUE_PAIRS = 180;
+    BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096;
+    BAGGAGE_MAX_TOTAL_LENGTH = 8192;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+function serializeKeyPairs(keyPairs) {
+  return keyPairs.reduce((hValue, current) => {
+    const value = `${hValue}${hValue !== "" ? BAGGAGE_ITEMS_SEPARATOR : ""}${current}`;
+    return value.length > BAGGAGE_MAX_TOTAL_LENGTH ? hValue : value;
+  }, "");
+}
+function getKeyPairs(baggage) {
+  return baggage.getAllEntries().map(([key, value]) => {
+    let entry = `${encodeURIComponent(key)}=${encodeURIComponent(value.value)}`;
+    if (value.metadata !== void 0) {
+      entry += BAGGAGE_PROPERTIES_SEPARATOR + value.metadata.toString();
+    }
+    return entry;
+  });
+}
+function parsePairKeyValue(entry) {
+  if (!entry)
+    return;
+  const metadataSeparatorIndex = entry.indexOf(BAGGAGE_PROPERTIES_SEPARATOR);
+  const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex);
+  const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
+  if (separatorIndex <= 0)
+    return;
+  const rawKey = keyPairPart.substring(0, separatorIndex).trim();
+  const rawValue = keyPairPart.substring(separatorIndex + 1).trim();
+  if (!rawKey || !rawValue)
+    return;
+  let key;
+  let value;
+  try {
+    key = decodeURIComponent(rawKey);
+    value = decodeURIComponent(rawValue);
+  } catch {
+    return;
+  }
+  let metadata;
+  if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) {
+    const metadataString = entry.substring(metadataSeparatorIndex + 1);
+    metadata = baggageEntryMetadataFromString(metadataString);
+  }
+  return { key, value, metadata };
+}
+function parseKeyPairsIntoRecord(value) {
+  const result = {};
+  if (typeof value === "string" && value.length > 0) {
+    value.split(BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => {
+      const keyPair = parsePairKeyValue(entry);
+      if (keyPair !== void 0 && keyPair.value.length > 0) {
+        result[keyPair.key] = keyPair.value;
+      }
+    });
+  }
+  return result;
+}
+var init_utils = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/utils.js"() {
+    "use strict";
+    init_esm();
+    init_constants();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
+var W3CBaggagePropagator;
+var init_W3CBaggagePropagator = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js"() {
+    "use strict";
+    init_esm();
+    init_suppress_tracing();
+    init_constants();
+    init_utils();
+    W3CBaggagePropagator = class {
+      inject(context2, carrier, setter) {
+        const baggage = propagation.getBaggage(context2);
+        if (!baggage || isTracingSuppressed(context2))
+          return;
+        const keyPairs = getKeyPairs(baggage).filter((pair) => {
+          return pair.length <= BAGGAGE_MAX_PER_NAME_VALUE_PAIRS;
+        }).slice(0, BAGGAGE_MAX_NAME_VALUE_PAIRS);
+        const headerValue = serializeKeyPairs(keyPairs);
+        if (headerValue.length > 0) {
+          setter.set(carrier, BAGGAGE_HEADER, headerValue);
+        }
+      }
+      extract(context2, carrier, getter) {
+        const headerValue = getter.get(carrier, BAGGAGE_HEADER);
+        const baggageString = Array.isArray(headerValue) ? headerValue.join(BAGGAGE_ITEMS_SEPARATOR) : headerValue;
+        if (!baggageString)
+          return context2;
+        const baggage = {};
+        if (baggageString.length === 0) {
+          return context2;
+        }
+        const pairs = baggageString.split(BAGGAGE_ITEMS_SEPARATOR);
+        pairs.forEach((entry) => {
+          const keyPair = parsePairKeyValue(entry);
+          if (keyPair) {
+            const baggageEntry = { value: keyPair.value };
+            if (keyPair.metadata) {
+              baggageEntry.metadata = keyPair.metadata;
+            }
+            baggage[keyPair.key] = baggageEntry;
+          }
+        });
+        if (Object.entries(baggage).length === 0) {
+          return context2;
+        }
+        return propagation.setBaggage(context2, propagation.createBaggage(baggage));
+      }
+      fields() {
+        return [BAGGAGE_HEADER];
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/anchored-clock.js
+var AnchoredClock;
+var init_anchored_clock = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/anchored-clock.js"() {
+    "use strict";
+    AnchoredClock = class {
+      _monotonicClock;
+      _epochMillis;
+      _performanceMillis;
+      /**
+       * Create a new AnchoredClock anchored to the current time returned by systemClock.
+       *
+       * @param systemClock should be a clock that returns the number of milliseconds since January 1 1970 such as Date
+       * @param monotonicClock should be a clock that counts milliseconds monotonically such as window.performance or perf_hooks.performance
+       */
+      constructor(systemClock, monotonicClock) {
+        this._monotonicClock = monotonicClock;
+        this._epochMillis = systemClock.now();
+        this._performanceMillis = monotonicClock.now();
+      }
+      /**
+       * Returns the current time by adding the number of milliseconds since the
+       * AnchoredClock was created to the creation epoch time
+       */
+      now() {
+        const delta = this._monotonicClock.now() - this._performanceMillis;
+        return this._epochMillis + delta;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/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 in attributes) {
+    if (!Object.prototype.hasOwnProperty.call(attributes, key)) {
+      continue;
+    }
+    if (!isAttributeKey(key)) {
+      diag.warn(`Invalid attribute key: ${key}`);
+      continue;
+    }
+    const val = attributes[key];
+    if (!isAttributeValue(val)) {
+      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 !== "";
+}
+function isAttributeValue(val) {
+  if (val == null) {
+    return true;
+  }
+  if (Array.isArray(val)) {
+    return isHomogeneousAttributeValueArray(val);
+  }
+  return isValidPrimitiveAttributeValueType(typeof val);
+}
+function isHomogeneousAttributeValueArray(arr) {
+  let type;
+  for (const element of arr) {
+    if (element == null)
+      continue;
+    const elementType = typeof element;
+    if (elementType === type) {
+      continue;
+    }
+    if (!type) {
+      if (isValidPrimitiveAttributeValueType(elementType)) {
+        type = elementType;
+        continue;
+      }
+      return false;
+    }
+    return false;
+  }
+  return true;
+}
+function isValidPrimitiveAttributeValueType(valType) {
+  switch (valType) {
+    case "number":
+    case "boolean":
+    case "string":
+      return true;
+  }
+  return false;
+}
+var init_attributes = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/attributes.js"() {
+    "use strict";
+    init_esm();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+function loggingErrorHandler() {
+  return (ex) => {
+    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 = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js"() {
+    "use strict";
+    init_esm();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+function setGlobalErrorHandler(handler) {
+  delegateHandler = handler;
+}
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch {
+  }
+}
+var delegateHandler;
+var init_global_error_handler = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js"() {
+    "use strict";
+    init_logging_error_handler();
+    delegateHandler = loggingErrorHandler();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/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() {
+  return otperformance.timeOrigin;
+}
+function hrTime(performanceNow) {
+  const timeOrigin = millisToHrTime(otperformance.timeOrigin);
+  const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
+  return addHrTimes(timeOrigin, now);
+}
+function timeInputToHrTime(time) {
+  if (isTimeInputHrTime(time)) {
+    return time;
+  } else if (typeof time === "number") {
+    if (time < otperformance.timeOrigin) {
+      return hrTime(time);
+    } else {
+      return millisToHrTime(time);
+    }
+  } else if (time instanceof Date) {
+    return millisToHrTime(time.getTime());
+  } else {
+    throw TypeError("Invalid input type");
+  }
+}
+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 hrTimeToTimeStamp(time) {
+  const precision = NANOSECOND_DIGITS;
+  const tmp = `${"0".repeat(precision)}${time[1]}Z`;
+  const nanoString = tmp.substring(tmp.length - precision - 1);
+  const date = new Date(time[0] * 1e3).toISOString();
+  return date.replace("000Z", nanoString);
+}
+function hrTimeToNanoseconds(time) {
+  return time[0] * SECOND_TO_NANOSECONDS + time[1];
+}
+function hrTimeToMilliseconds(time) {
+  return time[0] * 1e3 + time[1] / 1e6;
+}
+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 = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/timer-util.js
+function unrefTimer(timer) {
+  if (typeof timer !== "number") {
+    timer.unref();
+  }
+}
+var init_timer_util = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/timer-util.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+var init_ExportResult = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
+    "use strict";
+    (function(ExportResultCode2) {
+      ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+      ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+    })(ExportResultCode || (ExportResultCode = {}));
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/propagation/composite.js
+var CompositePropagator;
+var init_composite = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/propagation/composite.js"() {
+    "use strict";
+    init_esm();
+    CompositePropagator = class {
+      _propagators;
+      _fields;
+      /**
+       * Construct a composite propagator from a list of propagators.
+       *
+       * @param [config] Configuration object for composite propagator
+       */
+      constructor(config = {}) {
+        this._propagators = config.propagators ?? [];
+        this._fields = Array.from(new Set(this._propagators.map((p) => typeof p.fields === "function" ? p.fields() : []).reduce((x, y) => x.concat(y), [])));
+      }
+      /**
+       * Run each of the configured propagators with the given context and carrier.
+       * Propagators are run in the order they are configured, so if multiple
+       * propagators write the same carrier key, the propagator later in the list
+       * will "win".
+       *
+       * @param context Context to inject
+       * @param carrier Carrier into which context will be injected
+       */
+      inject(context2, carrier, setter) {
+        for (const propagator of this._propagators) {
+          try {
+            propagator.inject(context2, carrier, setter);
+          } catch (err) {
+            diag.warn(`Failed to inject with ${propagator.constructor.name}. Err: ${err.message}`);
+          }
+        }
+      }
+      /**
+       * Run each of the configured propagators with the given context and carrier.
+       * Propagators are run in the order they are configured, so if multiple
+       * propagators write the same context key, the propagator later in the list
+       * will "win".
+       *
+       * @param context Context to add values to
+       * @param carrier Carrier from which to extract context
+       */
+      extract(context2, carrier, getter) {
+        return this._propagators.reduce((ctx, propagator) => {
+          try {
+            return propagator.extract(ctx, carrier, getter);
+          } catch (err) {
+            diag.warn(`Failed to extract with ${propagator.constructor.name}. Err: ${err.message}`);
+          }
+          return ctx;
+        }, context2);
+      }
+      fields() {
+        return this._fields.slice();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/internal/validators.js
+function validateKey(key) {
+  return VALID_KEY_REGEX.test(key);
+}
+function validateValue(value) {
+  return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+}
+var VALID_KEY_CHAR_RANGE, VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
+var init_validators = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/internal/validators.js"() {
+    "use strict";
+    VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+    VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+    VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+    VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+    VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+    INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js
+var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, TraceState;
+var init_TraceState = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js"() {
+    "use strict";
+    init_validators();
+    MAX_TRACE_STATE_ITEMS = 32;
+    MAX_TRACE_STATE_LEN = 512;
+    LIST_MEMBERS_SEPARATOR = ",";
+    LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+    TraceState = class _TraceState {
+      _internalState = /* @__PURE__ */ new Map();
+      constructor(rawTraceState) {
+        if (rawTraceState)
+          this._parse(rawTraceState);
+      }
+      set(key, value) {
+        const traceState = this._clone();
+        if (traceState._internalState.has(key)) {
+          traceState._internalState.delete(key);
+        }
+        traceState._internalState.set(key, value);
+        return traceState;
+      }
+      unset(key) {
+        const traceState = this._clone();
+        traceState._internalState.delete(key);
+        return traceState;
+      }
+      get(key) {
+        return this._internalState.get(key);
+      }
+      serialize() {
+        return this._keys().reduce((agg, key) => {
+          agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+          return agg;
+        }, []).join(LIST_MEMBERS_SEPARATOR);
+      }
+      _parse(rawTraceState) {
+        if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+          return;
+        this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce((agg, part) => {
+          const listMember = part.trim();
+          const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+          if (i !== -1) {
+            const key = listMember.slice(0, i);
+            const value = listMember.slice(i + 1, part.length);
+            if (validateKey(key) && validateValue(value)) {
+              agg.set(key, value);
+            } else {
+            }
+          }
+          return agg;
+        }, /* @__PURE__ */ new Map());
+        if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+          this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+        }
+      }
+      _keys() {
+        return Array.from(this._internalState.keys()).reverse();
+      }
+      _clone() {
+        const traceState = new _TraceState();
+        traceState._internalState = new Map(this._internalState);
+        return traceState;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js
+function parseTraceParent(traceParent) {
+  const match = TRACE_PARENT_REGEX.exec(traceParent);
+  if (!match)
+    return null;
+  if (match[1] === "00" && match[5])
+    return null;
+  return {
+    traceId: match[2],
+    spanId: match[3],
+    traceFlags: parseInt(match[4], 16)
+  };
+}
+var TRACE_PARENT_HEADER, TRACE_STATE_HEADER, VERSION2, VERSION_PART, TRACE_ID_PART, PARENT_ID_PART, FLAGS_PART, TRACE_PARENT_REGEX, W3CTraceContextPropagator;
+var init_W3CTraceContextPropagator = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js"() {
+    "use strict";
+    init_esm();
+    init_suppress_tracing();
+    init_TraceState();
+    TRACE_PARENT_HEADER = "traceparent";
+    TRACE_STATE_HEADER = "tracestate";
+    VERSION2 = "00";
+    VERSION_PART = "(?!ff)[\\da-f]{2}";
+    TRACE_ID_PART = "(?![0]{32})[\\da-f]{32}";
+    PARENT_ID_PART = "(?![0]{16})[\\da-f]{16}";
+    FLAGS_PART = "[\\da-f]{2}";
+    TRACE_PARENT_REGEX = new RegExp(`^\\s?(${VERSION_PART})-(${TRACE_ID_PART})-(${PARENT_ID_PART})-(${FLAGS_PART})(-.*)?\\s?$`);
+    W3CTraceContextPropagator = class {
+      inject(context2, carrier, setter) {
+        const spanContext = trace.getSpanContext(context2);
+        if (!spanContext || isTracingSuppressed(context2) || !isSpanContextValid(spanContext))
+          return;
+        const traceParent = `${VERSION2}-${spanContext.traceId}-${spanContext.spanId}-0${Number(spanContext.traceFlags || TraceFlags.NONE).toString(16)}`;
+        setter.set(carrier, TRACE_PARENT_HEADER, traceParent);
+        if (spanContext.traceState) {
+          setter.set(carrier, TRACE_STATE_HEADER, spanContext.traceState.serialize());
+        }
+      }
+      extract(context2, carrier, getter) {
+        const traceParentHeader = getter.get(carrier, TRACE_PARENT_HEADER);
+        if (!traceParentHeader)
+          return context2;
+        const traceParent = Array.isArray(traceParentHeader) ? traceParentHeader[0] : traceParentHeader;
+        if (typeof traceParent !== "string")
+          return context2;
+        const spanContext = parseTraceParent(traceParent);
+        if (!spanContext)
+          return context2;
+        spanContext.isRemote = true;
+        const traceStateHeader = getter.get(carrier, TRACE_STATE_HEADER);
+        if (traceStateHeader) {
+          const state = Array.isArray(traceStateHeader) ? traceStateHeader.join(",") : traceStateHeader;
+          spanContext.traceState = new TraceState(typeof state === "string" ? state : void 0);
+        }
+        return trace.setSpanContext(context2, spanContext);
+      }
+      fields() {
+        return [TRACE_PARENT_HEADER, TRACE_STATE_HEADER];
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/rpc-metadata.js
+function setRPCMetadata(context2, meta) {
+  return context2.setValue(RPC_METADATA_KEY, meta);
+}
+function deleteRPCMetadata(context2) {
+  return context2.deleteValue(RPC_METADATA_KEY);
+}
+function getRPCMetadata(context2) {
+  return context2.getValue(RPC_METADATA_KEY);
+}
+var RPC_METADATA_KEY, RPCType;
+var init_rpc_metadata = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/rpc-metadata.js"() {
+    "use strict";
+    init_esm();
+    RPC_METADATA_KEY = createContextKey("OpenTelemetry SDK Context Key RPC_METADATA");
+    (function(RPCType2) {
+      RPCType2["HTTP"] = "http";
+    })(RPCType || (RPCType = {}));
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/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 {
+  }
+  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 = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/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 (isArray(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 (isArray(one)) {
+    result = one.slice();
+    if (isArray(two)) {
+      for (let i = 0, j = two.length; i < j; i++) {
+        result.push(takeValue(two[i]));
+      }
+    } else if (isObject(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 (isObject(one)) {
+    if (isObject(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 (isObject(obj1) && isObject(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 isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return !isPrimitive(value) && !isArray(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 = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/merge.js"() {
+    "use strict";
+    init_lodash_merge();
+    MAX_LEVEL = 20;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/timeout.js
+function callWithTimeout(promise, timeout) {
+  let timeoutHandle;
+  const timeoutPromise = new Promise(function timeoutFunction(_resolve, reject) {
+    timeoutHandle = setTimeout(function timeoutHandler() {
+      reject(new TimeoutError("Operation timed out."));
+    }, timeout);
+  });
+  return Promise.race([promise, timeoutPromise]).then((result) => {
+    clearTimeout(timeoutHandle);
+    return result;
+  }, (reason) => {
+    clearTimeout(timeoutHandle);
+    throw reason;
+  });
+}
+var TimeoutError;
+var init_timeout = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/timeout.js"() {
+    "use strict";
+    TimeoutError = class _TimeoutError extends Error {
+      constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, _TimeoutError.prototype);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/url.js
+function urlMatches(url, urlToMatch) {
+  if (typeof urlToMatch === "string") {
+    return url === urlToMatch;
+  } else {
+    return !!url.match(urlToMatch);
+  }
+}
+function isUrlIgnored(url, ignoredUrls) {
+  if (!ignoredUrls) {
+    return false;
+  }
+  for (const ignoreUrl of ignoredUrls) {
+    if (urlMatches(url, ignoreUrl)) {
+      return true;
+    }
+  }
+  return false;
+}
+var init_url = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/url.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred;
+var init_promise = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/promise.js"() {
+    "use strict";
+    Deferred = class {
+      _promise;
+      _resolve;
+      _reject;
+      constructor() {
+        this._promise = new Promise((resolve, reject) => {
+          this._resolve = resolve;
+          this._reject = reject;
+        });
+      }
+      get promise() {
+        return this._promise;
+      }
+      resolve(val) {
+        this._resolve(val);
+      }
+      reject(err) {
+        this._reject(err);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var BindOnceFuture;
+var init_callback = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/callback.js"() {
+    "use strict";
+    init_promise();
+    BindOnceFuture = class {
+      _isCalled = false;
+      _deferred = new Deferred();
+      _callback;
+      _that;
+      constructor(callback, that) {
+        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;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/configuration.js
+function diagLogLevelFromString(value) {
+  if (value == null) {
+    return void 0;
+  }
+  const resolvedLogLevel = logLevelMap[value.toUpperCase()];
+  if (resolvedLogLevel == null) {
+    diag.warn(`Unknown log level "${value}", expected one of ${Object.keys(logLevelMap)}, using default`);
+    return DiagLogLevel.INFO;
+  }
+  return resolvedLogLevel;
+}
+var logLevelMap;
+var init_configuration = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/configuration.js"() {
+    "use strict";
+    init_esm();
+    logLevelMap = {
+      ALL: DiagLogLevel.ALL,
+      VERBOSE: DiagLogLevel.VERBOSE,
+      DEBUG: DiagLogLevel.DEBUG,
+      INFO: DiagLogLevel.INFO,
+      WARN: DiagLogLevel.WARN,
+      ERROR: DiagLogLevel.ERROR,
+      NONE: DiagLogLevel.NONE
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+function _export(exporter, arg) {
+  return new Promise((resolve) => {
+    context.with(suppressTracing(context.active()), () => {
+      exporter.export(arg, resolve);
+    });
+  });
+}
+var init_exporter = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/internal/exporter.js"() {
+    "use strict";
+    init_esm();
+    init_suppress_tracing();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  AnchoredClock: () => AnchoredClock,
+  BindOnceFuture: () => BindOnceFuture,
+  CompositePropagator: () => CompositePropagator,
+  ExportResultCode: () => ExportResultCode,
+  RPCType: () => RPCType,
+  SDK_INFO: () => SDK_INFO,
+  TRACE_PARENT_HEADER: () => TRACE_PARENT_HEADER,
+  TRACE_STATE_HEADER: () => TRACE_STATE_HEADER,
+  TimeoutError: () => TimeoutError,
+  TraceState: () => TraceState,
+  W3CBaggagePropagator: () => W3CBaggagePropagator,
+  W3CTraceContextPropagator: () => W3CTraceContextPropagator,
+  _globalThis: () => _globalThis,
+  addHrTimes: () => addHrTimes,
+  callWithTimeout: () => callWithTimeout,
+  deleteRPCMetadata: () => deleteRPCMetadata,
+  diagLogLevelFromString: () => diagLogLevelFromString,
+  getBooleanFromEnv: () => getBooleanFromEnv,
+  getNumberFromEnv: () => getNumberFromEnv,
+  getRPCMetadata: () => getRPCMetadata,
+  getStringFromEnv: () => getStringFromEnv,
+  getStringListFromEnv: () => getStringListFromEnv,
+  getTimeOrigin: () => getTimeOrigin,
+  globalErrorHandler: () => globalErrorHandler,
+  hrTime: () => hrTime,
+  hrTimeDuration: () => hrTimeDuration,
+  hrTimeToMicroseconds: () => hrTimeToMicroseconds,
+  hrTimeToMilliseconds: () => hrTimeToMilliseconds,
+  hrTimeToNanoseconds: () => hrTimeToNanoseconds,
+  hrTimeToTimeStamp: () => hrTimeToTimeStamp,
+  internal: () => internal,
+  isAttributeValue: () => isAttributeValue,
+  isTimeInput: () => isTimeInput,
+  isTimeInputHrTime: () => isTimeInputHrTime,
+  isTracingSuppressed: () => isTracingSuppressed,
+  isUrlIgnored: () => isUrlIgnored,
+  loggingErrorHandler: () => loggingErrorHandler,
+  merge: () => merge,
+  millisToHrTime: () => millisToHrTime,
+  otperformance: () => otperformance,
+  parseKeyPairsIntoRecord: () => parseKeyPairsIntoRecord,
+  parseTraceParent: () => parseTraceParent,
+  sanitizeAttributes: () => sanitizeAttributes,
+  setGlobalErrorHandler: () => setGlobalErrorHandler,
+  setRPCMetadata: () => setRPCMetadata,
+  suppressTracing: () => suppressTracing,
+  timeInputToHrTime: () => timeInputToHrTime,
+  unrefTimer: () => unrefTimer,
+  unsuppressTracing: () => unsuppressTracing,
+  urlMatches: () => urlMatches
+});
+var internal;
+var init_esm3 = __esm({
+  "../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/index.js"() {
+    "use strict";
+    init_W3CBaggagePropagator();
+    init_anchored_clock();
+    init_attributes();
+    init_global_error_handler();
+    init_logging_error_handler();
+    init_time();
+    init_timer_util();
+    init_ExportResult();
+    init_utils();
+    init_platform();
+    init_composite();
+    init_W3CTraceContextPropagator();
+    init_rpc_metadata();
+    init_suppress_tracing();
+    init_TraceState();
+    init_merge();
+    init_timeout();
+    init_url();
+    init_callback();
+    init_configuration();
+    init_exporter();
+    internal = {
+      _export
+    };
+  }
+});
+
+export {
+  suppressTracing,
+  isTracingSuppressed,
+  parseKeyPairsIntoRecord,
+  sanitizeAttributes,
+  isAttributeValue,
+  globalErrorHandler,
+  getNumberFromEnv,
+  getStringFromEnv,
+  SDK_INFO,
+  otperformance,
+  millisToHrTime,
+  hrTime,
+  hrTimeDuration,
+  hrTimeToNanoseconds,
+  hrTimeToMicroseconds,
+  isTimeInputHrTime,
+  isTimeInput,
+  addHrTimes,
+  ExportResultCode,
+  merge,
+  BindOnceFuture,
+  internal,
+  esm_exports,
+  init_esm3 as init_esm
+};
+//# sourceMappingURL=chunk-SR4I5KET.js.map