@agentv/core 2.6.0 → 2.7.1-next.1

package/dist/esm-5Q4BZALM.js

@@ -0,0 +1,968 @@
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
+import { propagation } from "@opentelemetry/api";
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+import { createContextKey } from "@opentelemetry/api";
+var SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+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;
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var BAGGAGE_KEY_PAIR_SEPARATOR = "=";
+var BAGGAGE_PROPERTIES_SEPARATOR = ";";
+var BAGGAGE_ITEMS_SEPARATOR = ",";
+var BAGGAGE_HEADER = "baggage";
+var BAGGAGE_MAX_NAME_VALUE_PAIRS = 180;
+var BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096;
+var BAGGAGE_MAX_TOTAL_LENGTH = 8192;
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+import { baggageEntryMetadataFromString } from "@opentelemetry/api";
+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;
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
+var 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 = 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
+import { diag } from "@opentelemetry/api";
+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;
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+import { diag as diag2 } from "@opentelemetry/api";
+function loggingErrorHandler() {
+  return (ex) => {
+    diag2.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;
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+var delegateHandler = loggingErrorHandler();
+function setGlobalErrorHandler(handler) {
+  delegateHandler = handler;
+}
+function globalErrorHandler(ex) {
+  try {
+    delegateHandler(ex);
+  } catch {
+  }
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+import { diag as diag3 } from "@opentelemetry/api";
+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)) {
+    diag3.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 {
+    diag3.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 !== "");
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/globalThis.js
+var _globalThis = globalThis;
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION = "2.5.1";
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
+import { ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_LANGUAGE, TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS, ATTR_TELEMETRY_SDK_VERSION } from "@opentelemetry/semantic-conventions";
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/semconv.js
+var 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 = {
+  [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/platform/node/index.js
+var otperformance = performance;
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/common/time.js
+var NANOSECOND_DIGITS = 9;
+var NANOSECOND_DIGITS_IN_MILLIS = 6;
+var MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+var SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+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;
+}
+
+// ../../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();
+  }
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+(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
+import { diag as diag4 } from "@opentelemetry/api";
+var 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) {
+        diag4.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) {
+        diag4.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/trace/W3CTraceContextPropagator.js
+import { isSpanContextValid, trace, TraceFlags } from "@opentelemetry/api";
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/internal/validators.js
+var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+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);
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js
+var MAX_TRACE_STATE_ITEMS = 32;
+var MAX_TRACE_STATE_LEN = 512;
+var LIST_MEMBERS_SEPARATOR = ",";
+var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+var 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
+var TRACE_PARENT_HEADER = "traceparent";
+var TRACE_STATE_HEADER = "tracestate";
+var VERSION2 = "00";
+var VERSION_PART = "(?!ff)[\\da-f]{2}";
+var TRACE_ID_PART = "(?![0]{32})[\\da-f]{32}";
+var PARENT_ID_PART = "(?![0]{16})[\\da-f]{16}";
+var FLAGS_PART = "[\\da-f]{2}";
+var TRACE_PARENT_REGEX = new RegExp(`^\\s?(${VERSION_PART})-(${TRACE_ID_PART})-(${PARENT_ID_PART})-(${FLAGS_PART})(-.*)?\\s?$`);
+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 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
+import { createContextKey as createContextKey2 } from "@opentelemetry/api";
+var RPC_METADATA_KEY = createContextKey2("OpenTelemetry SDK Context Key RPC_METADATA");
+var RPCType;
+(function(RPCType2) {
+  RPCType2["HTTP"] = "http";
+})(RPCType || (RPCType = {}));
+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);
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
+var objectTag = "[object Object]";
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+var objectCtorString = funcToString.call(Object);
+var getPrototypeOf = Object.getPrototypeOf;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+var nativeObjectToString = objectProto.toString;
+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);
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/merge.js
+var MAX_LEVEL = 20;
+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;
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/timeout.js
+var TimeoutError = class _TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+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;
+  });
+}
+
+// ../../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;
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var 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 = 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
+import { diag as diag5, DiagLogLevel } from "@opentelemetry/api";
+var logLevelMap = {
+  ALL: DiagLogLevel.ALL,
+  VERBOSE: DiagLogLevel.VERBOSE,
+  DEBUG: DiagLogLevel.DEBUG,
+  INFO: DiagLogLevel.INFO,
+  WARN: DiagLogLevel.WARN,
+  ERROR: DiagLogLevel.ERROR,
+  NONE: DiagLogLevel.NONE
+};
+function diagLogLevelFromString(value) {
+  if (value == null) {
+    return void 0;
+  }
+  const resolvedLogLevel = logLevelMap[value.toUpperCase()];
+  if (resolvedLogLevel == null) {
+    diag5.warn(`Unknown log level "${value}", expected one of ${Object.keys(logLevelMap)}, using default`);
+    return DiagLogLevel.INFO;
+  }
+  return resolvedLogLevel;
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/internal/exporter.js
+import { context } from "@opentelemetry/api";
+function _export(exporter, arg) {
+  return new Promise((resolve) => {
+    context.with(suppressTracing(context.active()), () => {
+      exporter.export(arg, resolve);
+    });
+  });
+}
+
+// ../../node_modules/.bun/@opentelemetry+core@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/core/build/esm/index.js
+var internal = {
+  _export
+};
+export {
+  AnchoredClock,
+  BindOnceFuture,
+  CompositePropagator,
+  ExportResultCode,
+  RPCType,
+  SDK_INFO,
+  TRACE_PARENT_HEADER,
+  TRACE_STATE_HEADER,
+  TimeoutError,
+  TraceState,
+  W3CBaggagePropagator,
+  W3CTraceContextPropagator,
+  _globalThis,
+  addHrTimes,
+  callWithTimeout,
+  deleteRPCMetadata,
+  diagLogLevelFromString,
+  getBooleanFromEnv,
+  getNumberFromEnv,
+  getRPCMetadata,
+  getStringFromEnv,
+  getStringListFromEnv,
+  getTimeOrigin,
+  globalErrorHandler,
+  hrTime,
+  hrTimeDuration,
+  hrTimeToMicroseconds,
+  hrTimeToMilliseconds,
+  hrTimeToNanoseconds,
+  hrTimeToTimeStamp,
+  internal,
+  isAttributeValue,
+  isTimeInput,
+  isTimeInputHrTime,
+  isTracingSuppressed,
+  isUrlIgnored,
+  loggingErrorHandler,
+  merge,
+  millisToHrTime,
+  otperformance,
+  parseKeyPairsIntoRecord,
+  parseTraceParent,
+  sanitizeAttributes,
+  setGlobalErrorHandler,
+  setRPCMetadata,
+  suppressTracing,
+  timeInputToHrTime,
+  unrefTimer,
+  unsuppressTracing,
+  urlMatches
+};
+//# sourceMappingURL=esm-5Q4BZALM.js.map