agentv 3.1.0 → 3.2.0

package/dist/src-ML4D2MC2.js

@@ -0,0 +1,1733 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  defaultResource,
+  init_esm as init_esm4
+} from "./chunk-XOSNETAV.js";
+import {
+  BindOnceFuture,
+  ExportResultCode,
+  addHrTimes,
+  esm_exports as esm_exports2,
+  getNumberFromEnv,
+  getStringFromEnv,
+  globalErrorHandler,
+  hrTime,
+  hrTimeDuration,
+  hrTimeToMicroseconds,
+  init_esm as init_esm3,
+  internal,
+  isAttributeValue,
+  isTimeInput,
+  isTimeInputHrTime,
+  isTracingSuppressed,
+  merge,
+  millisToHrTime,
+  otperformance,
+  sanitizeAttributes,
+  suppressTracing
+} from "./chunk-SR4I5KET.js";
+import {
+  ATTR_EXCEPTION_MESSAGE,
+  ATTR_EXCEPTION_STACKTRACE,
+  ATTR_EXCEPTION_TYPE,
+  init_esm as init_esm2
+} from "./chunk-VQ2ZO7XJ.js";
+import {
+  INVALID_SPAN_CONTEXT,
+  SamplingDecision,
+  SpanKind,
+  SpanStatusCode,
+  TraceFlags,
+  context,
+  diag,
+  esm_exports,
+  init_esm,
+  isSpanContextValid,
+  isValidTraceId,
+  trace
+} from "./chunk-LRULMAAA.js";
+import {
+  __commonJS,
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
+} from "./chunk-5H446C7X.js";
+
+// ../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/AbstractAsyncHooksContextManager.js
+var require_AbstractAsyncHooksContextManager = __commonJS({
+  "../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/AbstractAsyncHooksContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AbstractAsyncHooksContextManager = void 0;
+    var events_1 = __require("events");
+    var ADD_LISTENER_METHODS = [
+      "addListener",
+      "on",
+      "once",
+      "prependListener",
+      "prependOnceListener"
+    ];
+    var AbstractAsyncHooksContextManager = class {
+      /**
+       * Binds a the certain context or the active one to the target function and then returns the target
+       * @param context A context (span) to be bind to target
+       * @param target a function or event emitter. When target or one of its callbacks is called,
+       *  the provided context will be used as the active context for the duration of the call.
+       */
+      bind(context2, target) {
+        if (target instanceof events_1.EventEmitter) {
+          return this._bindEventEmitter(context2, target);
+        }
+        if (typeof target === "function") {
+          return this._bindFunction(context2, target);
+        }
+        return target;
+      }
+      _bindFunction(context2, target) {
+        const manager = this;
+        const contextWrapper = function(...args) {
+          return manager.with(context2, () => target.apply(this, args));
+        };
+        Object.defineProperty(contextWrapper, "length", {
+          enumerable: false,
+          configurable: true,
+          writable: false,
+          value: target.length
+        });
+        return contextWrapper;
+      }
+      /**
+       * By default, EventEmitter call their callback with their context, which we do
+       * not want, instead we will bind a specific context to all callbacks that
+       * go through it.
+       * @param context the context we want to bind
+       * @param ee EventEmitter an instance of EventEmitter to patch
+       */
+      _bindEventEmitter(context2, ee) {
+        const map = this._getPatchMap(ee);
+        if (map !== void 0)
+          return ee;
+        this._createPatchMap(ee);
+        ADD_LISTENER_METHODS.forEach((methodName) => {
+          if (ee[methodName] === void 0)
+            return;
+          ee[methodName] = this._patchAddListener(ee, ee[methodName], context2);
+        });
+        if (typeof ee.removeListener === "function") {
+          ee.removeListener = this._patchRemoveListener(ee, ee.removeListener);
+        }
+        if (typeof ee.off === "function") {
+          ee.off = this._patchRemoveListener(ee, ee.off);
+        }
+        if (typeof ee.removeAllListeners === "function") {
+          ee.removeAllListeners = this._patchRemoveAllListeners(ee, ee.removeAllListeners);
+        }
+        return ee;
+      }
+      /**
+       * Patch methods that remove a given listener so that we match the "patched"
+       * version of that listener (the one that propagate context).
+       * @param ee EventEmitter instance
+       * @param original reference to the patched method
+       */
+      _patchRemoveListener(ee, original) {
+        const contextManager = this;
+        return function(event, listener) {
+          const events = contextManager._getPatchMap(ee)?.[event];
+          if (events === void 0) {
+            return original.call(this, event, listener);
+          }
+          const patchedListener = events.get(listener);
+          return original.call(this, event, patchedListener || listener);
+        };
+      }
+      /**
+       * Patch methods that remove all listeners so we remove our
+       * internal references for a given event.
+       * @param ee EventEmitter instance
+       * @param original reference to the patched method
+       */
+      _patchRemoveAllListeners(ee, original) {
+        const contextManager = this;
+        return function(event) {
+          const map = contextManager._getPatchMap(ee);
+          if (map !== void 0) {
+            if (arguments.length === 0) {
+              contextManager._createPatchMap(ee);
+            } else if (map[event] !== void 0) {
+              delete map[event];
+            }
+          }
+          return original.apply(this, arguments);
+        };
+      }
+      /**
+       * Patch methods on an event emitter instance that can add listeners so we
+       * can force them to propagate a given context.
+       * @param ee EventEmitter instance
+       * @param original reference to the patched method
+       * @param [context] context to propagate when calling listeners
+       */
+      _patchAddListener(ee, original, context2) {
+        const contextManager = this;
+        return function(event, listener) {
+          if (contextManager._wrapped) {
+            return original.call(this, event, listener);
+          }
+          let map = contextManager._getPatchMap(ee);
+          if (map === void 0) {
+            map = contextManager._createPatchMap(ee);
+          }
+          let listeners = map[event];
+          if (listeners === void 0) {
+            listeners = /* @__PURE__ */ new WeakMap();
+            map[event] = listeners;
+          }
+          const patchedListener = contextManager.bind(context2, listener);
+          listeners.set(listener, patchedListener);
+          contextManager._wrapped = true;
+          try {
+            return original.call(this, event, patchedListener);
+          } finally {
+            contextManager._wrapped = false;
+          }
+        };
+      }
+      _createPatchMap(ee) {
+        const map = /* @__PURE__ */ Object.create(null);
+        ee[this._kOtListeners] = map;
+        return map;
+      }
+      _getPatchMap(ee) {
+        return ee[this._kOtListeners];
+      }
+      _kOtListeners = Symbol("OtListeners");
+      _wrapped = false;
+    };
+    exports.AbstractAsyncHooksContextManager = AbstractAsyncHooksContextManager;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js
+var require_AsyncHooksContextManager = __commonJS({
+  "../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsyncHooksContextManager = void 0;
+    var api_1 = (init_esm(), __toCommonJS(esm_exports));
+    var asyncHooks = __require("async_hooks");
+    var AbstractAsyncHooksContextManager_1 = require_AbstractAsyncHooksContextManager();
+    var AsyncHooksContextManager = class extends AbstractAsyncHooksContextManager_1.AbstractAsyncHooksContextManager {
+      _asyncHook;
+      _contexts = /* @__PURE__ */ new Map();
+      _stack = [];
+      constructor() {
+        super();
+        this._asyncHook = asyncHooks.createHook({
+          init: this._init.bind(this),
+          before: this._before.bind(this),
+          after: this._after.bind(this),
+          destroy: this._destroy.bind(this),
+          promiseResolve: this._destroy.bind(this)
+        });
+      }
+      active() {
+        return this._stack[this._stack.length - 1] ?? api_1.ROOT_CONTEXT;
+      }
+      with(context2, fn, thisArg, ...args) {
+        this._enterContext(context2);
+        try {
+          return fn.call(thisArg, ...args);
+        } finally {
+          this._exitContext();
+        }
+      }
+      enable() {
+        this._asyncHook.enable();
+        return this;
+      }
+      disable() {
+        this._asyncHook.disable();
+        this._contexts.clear();
+        this._stack = [];
+        return this;
+      }
+      /**
+       * Init hook will be called when userland create a async context, setting the
+       * context as the current one if it exist.
+       * @param uid id of the async context
+       * @param type the resource type
+       */
+      _init(uid, type) {
+        if (type === "TIMERWRAP")
+          return;
+        const context2 = this._stack[this._stack.length - 1];
+        if (context2 !== void 0) {
+          this._contexts.set(uid, context2);
+        }
+      }
+      /**
+       * Destroy hook will be called when a given context is no longer used so we can
+       * remove its attached context.
+       * @param uid uid of the async context
+       */
+      _destroy(uid) {
+        this._contexts.delete(uid);
+      }
+      /**
+       * Before hook is called just before executing a async context.
+       * @param uid uid of the async context
+       */
+      _before(uid) {
+        const context2 = this._contexts.get(uid);
+        if (context2 !== void 0) {
+          this._enterContext(context2);
+        }
+      }
+      /**
+       * After hook is called just after completing the execution of a async context.
+       */
+      _after() {
+        this._exitContext();
+      }
+      /**
+       * Set the given context as active
+       */
+      _enterContext(context2) {
+        this._stack.push(context2);
+      }
+      /**
+       * Remove the context at the root of the stack
+       */
+      _exitContext() {
+        this._stack.pop();
+      }
+    };
+    exports.AsyncHooksContextManager = AsyncHooksContextManager;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncLocalStorageContextManager.js
+var require_AsyncLocalStorageContextManager = __commonJS({
+  "../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/AsyncLocalStorageContextManager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsyncLocalStorageContextManager = void 0;
+    var api_1 = (init_esm(), __toCommonJS(esm_exports));
+    var async_hooks_1 = __require("async_hooks");
+    var AbstractAsyncHooksContextManager_1 = require_AbstractAsyncHooksContextManager();
+    var AsyncLocalStorageContextManager = class extends AbstractAsyncHooksContextManager_1.AbstractAsyncHooksContextManager {
+      _asyncLocalStorage;
+      constructor() {
+        super();
+        this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+      }
+      active() {
+        return this._asyncLocalStorage.getStore() ?? api_1.ROOT_CONTEXT;
+      }
+      with(context2, fn, thisArg, ...args) {
+        const cb = thisArg == null ? fn : fn.bind(thisArg);
+        return this._asyncLocalStorage.run(context2, cb, ...args);
+      }
+      enable() {
+        return this;
+      }
+      disable() {
+        this._asyncLocalStorage.disable();
+        return this;
+      }
+    };
+    exports.AsyncLocalStorageContextManager = AsyncLocalStorageContextManager;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.bun/@opentelemetry+context-async-hooks@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/context-async-hooks/build/src/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsyncLocalStorageContextManager = exports.AsyncHooksContextManager = void 0;
+    var AsyncHooksContextManager_1 = require_AsyncHooksContextManager();
+    Object.defineProperty(exports, "AsyncHooksContextManager", { enumerable: true, get: function() {
+      return AsyncHooksContextManager_1.AsyncHooksContextManager;
+    } });
+    var AsyncLocalStorageContextManager_1 = require_AsyncLocalStorageContextManager();
+    Object.defineProperty(exports, "AsyncLocalStorageContextManager", { enumerable: true, get: function() {
+      return AsyncLocalStorageContextManager_1.AsyncLocalStorageContextManager;
+    } });
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js
+var ExceptionEventName;
+var init_enums = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js"() {
+    "use strict";
+    ExceptionEventName = "exception";
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js
+var SpanImpl;
+var init_Span = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js"() {
+    "use strict";
+    init_esm();
+    init_esm3();
+    init_esm2();
+    init_enums();
+    SpanImpl = class {
+      // Below properties are included to implement ReadableSpan for export
+      // purposes but are not intended to be written-to directly.
+      _spanContext;
+      kind;
+      parentSpanContext;
+      attributes = {};
+      links = [];
+      events = [];
+      startTime;
+      resource;
+      instrumentationScope;
+      _droppedAttributesCount = 0;
+      _droppedEventsCount = 0;
+      _droppedLinksCount = 0;
+      _attributesCount = 0;
+      name;
+      status = {
+        code: SpanStatusCode.UNSET
+      };
+      endTime = [0, 0];
+      _ended = false;
+      _duration = [-1, -1];
+      _spanProcessor;
+      _spanLimits;
+      _attributeValueLengthLimit;
+      _performanceStartTime;
+      _performanceOffset;
+      _startTimeProvided;
+      /**
+       * Constructs a new SpanImpl instance.
+       */
+      constructor(opts) {
+        const now = Date.now();
+        this._spanContext = opts.spanContext;
+        this._performanceStartTime = otperformance.now();
+        this._performanceOffset = now - (this._performanceStartTime + otperformance.timeOrigin);
+        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(opts.startTime ?? now);
+        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) {
+          diag.warn(`Invalid attribute key: ${key}`);
+          return this;
+        }
+        if (!isAttributeValue(value)) {
+          diag.warn(`Invalid attribute value set for key: ${key}`);
+          return this;
+        }
+        const { attributeCountLimit } = this._spanLimits;
+        const isNewKey = !Object.prototype.hasOwnProperty.call(this.attributes, key);
+        if (attributeCountLimit !== void 0 && this._attributesCount >= attributeCountLimit && isNewKey) {
+          this._droppedAttributesCount++;
+          return this;
+        }
+        this.attributes[key] = this._truncateToSize(value);
+        if (isNewKey) {
+          this._attributesCount++;
+        }
+        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) {
+          diag.warn("No events allowed.");
+          this._droppedEventsCount++;
+          return this;
+        }
+        if (eventCountLimit !== void 0 && this.events.length >= eventCountLimit) {
+          if (this._droppedEventsCount === 0) {
+            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") {
+          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()) {
+          diag.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
+          return;
+        }
+        this.endTime = this._getTime(endTime);
+        this._duration = hrTimeDuration(this.startTime, this.endTime);
+        if (this._duration[0] < 0) {
+          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) {
+          diag.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
+        }
+        if (this._spanProcessor.onEnding) {
+          this._spanProcessor.onEnding(this);
+        }
+        this._ended = true;
+        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 {
+          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 error = new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
+          diag.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error);
+        }
+        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) {
+          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;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js
+var SamplingDecision2;
+var init_Sampler = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js
+var AlwaysOffSampler;
+var init_AlwaysOffSampler = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js
+var AlwaysOnSampler;
+var init_AlwaysOnSampler = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js
+var ParentBasedSampler;
+var init_ParentBasedSampler = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js"() {
+    "use strict";
+    init_esm();
+    init_esm3();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    ParentBasedSampler = class {
+      _root;
+      _remoteParentSampled;
+      _remoteParentNotSampled;
+      _localParentSampled;
+      _localParentNotSampled;
+      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 = config.remoteParentSampled ?? new AlwaysOnSampler();
+        this._remoteParentNotSampled = config.remoteParentNotSampled ?? new AlwaysOffSampler();
+        this._localParentSampled = config.localParentSampled ?? new AlwaysOnSampler();
+        this._localParentNotSampled = config.localParentNotSampled ?? new AlwaysOffSampler();
+      }
+      shouldSample(context2, traceId, spanName, spanKind, attributes, links) {
+        const parentContext = trace.getSpanContext(context2);
+        if (!parentContext || !isSpanContextValid(parentContext)) {
+          return this._root.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+        }
+        if (parentContext.isRemote) {
+          if (parentContext.traceFlags & 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 & 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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js
+var TraceIdRatioBasedSampler;
+var init_TraceIdRatioBasedSampler = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js"() {
+    "use strict";
+    init_esm();
+    init_Sampler();
+    TraceIdRatioBasedSampler = class {
+      _ratio;
+      _upperBound;
+      constructor(ratio = 0) {
+        this._ratio = this._normalize(ratio);
+        this._upperBound = Math.floor(this._ratio * 4294967295);
+      }
+      shouldSample(context2, traceId) {
+        return {
+          decision: isValidTraceId(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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js
+function loadDefaultConfig() {
+  return {
+    sampler: buildSamplerFromEnv(),
+    forceFlushTimeoutMillis: 3e4,
+    generalLimits: {
+      attributeValueLengthLimit: getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
+      attributeCountLimit: getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? 128
+    },
+    spanLimits: {
+      attributeValueLengthLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
+      attributeCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? 128,
+      linkCountLimit: getNumberFromEnv("OTEL_SPAN_LINK_COUNT_LIMIT") ?? 128,
+      eventCountLimit: getNumberFromEnv("OTEL_SPAN_EVENT_COUNT_LIMIT") ?? 128,
+      attributePerEventCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT") ?? 128,
+      attributePerLinkCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT") ?? 128
+    }
+  };
+}
+function buildSamplerFromEnv() {
+  const sampler = getStringFromEnv("OTEL_TRACES_SAMPLER") ?? TracesSamplerValues.ParentBasedAlwaysOn;
+  switch (sampler) {
+    case TracesSamplerValues.AlwaysOn:
+      return new AlwaysOnSampler();
+    case TracesSamplerValues.AlwaysOff:
+      return new AlwaysOffSampler();
+    case TracesSamplerValues.ParentBasedAlwaysOn:
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+    case TracesSamplerValues.ParentBasedAlwaysOff:
+      return new ParentBasedSampler({
+        root: new AlwaysOffSampler()
+      });
+    case TracesSamplerValues.TraceIdRatio:
+      return new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv());
+    case TracesSamplerValues.ParentBasedTraceIdRatio:
+      return new ParentBasedSampler({
+        root: new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv())
+      });
+    default:
+      diag.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${TracesSamplerValues.ParentBasedAlwaysOn}".`);
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+  }
+}
+function getSamplerProbabilityFromEnv() {
+  const probability = getNumberFromEnv("OTEL_TRACES_SAMPLER_ARG");
+  if (probability == null) {
+    diag.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`);
+    return DEFAULT_RATIO;
+  }
+  if (probability < 0 || probability > 1) {
+    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 TracesSamplerValues, DEFAULT_RATIO;
+var init_config = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js"() {
+    "use strict";
+    init_esm();
+    init_esm3();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    init_ParentBasedSampler();
+    init_TraceIdRatioBasedSampler();
+    (function(TracesSamplerValues2) {
+      TracesSamplerValues2["AlwaysOff"] = "always_off";
+      TracesSamplerValues2["AlwaysOn"] = "always_on";
+      TracesSamplerValues2["ParentBasedAlwaysOff"] = "parentbased_always_off";
+      TracesSamplerValues2["ParentBasedAlwaysOn"] = "parentbased_always_on";
+      TracesSamplerValues2["ParentBasedTraceIdRatio"] = "parentbased_traceidratio";
+      TracesSamplerValues2["TraceIdRatio"] = "traceidratio";
+    })(TracesSamplerValues || (TracesSamplerValues = {}));
+    DEFAULT_RATIO = 1;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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 = userConfig.spanLimits?.attributeCountLimit ?? userConfig.generalLimits?.attributeCountLimit ?? getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? DEFAULT_ATTRIBUTE_COUNT_LIMIT;
+  spanLimits.attributeValueLengthLimit = userConfig.spanLimits?.attributeValueLengthLimit ?? userConfig.generalLimits?.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 = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
+var BatchSpanProcessorBase;
+var init_BatchSpanProcessorBase = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js"() {
+    "use strict";
+    init_esm();
+    init_esm3();
+    BatchSpanProcessorBase = class {
+      _maxExportBatchSize;
+      _maxQueueSize;
+      _scheduledDelayMillis;
+      _exportTimeoutMillis;
+      _exporter;
+      _isExporting = false;
+      _finishedSpans = [];
+      _timer;
+      _shutdownOnce;
+      _droppedSpansCount = 0;
+      constructor(exporter, config) {
+        this._exporter = exporter;
+        this._maxExportBatchSize = typeof config?.maxExportBatchSize === "number" ? config.maxExportBatchSize : getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE") ?? 512;
+        this._maxQueueSize = typeof config?.maxQueueSize === "number" ? config.maxQueueSize : getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE") ?? 2048;
+        this._scheduledDelayMillis = typeof config?.scheduledDelayMillis === "number" ? config.scheduledDelayMillis : getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY") ?? 5e3;
+        this._exportTimeoutMillis = typeof config?.exportTimeoutMillis === "number" ? config.exportTimeoutMillis : getNumberFromEnv("OTEL_BSP_EXPORT_TIMEOUT") ?? 3e4;
+        this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+        if (this._maxExportBatchSize > this._maxQueueSize) {
+          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 & 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) {
+            diag.debug("maxQueueSize reached, dropping spans");
+          }
+          this._droppedSpansCount++;
+          return;
+        }
+        if (this._droppedSpansCount > 0) {
+          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, reject) => {
+          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(reject);
+        });
+      }
+      _flushOneBatch() {
+        this._clearTimer();
+        if (this._finishedSpans.length === 0) {
+          return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            reject(new Error("Timeout"));
+          }, this._exportTimeoutMillis);
+          context.with(suppressTracing(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 {
+                reject(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);
+                reject(err);
+              });
+            }
+          });
+        });
+      }
+      _maybeStartTimer() {
+        if (this._isExporting)
+          return;
+        const flush = () => {
+          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 flush();
+        }
+        if (this._timer !== void 0)
+          return;
+        this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
+        if (typeof this._timer !== "number") {
+          this._timer.unref();
+        }
+      }
+      _clearTimer() {
+        if (this._timer !== void 0) {
+          clearTimeout(this._timer);
+          this._timer = void 0;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js
+var BatchSpanProcessor;
+var init_BatchSpanProcessor = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js"() {
+    "use strict";
+    init_BatchSpanProcessorBase();
+    BatchSpanProcessor = class extends BatchSpanProcessorBase {
+      onShutdown() {
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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 = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js"() {
+    "use strict";
+    SPAN_ID_BYTES = 8;
+    TRACE_ID_BYTES = 16;
+    RandomIdGenerator = class {
+      /**
+       * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
+       * characters corresponding to 128 bits.
+       */
+      generateTraceId = getIdGenerator(TRACE_ID_BYTES);
+      /**
+       * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
+       * characters corresponding to 64 bits.
+       */
+      generateSpanId = getIdGenerator(SPAN_ID_BYTES);
+    };
+    SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES);
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/index.js
+var init_node = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_BatchSpanProcessor();
+    init_RandomIdGenerator();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/index.js
+var init_platform = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/index.js"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js
+var Tracer;
+var init_Tracer = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js"() {
+    "use strict";
+    init_esm();
+    init_esm3();
+    init_Span();
+    init_utility();
+    init_platform();
+    Tracer = class {
+      _sampler;
+      _generalLimits;
+      _spanLimits;
+      _idGenerator;
+      instrumentationScope;
+      _resource;
+      _spanProcessor;
+      /**
+       * 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 = context.active()) {
+        if (options.root) {
+          context2 = trace.deleteSpan(context2);
+        }
+        const parentSpan = trace.getSpan(context2);
+        if (isTracingSuppressed(context2)) {
+          diag.debug("Instrumentation suppressed, returning Noop Span");
+          const nonRecordingSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
+          return nonRecordingSpan;
+        }
+        const parentSpanContext = parentSpan?.spanContext();
+        const spanId = this._idGenerator.generateSpanId();
+        let validParentSpanContext;
+        let traceId;
+        let traceState;
+        if (!parentSpanContext || !trace.isSpanContextValid(parentSpanContext)) {
+          traceId = this._idGenerator.generateTraceId();
+        } else {
+          traceId = parentSpanContext.traceId;
+          traceState = parentSpanContext.traceState;
+          validParentSpanContext = parentSpanContext;
+        }
+        const spanKind = options.kind ?? SpanKind.INTERNAL;
+        const links = (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 = samplingResult.traceState ?? traceState;
+        const traceFlags = samplingResult.decision === SamplingDecision.RECORD_AND_SAMPLED ? TraceFlags.SAMPLED : TraceFlags.NONE;
+        const spanContext = { traceId, spanId, traceFlags, traceState };
+        if (samplingResult.decision === SamplingDecision.NOT_RECORD) {
+          diag.debug("Recording is off, propagating context in a non-recording span");
+          const nonRecordingSpan = trace.wrapSpanContext(spanContext);
+          return nonRecordingSpan;
+        }
+        const initAttributes = sanitizeAttributes(Object.assign(attributes, samplingResult.attributes));
+        const span = new SpanImpl({
+          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 = ctx ?? context.active();
+        const span = this.startSpan(name, opts, parentContext);
+        const contextWithSpanSet = trace.setSpan(parentContext, span);
+        return 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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js
+var MultiSpanProcessor;
+var init_MultiSpanProcessor = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js"() {
+    "use strict";
+    init_esm3();
+    MultiSpanProcessor = class {
+      _spanProcessors;
+      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((error) => {
+            globalErrorHandler(error || new Error("MultiSpanProcessor: forceFlush failed"));
+            resolve();
+          });
+        });
+      }
+      onStart(span, context2) {
+        for (const spanProcessor of this._spanProcessors) {
+          spanProcessor.onStart(span, context2);
+        }
+      }
+      onEnding(span) {
+        for (const spanProcessor of this._spanProcessors) {
+          if (spanProcessor.onEnding) {
+            spanProcessor.onEnding(span);
+          }
+        }
+      }
+      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, reject) => {
+          Promise.all(promises).then(() => {
+            resolve();
+          }, reject);
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js
+var ForceFlushState, BasicTracerProvider;
+var init_BasicTracerProvider = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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 = class {
+      _config;
+      _tracers = /* @__PURE__ */ new Map();
+      _resource;
+      _activeSpanProcessor;
+      constructor(config = {}) {
+        const mergedConfig = merge({}, loadDefaultConfig(), reconfigureLimits(config));
+        this._resource = mergedConfig.resource ?? defaultResource();
+        this._config = Object.assign({}, mergedConfig, {
+          resource: this._resource
+        });
+        const spanProcessors = [];
+        if (config.spanProcessors?.length) {
+          spanProcessors.push(...config.spanProcessors);
+        }
+        this._activeSpanProcessor = new MultiSpanProcessor(spanProcessors);
+      }
+      getTracer(name, version, options) {
+        const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
+        if (!this._tracers.has(key)) {
+          this._tracers.set(key, new Tracer({ name, version, schemaUrl: options?.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((error) => {
+              clearTimeout(timeoutInterval);
+              state = ForceFlushState.error;
+              resolve(error);
+            });
+          });
+        });
+        return new Promise((resolve, reject) => {
+          Promise.all(promises).then((results) => {
+            const errors = results.filter((result) => result !== ForceFlushState.resolved);
+            if (errors.length > 0) {
+              reject(errors);
+            } else {
+              resolve();
+            }
+          }).catch((error) => reject([error]));
+        });
+      }
+      shutdown() {
+        return this._activeSpanProcessor.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/ConsoleSpanExporter.js
+var ConsoleSpanExporter;
+var init_ConsoleSpanExporter = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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: span.spanContext().traceState?.serialize(),
+          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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js
+var InMemorySpanExporter;
+var init_InMemorySpanExporter = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/InMemorySpanExporter.js"() {
+    "use strict";
+    init_esm3();
+    InMemorySpanExporter = class {
+      _finishedSpans = [];
+      /**
+       * Indicates if the exporter has been "shutdown."
+       * When false, exported spans will not be stored in-memory.
+       */
+      _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;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js
+var SimpleSpanProcessor;
+var init_SimpleSpanProcessor = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/SimpleSpanProcessor.js"() {
+    "use strict";
+    init_esm();
+    init_esm3();
+    SimpleSpanProcessor = class {
+      _exporter;
+      _shutdownOnce;
+      _pendingExports;
+      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 & TraceFlags.SAMPLED) === 0) {
+          return;
+        }
+        const pendingExport = this._doExport(span).catch((err) => globalErrorHandler(err));
+        this._pendingExports.add(pendingExport);
+        void pendingExport.finally(() => this._pendingExports.delete(pendingExport));
+      }
+      async _doExport(span) {
+        if (span.resource.asyncAttributesPending) {
+          await span.resource.waitForAsyncAttributes?.();
+        }
+        const result = await internal._export(this._exporter, [span]);
+        if (result.code !== ExportResultCode.SUCCESS) {
+          throw result.error ?? new Error(`SimpleSpanProcessor: span export failed (status ${result})`);
+        }
+      }
+      shutdown() {
+        return this._shutdownOnce.call();
+      }
+      _shutdown() {
+        return this._exporter.shutdown();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/export/NoopSpanProcessor.js
+var NoopSpanProcessor;
+var init_NoopSpanProcessor = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/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/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js
+var esm_exports3 = {};
+__export(esm_exports3, {
+  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 = __esm({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-base@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-base/build/esm/index.js"() {
+    "use strict";
+    init_BasicTracerProvider();
+    init_platform();
+    init_ConsoleSpanExporter();
+    init_InMemorySpanExporter();
+    init_SimpleSpanProcessor();
+    init_NoopSpanProcessor();
+    init_AlwaysOffSampler();
+    init_AlwaysOnSampler();
+    init_ParentBasedSampler();
+    init_TraceIdRatioBasedSampler();
+    init_Sampler();
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-node@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-node/build/src/NodeTracerProvider.js
+var require_NodeTracerProvider = __commonJS({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-node@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-node/build/src/NodeTracerProvider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeTracerProvider = void 0;
+    var context_async_hooks_1 = require_src();
+    var sdk_trace_base_1 = (init_esm5(), __toCommonJS(esm_exports3));
+    var api_1 = (init_esm(), __toCommonJS(esm_exports));
+    var core_1 = (init_esm3(), __toCommonJS(esm_exports2));
+    function setupContextManager(contextManager) {
+      if (contextManager === null) {
+        return;
+      }
+      if (contextManager === void 0) {
+        const defaultContextManager = new context_async_hooks_1.AsyncLocalStorageContextManager();
+        defaultContextManager.enable();
+        api_1.context.setGlobalContextManager(defaultContextManager);
+        return;
+      }
+      contextManager.enable();
+      api_1.context.setGlobalContextManager(contextManager);
+    }
+    function setupPropagator(propagator) {
+      if (propagator === null) {
+        return;
+      }
+      if (propagator === void 0) {
+        api_1.propagation.setGlobalPropagator(new core_1.CompositePropagator({
+          propagators: [
+            new core_1.W3CTraceContextPropagator(),
+            new core_1.W3CBaggagePropagator()
+          ]
+        }));
+        return;
+      }
+      api_1.propagation.setGlobalPropagator(propagator);
+    }
+    var NodeTracerProvider = class extends sdk_trace_base_1.BasicTracerProvider {
+      constructor(config = {}) {
+        super(config);
+      }
+      /**
+       * Register this TracerProvider for use with the OpenTelemetry API.
+       * Undefined values may be replaced with defaults, and
+       * null values will be skipped.
+       *
+       * @param config Configuration object for SDK registration
+       */
+      register(config = {}) {
+        api_1.trace.setGlobalTracerProvider(this);
+        setupContextManager(config.contextManager);
+        setupPropagator(config.propagator);
+      }
+    };
+    exports.NodeTracerProvider = NodeTracerProvider;
+  }
+});
+
+// ../../node_modules/.bun/@opentelemetry+sdk-trace-node@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-node/build/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/.bun/@opentelemetry+sdk-trace-node@2.5.1+460773ef8ff1e07c/node_modules/@opentelemetry/sdk-trace-node/build/src/index.js"(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TraceIdRatioBasedSampler = exports.SimpleSpanProcessor = exports.SamplingDecision = exports.RandomIdGenerator = exports.ParentBasedSampler = exports.NoopSpanProcessor = exports.InMemorySpanExporter = exports.ConsoleSpanExporter = exports.BatchSpanProcessor = exports.BasicTracerProvider = exports.AlwaysOnSampler = exports.AlwaysOffSampler = exports.NodeTracerProvider = void 0;
+    var NodeTracerProvider_1 = require_NodeTracerProvider();
+    Object.defineProperty(exports, "NodeTracerProvider", { enumerable: true, get: function() {
+      return NodeTracerProvider_1.NodeTracerProvider;
+    } });
+    var sdk_trace_base_1 = (init_esm5(), __toCommonJS(esm_exports3));
+    Object.defineProperty(exports, "AlwaysOffSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.AlwaysOffSampler;
+    } });
+    Object.defineProperty(exports, "AlwaysOnSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.AlwaysOnSampler;
+    } });
+    Object.defineProperty(exports, "BasicTracerProvider", { enumerable: true, get: function() {
+      return sdk_trace_base_1.BasicTracerProvider;
+    } });
+    Object.defineProperty(exports, "BatchSpanProcessor", { enumerable: true, get: function() {
+      return sdk_trace_base_1.BatchSpanProcessor;
+    } });
+    Object.defineProperty(exports, "ConsoleSpanExporter", { enumerable: true, get: function() {
+      return sdk_trace_base_1.ConsoleSpanExporter;
+    } });
+    Object.defineProperty(exports, "InMemorySpanExporter", { enumerable: true, get: function() {
+      return sdk_trace_base_1.InMemorySpanExporter;
+    } });
+    Object.defineProperty(exports, "NoopSpanProcessor", { enumerable: true, get: function() {
+      return sdk_trace_base_1.NoopSpanProcessor;
+    } });
+    Object.defineProperty(exports, "ParentBasedSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.ParentBasedSampler;
+    } });
+    Object.defineProperty(exports, "RandomIdGenerator", { enumerable: true, get: function() {
+      return sdk_trace_base_1.RandomIdGenerator;
+    } });
+    Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() {
+      return sdk_trace_base_1.SamplingDecision;
+    } });
+    Object.defineProperty(exports, "SimpleSpanProcessor", { enumerable: true, get: function() {
+      return sdk_trace_base_1.SimpleSpanProcessor;
+    } });
+    Object.defineProperty(exports, "TraceIdRatioBasedSampler", { enumerable: true, get: function() {
+      return sdk_trace_base_1.TraceIdRatioBasedSampler;
+    } });
+  }
+});
+export default require_src2();
+//# sourceMappingURL=src-ML4D2MC2.js.map