claude-code-best 1.4.4 → 1.5.0

package/dist/chunk-3fapt8z5.js

@@ -0,0 +1,3686 @@
+// @bun
+import {
+  endInteractionSpan,
+  init_betaSessionTracing,
+  init_perfettoTracing,
+  init_sessionTracing,
+  initializePerfettoTracing,
+  isBetaTracingEnabled,
+  isEnhancedTelemetryEnabled
+} from "./chunk-7ye0arvq.js";
+import {
+  BasicTracerProvider,
+  BatchSpanProcessor,
+  ConsoleSpanExporter,
+  init_esm as init_esm4
+} from "./chunk-5nccnh01.js";
+import {
+  BatchLogRecordProcessor,
+  ConsoleLogRecordExporter,
+  ExportResultCode,
+  LoggerProvider,
+  checkHasTrustDialogAccepted,
+  defaultResource,
+  envDetector,
+  getAuthHeaders,
+  getClaudeCodeUserAgent,
+  getGlobalConfig,
+  getOtelHeadersFromHelper,
+  getSettings_DEPRECATED,
+  getSubscriptionType,
+  globalErrorHandler,
+  hasProfileScope,
+  hostDetector,
+  hrTimeToMicroseconds,
+  init_auth,
+  init_config1 as init_config,
+  init_esm,
+  init_esm1 as init_esm2,
+  init_esm2 as init_esm3,
+  init_http,
+  init_settings1 as init_settings,
+  init_userAgent,
+  internal,
+  is1PApiCustomer,
+  isClaudeAISubscriber,
+  millisToHrTime,
+  osDetector,
+  require_src as require_src3,
+  resourceFromAttributes,
+  saveGlobalConfig,
+  withOAuth401Retry
+} from "./chunk-d6kw0esk.js";
+import"./chunk-ykcqa4mj.js";
+import"./chunk-r4j2h4yp.js";
+import {
+  HttpsProxyAgent,
+  getCACertificates,
+  getMTLSConfig,
+  getProxyUrl,
+  init_caCerts,
+  init_dist,
+  init_mtls,
+  init_proxy,
+  shouldBypassProxy
+} from "./chunk-7zrkp054.js";
+import"./chunk-zwarn9h7.js";
+import"./chunk-fx52a9s2.js";
+import"./chunk-7hmy36fh.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import"./chunk-8g5pe1gr.js";
+import {
+  getPlatform,
+  getWslVersion,
+  init_platform
+} from "./chunk-pjz4m7pd.js";
+import"./chunk-zvdc0eh1.js";
+import {
+  require_src as require_src2
+} from "./chunk-7a31vc3r.js";
+import"./chunk-6y2wszkc.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-9qh5f9r3.js";
+import"./chunk-xhesahm0.js";
+import"./chunk-rh5a2rg9.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-v1kzp02e.js";
+import {
+  require_src
+} from "./chunk-p2816w9z.js";
+import {
+  init_startupProfiler,
+  profileCheckpoint
+} from "./chunk-ea7t0b92.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-m9w972ny.js";
+import"./chunk-b5wxetbv.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-rvb54w68.js";
+import {
+  init_memoize,
+  memoizeWithTTLAsync
+} from "./chunk-fz395yre.js";
+import"./chunk-jdq8jgyg.js";
+import"./chunk-99zt59gg.js";
+import"./chunk-tv74hgw9.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-vp2p7azg.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-vsbyhpfy.js";
+import"./chunk-p7pj6wf8.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  errorMessage,
+  getHasFormattedOutput,
+  init_cleanupRegistry,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  registerCleanup,
+  toError
+} from "./chunk-5khwvj1z.js";
+import"./chunk-fbv4apne.js";
+import {
+  getIsNonInteractiveSession,
+  getLoggerProvider,
+  getMeterProvider,
+  getTracerProvider,
+  init_state,
+  setEventLogger,
+  setLoggerProvider,
+  setMeterProvider,
+  setTracerProvider
+} from "./chunk-gzp6rza1.js";
+import"./chunk-50dgek10.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-z0csm2zq.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-hxhwzgnn.js";
+import"./chunk-qx8z601m.js";
+import"./chunk-cgm6758j.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-9m27g5s1.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm,
+  __require,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/export/AggregationTemporality.js
+var AggregationTemporality;
+var init_AggregationTemporality = __esm(() => {
+  (function(AggregationTemporality2) {
+    AggregationTemporality2[AggregationTemporality2["DELTA"] = 0] = "DELTA";
+    AggregationTemporality2[AggregationTemporality2["CUMULATIVE"] = 1] = "CUMULATIVE";
+  })(AggregationTemporality || (AggregationTemporality = {}));
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/utils.js
+function hashAttributes(attributes) {
+  let keys = Object.keys(attributes);
+  if (keys.length === 0)
+    return "";
+  keys = keys.sort();
+  return JSON.stringify(keys.map((key) => [key, attributes[key]]));
+}
+function instrumentationScopeId(instrumentationScope) {
+  return `${instrumentationScope.name}:${instrumentationScope.version ?? ""}:${instrumentationScope.schemaUrl ?? ""}`;
+}
+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;
+  });
+}
+function setEquals(lhs, rhs) {
+  if (lhs.size !== rhs.size) {
+    return false;
+  }
+  for (const item of lhs) {
+    if (!rhs.has(item)) {
+      return false;
+    }
+  }
+  return true;
+}
+function binarySearchUB(arr, value) {
+  let lo = 0;
+  let hi = arr.length - 1;
+  let ret = arr.length;
+  while (hi >= lo) {
+    const mid = lo + Math.trunc((hi - lo) / 2);
+    if (arr[mid] < value) {
+      lo = mid + 1;
+    } else {
+      ret = mid;
+      hi = mid - 1;
+    }
+  }
+  return ret;
+}
+function equalsCaseInsensitive(lhs, rhs) {
+  return lhs.toLowerCase() === rhs.toLowerCase();
+}
+var TimeoutError;
+var init_utils = __esm(() => {
+  TimeoutError = class TimeoutError extends Error {
+    constructor(message) {
+      super(message);
+      Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/types.js
+var AggregatorKind;
+var init_types = __esm(() => {
+  (function(AggregatorKind2) {
+    AggregatorKind2[AggregatorKind2["DROP"] = 0] = "DROP";
+    AggregatorKind2[AggregatorKind2["SUM"] = 1] = "SUM";
+    AggregatorKind2[AggregatorKind2["LAST_VALUE"] = 2] = "LAST_VALUE";
+    AggregatorKind2[AggregatorKind2["HISTOGRAM"] = 3] = "HISTOGRAM";
+    AggregatorKind2[AggregatorKind2["EXPONENTIAL_HISTOGRAM"] = 4] = "EXPONENTIAL_HISTOGRAM";
+  })(AggregatorKind || (AggregatorKind = {}));
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/Drop.js
+class DropAggregator {
+  kind = AggregatorKind.DROP;
+  createAccumulation() {
+    return;
+  }
+  merge(_previous, _delta) {
+    return;
+  }
+  diff(_previous, _current) {
+    return;
+  }
+  toMetricData(_descriptor, _aggregationTemporality, _accumulationByAttributes, _endTime) {
+    return;
+  }
+}
+var init_Drop = __esm(() => {
+  init_types();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/export/MetricData.js
+var InstrumentType, DataPointType;
+var init_MetricData = __esm(() => {
+  (function(InstrumentType2) {
+    InstrumentType2["COUNTER"] = "COUNTER";
+    InstrumentType2["GAUGE"] = "GAUGE";
+    InstrumentType2["HISTOGRAM"] = "HISTOGRAM";
+    InstrumentType2["UP_DOWN_COUNTER"] = "UP_DOWN_COUNTER";
+    InstrumentType2["OBSERVABLE_COUNTER"] = "OBSERVABLE_COUNTER";
+    InstrumentType2["OBSERVABLE_GAUGE"] = "OBSERVABLE_GAUGE";
+    InstrumentType2["OBSERVABLE_UP_DOWN_COUNTER"] = "OBSERVABLE_UP_DOWN_COUNTER";
+  })(InstrumentType || (InstrumentType = {}));
+  (function(DataPointType2) {
+    DataPointType2[DataPointType2["HISTOGRAM"] = 0] = "HISTOGRAM";
+    DataPointType2[DataPointType2["EXPONENTIAL_HISTOGRAM"] = 1] = "EXPONENTIAL_HISTOGRAM";
+    DataPointType2[DataPointType2["GAUGE"] = 2] = "GAUGE";
+    DataPointType2[DataPointType2["SUM"] = 3] = "SUM";
+  })(DataPointType || (DataPointType = {}));
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/Histogram.js
+function createNewEmptyCheckpoint(boundaries) {
+  const counts = boundaries.map(() => 0);
+  counts.push(0);
+  return {
+    buckets: {
+      boundaries,
+      counts
+    },
+    sum: 0,
+    count: 0,
+    hasMinMax: false,
+    min: Infinity,
+    max: -Infinity
+  };
+}
+
+class HistogramAccumulation {
+  startTime;
+  _boundaries;
+  _recordMinMax;
+  _current;
+  constructor(startTime, boundaries, recordMinMax = true, current = createNewEmptyCheckpoint(boundaries)) {
+    this.startTime = startTime;
+    this._boundaries = boundaries;
+    this._recordMinMax = recordMinMax;
+    this._current = current;
+  }
+  record(value) {
+    if (Number.isNaN(value)) {
+      return;
+    }
+    this._current.count += 1;
+    this._current.sum += value;
+    if (this._recordMinMax) {
+      this._current.min = Math.min(value, this._current.min);
+      this._current.max = Math.max(value, this._current.max);
+      this._current.hasMinMax = true;
+    }
+    const idx = binarySearchUB(this._boundaries, value);
+    this._current.buckets.counts[idx] += 1;
+  }
+  setStartTime(startTime) {
+    this.startTime = startTime;
+  }
+  toPointValue() {
+    return this._current;
+  }
+}
+
+class HistogramAggregator {
+  kind = AggregatorKind.HISTOGRAM;
+  _boundaries;
+  _recordMinMax;
+  constructor(boundaries, recordMinMax) {
+    this._boundaries = boundaries;
+    this._recordMinMax = recordMinMax;
+  }
+  createAccumulation(startTime) {
+    return new HistogramAccumulation(startTime, this._boundaries, this._recordMinMax);
+  }
+  merge(previous, delta) {
+    const previousValue = previous.toPointValue();
+    const deltaValue = delta.toPointValue();
+    const previousCounts = previousValue.buckets.counts;
+    const deltaCounts = deltaValue.buckets.counts;
+    const mergedCounts = new Array(previousCounts.length);
+    for (let idx = 0;idx < previousCounts.length; idx++) {
+      mergedCounts[idx] = previousCounts[idx] + deltaCounts[idx];
+    }
+    let min = Infinity;
+    let max = -Infinity;
+    if (this._recordMinMax) {
+      if (previousValue.hasMinMax && deltaValue.hasMinMax) {
+        min = Math.min(previousValue.min, deltaValue.min);
+        max = Math.max(previousValue.max, deltaValue.max);
+      } else if (previousValue.hasMinMax) {
+        min = previousValue.min;
+        max = previousValue.max;
+      } else if (deltaValue.hasMinMax) {
+        min = deltaValue.min;
+        max = deltaValue.max;
+      }
+    }
+    return new HistogramAccumulation(previous.startTime, previousValue.buckets.boundaries, this._recordMinMax, {
+      buckets: {
+        boundaries: previousValue.buckets.boundaries,
+        counts: mergedCounts
+      },
+      count: previousValue.count + deltaValue.count,
+      sum: previousValue.sum + deltaValue.sum,
+      hasMinMax: this._recordMinMax && (previousValue.hasMinMax || deltaValue.hasMinMax),
+      min,
+      max
+    });
+  }
+  diff(previous, current) {
+    const previousValue = previous.toPointValue();
+    const currentValue = current.toPointValue();
+    const previousCounts = previousValue.buckets.counts;
+    const currentCounts = currentValue.buckets.counts;
+    const diffedCounts = new Array(previousCounts.length);
+    for (let idx = 0;idx < previousCounts.length; idx++) {
+      diffedCounts[idx] = currentCounts[idx] - previousCounts[idx];
+    }
+    return new HistogramAccumulation(current.startTime, previousValue.buckets.boundaries, this._recordMinMax, {
+      buckets: {
+        boundaries: previousValue.buckets.boundaries,
+        counts: diffedCounts
+      },
+      count: currentValue.count - previousValue.count,
+      sum: currentValue.sum - previousValue.sum,
+      hasMinMax: false,
+      min: Infinity,
+      max: -Infinity
+    });
+  }
+  toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+    return {
+      descriptor,
+      aggregationTemporality,
+      dataPointType: DataPointType.HISTOGRAM,
+      dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+        const pointValue = accumulation.toPointValue();
+        const allowsNegativeValues = descriptor.type === InstrumentType.GAUGE || descriptor.type === InstrumentType.UP_DOWN_COUNTER || descriptor.type === InstrumentType.OBSERVABLE_GAUGE || descriptor.type === InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;
+        return {
+          attributes,
+          startTime: accumulation.startTime,
+          endTime,
+          value: {
+            min: pointValue.hasMinMax ? pointValue.min : undefined,
+            max: pointValue.hasMinMax ? pointValue.max : undefined,
+            sum: !allowsNegativeValues ? pointValue.sum : undefined,
+            buckets: pointValue.buckets,
+            count: pointValue.count
+          }
+        };
+      })
+    };
+  }
+}
+var init_Histogram = __esm(() => {
+  init_types();
+  init_MetricData();
+  init_utils();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/exponential-histogram/Buckets.js
+class Buckets {
+  backing;
+  indexBase;
+  indexStart;
+  indexEnd;
+  constructor(backing = new BucketsBacking, indexBase = 0, indexStart = 0, indexEnd = 0) {
+    this.backing = backing;
+    this.indexBase = indexBase;
+    this.indexStart = indexStart;
+    this.indexEnd = indexEnd;
+  }
+  get offset() {
+    return this.indexStart;
+  }
+  get length() {
+    if (this.backing.length === 0) {
+      return 0;
+    }
+    if (this.indexEnd === this.indexStart && this.at(0) === 0) {
+      return 0;
+    }
+    return this.indexEnd - this.indexStart + 1;
+  }
+  counts() {
+    return Array.from({ length: this.length }, (_, i) => this.at(i));
+  }
+  at(position) {
+    const bias = this.indexBase - this.indexStart;
+    if (position < bias) {
+      position += this.backing.length;
+    }
+    position -= bias;
+    return this.backing.countAt(position);
+  }
+  incrementBucket(bucketIndex, increment) {
+    this.backing.increment(bucketIndex, increment);
+  }
+  decrementBucket(bucketIndex, decrement) {
+    this.backing.decrement(bucketIndex, decrement);
+  }
+  trim() {
+    for (let i = 0;i < this.length; i++) {
+      if (this.at(i) !== 0) {
+        this.indexStart += i;
+        break;
+      } else if (i === this.length - 1) {
+        this.indexStart = this.indexEnd = this.indexBase = 0;
+        return;
+      }
+    }
+    for (let i = this.length - 1;i >= 0; i--) {
+      if (this.at(i) !== 0) {
+        this.indexEnd -= this.length - i - 1;
+        break;
+      }
+    }
+    this._rotate();
+  }
+  downscale(by) {
+    this._rotate();
+    const size = 1 + this.indexEnd - this.indexStart;
+    const each = 1 << by;
+    let inpos = 0;
+    let outpos = 0;
+    for (let pos = this.indexStart;pos <= this.indexEnd; ) {
+      let mod = pos % each;
+      if (mod < 0) {
+        mod += each;
+      }
+      for (let i = mod;i < each && inpos < size; i++) {
+        this._relocateBucket(outpos, inpos);
+        inpos++;
+        pos++;
+      }
+      outpos++;
+    }
+    this.indexStart >>= by;
+    this.indexEnd >>= by;
+    this.indexBase = this.indexStart;
+  }
+  clone() {
+    return new Buckets(this.backing.clone(), this.indexBase, this.indexStart, this.indexEnd);
+  }
+  _rotate() {
+    const bias = this.indexBase - this.indexStart;
+    if (bias === 0) {
+      return;
+    } else if (bias > 0) {
+      this.backing.reverse(0, this.backing.length);
+      this.backing.reverse(0, bias);
+      this.backing.reverse(bias, this.backing.length);
+    } else {
+      this.backing.reverse(0, this.backing.length);
+      this.backing.reverse(0, this.backing.length + bias);
+    }
+    this.indexBase = this.indexStart;
+  }
+  _relocateBucket(dest, src) {
+    if (dest === src) {
+      return;
+    }
+    this.incrementBucket(dest, this.backing.emptyBucket(src));
+  }
+}
+
+class BucketsBacking {
+  _counts;
+  constructor(counts = [0]) {
+    this._counts = counts;
+  }
+  get length() {
+    return this._counts.length;
+  }
+  countAt(pos) {
+    return this._counts[pos];
+  }
+  growTo(newSize, oldPositiveLimit, newPositiveLimit) {
+    const tmp = new Array(newSize).fill(0);
+    tmp.splice(newPositiveLimit, this._counts.length - oldPositiveLimit, ...this._counts.slice(oldPositiveLimit));
+    tmp.splice(0, oldPositiveLimit, ...this._counts.slice(0, oldPositiveLimit));
+    this._counts = tmp;
+  }
+  reverse(from, limit) {
+    const num = Math.floor((from + limit) / 2) - from;
+    for (let i = 0;i < num; i++) {
+      const tmp = this._counts[from + i];
+      this._counts[from + i] = this._counts[limit - i - 1];
+      this._counts[limit - i - 1] = tmp;
+    }
+  }
+  emptyBucket(src) {
+    const tmp = this._counts[src];
+    this._counts[src] = 0;
+    return tmp;
+  }
+  increment(bucketIndex, increment) {
+    this._counts[bucketIndex] += increment;
+  }
+  decrement(bucketIndex, decrement) {
+    if (this._counts[bucketIndex] >= decrement) {
+      this._counts[bucketIndex] -= decrement;
+    } else {
+      this._counts[bucketIndex] = 0;
+    }
+  }
+  clone() {
+    return new BucketsBacking([...this._counts]);
+  }
+}
+var init_Buckets = () => {};
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/exponential-histogram/mapping/ieee754.js
+function getNormalBase2(value) {
+  const dv = new DataView(new ArrayBuffer(8));
+  dv.setFloat64(0, value);
+  const hiBits = dv.getUint32(0);
+  const expBits = (hiBits & EXPONENT_MASK) >> 20;
+  return expBits - EXPONENT_BIAS;
+}
+function getSignificand(value) {
+  const dv = new DataView(new ArrayBuffer(8));
+  dv.setFloat64(0, value);
+  const hiBits = dv.getUint32(0);
+  const loBits = dv.getUint32(4);
+  const significandHiBits = (hiBits & SIGNIFICAND_MASK) * Math.pow(2, 32);
+  return significandHiBits + loBits;
+}
+var SIGNIFICAND_WIDTH = 52, EXPONENT_MASK = 2146435072, SIGNIFICAND_MASK = 1048575, EXPONENT_BIAS = 1023, MIN_NORMAL_EXPONENT, MAX_NORMAL_EXPONENT, MIN_VALUE;
+var init_ieee754 = __esm(() => {
+  MIN_NORMAL_EXPONENT = -EXPONENT_BIAS + 1;
+  MAX_NORMAL_EXPONENT = EXPONENT_BIAS;
+  MIN_VALUE = Math.pow(2, -1022);
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/exponential-histogram/util.js
+function ldexp(frac, exp) {
+  if (frac === 0 || frac === Number.POSITIVE_INFINITY || frac === Number.NEGATIVE_INFINITY || Number.isNaN(frac)) {
+    return frac;
+  }
+  return frac * Math.pow(2, exp);
+}
+function nextGreaterSquare(v) {
+  v--;
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  v++;
+  return v;
+}
+var init_util = () => {};
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/exponential-histogram/mapping/types.js
+var MappingError;
+var init_types2 = __esm(() => {
+  MappingError = class MappingError extends Error {
+  };
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/exponential-histogram/mapping/ExponentMapping.js
+class ExponentMapping {
+  _shift;
+  constructor(scale) {
+    this._shift = -scale;
+  }
+  mapToIndex(value) {
+    if (value < MIN_VALUE) {
+      return this._minNormalLowerBoundaryIndex();
+    }
+    const exp = getNormalBase2(value);
+    const correction = this._rightShift(getSignificand(value) - 1, SIGNIFICAND_WIDTH);
+    return exp + correction >> this._shift;
+  }
+  lowerBoundary(index) {
+    const minIndex = this._minNormalLowerBoundaryIndex();
+    if (index < minIndex) {
+      throw new MappingError(`underflow: ${index} is < minimum lower boundary: ${minIndex}`);
+    }
+    const maxIndex = this._maxNormalLowerBoundaryIndex();
+    if (index > maxIndex) {
+      throw new MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);
+    }
+    return ldexp(1, index << this._shift);
+  }
+  get scale() {
+    if (this._shift === 0) {
+      return 0;
+    }
+    return -this._shift;
+  }
+  _minNormalLowerBoundaryIndex() {
+    let index = MIN_NORMAL_EXPONENT >> this._shift;
+    if (this._shift < 2) {
+      index--;
+    }
+    return index;
+  }
+  _maxNormalLowerBoundaryIndex() {
+    return MAX_NORMAL_EXPONENT >> this._shift;
+  }
+  _rightShift(value, shift) {
+    return Math.floor(value * Math.pow(2, -shift));
+  }
+}
+var init_ExponentMapping = __esm(() => {
+  init_ieee754();
+  init_util();
+  init_types2();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/exponential-histogram/mapping/LogarithmMapping.js
+class LogarithmMapping {
+  _scale;
+  _scaleFactor;
+  _inverseFactor;
+  constructor(scale) {
+    this._scale = scale;
+    this._scaleFactor = ldexp(Math.LOG2E, scale);
+    this._inverseFactor = ldexp(Math.LN2, -scale);
+  }
+  mapToIndex(value) {
+    if (value <= MIN_VALUE) {
+      return this._minNormalLowerBoundaryIndex() - 1;
+    }
+    if (getSignificand(value) === 0) {
+      const exp = getNormalBase2(value);
+      return (exp << this._scale) - 1;
+    }
+    const index = Math.floor(Math.log(value) * this._scaleFactor);
+    const maxIndex = this._maxNormalLowerBoundaryIndex();
+    if (index >= maxIndex) {
+      return maxIndex;
+    }
+    return index;
+  }
+  lowerBoundary(index) {
+    const maxIndex = this._maxNormalLowerBoundaryIndex();
+    if (index >= maxIndex) {
+      if (index === maxIndex) {
+        return 2 * Math.exp((index - (1 << this._scale)) / this._scaleFactor);
+      }
+      throw new MappingError(`overflow: ${index} is > maximum lower boundary: ${maxIndex}`);
+    }
+    const minIndex = this._minNormalLowerBoundaryIndex();
+    if (index <= minIndex) {
+      if (index === minIndex) {
+        return MIN_VALUE;
+      } else if (index === minIndex - 1) {
+        return Math.exp((index + (1 << this._scale)) / this._scaleFactor) / 2;
+      }
+      throw new MappingError(`overflow: ${index} is < minimum lower boundary: ${minIndex}`);
+    }
+    return Math.exp(index * this._inverseFactor);
+  }
+  get scale() {
+    return this._scale;
+  }
+  _minNormalLowerBoundaryIndex() {
+    return MIN_NORMAL_EXPONENT << this._scale;
+  }
+  _maxNormalLowerBoundaryIndex() {
+    return (MAX_NORMAL_EXPONENT + 1 << this._scale) - 1;
+  }
+}
+var init_LogarithmMapping = __esm(() => {
+  init_ieee754();
+  init_util();
+  init_types2();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/exponential-histogram/mapping/getMapping.js
+function getMapping(scale) {
+  if (scale > MAX_SCALE || scale < MIN_SCALE) {
+    throw new MappingError(`expected scale >= ${MIN_SCALE} && <= ${MAX_SCALE}, got: ${scale}`);
+  }
+  return PREBUILT_MAPPINGS[scale + 10];
+}
+var MIN_SCALE = -10, MAX_SCALE = 20, PREBUILT_MAPPINGS;
+var init_getMapping = __esm(() => {
+  init_ExponentMapping();
+  init_LogarithmMapping();
+  init_types2();
+  PREBUILT_MAPPINGS = Array.from({ length: 31 }, (_, i) => {
+    if (i > 10) {
+      return new LogarithmMapping(i - 10);
+    }
+    return new ExponentMapping(i - 10);
+  });
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/ExponentialHistogram.js
+class HighLow {
+  static combine(h1, h2) {
+    return new HighLow(Math.min(h1.low, h2.low), Math.max(h1.high, h2.high));
+  }
+  low;
+  high;
+  constructor(low, high) {
+    this.low = low;
+    this.high = high;
+  }
+}
+
+class ExponentialHistogramAccumulation {
+  startTime;
+  _maxSize;
+  _recordMinMax;
+  _sum;
+  _count;
+  _zeroCount;
+  _min;
+  _max;
+  _positive;
+  _negative;
+  _mapping;
+  constructor(startTime, maxSize = DEFAULT_MAX_SIZE, recordMinMax = true, sum = 0, count = 0, zeroCount = 0, min = Number.POSITIVE_INFINITY, max = Number.NEGATIVE_INFINITY, positive = new Buckets, negative = new Buckets, mapping = getMapping(MAX_SCALE2)) {
+    this.startTime = startTime;
+    this._maxSize = maxSize;
+    this._recordMinMax = recordMinMax;
+    this._sum = sum;
+    this._count = count;
+    this._zeroCount = zeroCount;
+    this._min = min;
+    this._max = max;
+    this._positive = positive;
+    this._negative = negative;
+    this._mapping = mapping;
+    if (this._maxSize < MIN_MAX_SIZE) {
+      import_api.diag.warn(`Exponential Histogram Max Size set to ${this._maxSize},                 changing to the minimum size of: ${MIN_MAX_SIZE}`);
+      this._maxSize = MIN_MAX_SIZE;
+    }
+  }
+  record(value) {
+    this.updateByIncrement(value, 1);
+  }
+  setStartTime(startTime) {
+    this.startTime = startTime;
+  }
+  toPointValue() {
+    return {
+      hasMinMax: this._recordMinMax,
+      min: this.min,
+      max: this.max,
+      sum: this.sum,
+      positive: {
+        offset: this.positive.offset,
+        bucketCounts: this.positive.counts()
+      },
+      negative: {
+        offset: this.negative.offset,
+        bucketCounts: this.negative.counts()
+      },
+      count: this.count,
+      scale: this.scale,
+      zeroCount: this.zeroCount
+    };
+  }
+  get sum() {
+    return this._sum;
+  }
+  get min() {
+    return this._min;
+  }
+  get max() {
+    return this._max;
+  }
+  get count() {
+    return this._count;
+  }
+  get zeroCount() {
+    return this._zeroCount;
+  }
+  get scale() {
+    if (this._count === this._zeroCount) {
+      return 0;
+    }
+    return this._mapping.scale;
+  }
+  get positive() {
+    return this._positive;
+  }
+  get negative() {
+    return this._negative;
+  }
+  updateByIncrement(value, increment) {
+    if (Number.isNaN(value)) {
+      return;
+    }
+    if (value > this._max) {
+      this._max = value;
+    }
+    if (value < this._min) {
+      this._min = value;
+    }
+    this._count += increment;
+    if (value === 0) {
+      this._zeroCount += increment;
+      return;
+    }
+    this._sum += value * increment;
+    if (value > 0) {
+      this._updateBuckets(this._positive, value, increment);
+    } else {
+      this._updateBuckets(this._negative, -value, increment);
+    }
+  }
+  merge(previous) {
+    if (this._count === 0) {
+      this._min = previous.min;
+      this._max = previous.max;
+    } else if (previous.count !== 0) {
+      if (previous.min < this.min) {
+        this._min = previous.min;
+      }
+      if (previous.max > this.max) {
+        this._max = previous.max;
+      }
+    }
+    this.startTime = previous.startTime;
+    this._sum += previous.sum;
+    this._count += previous.count;
+    this._zeroCount += previous.zeroCount;
+    const minScale = this._minScale(previous);
+    this._downscale(this.scale - minScale);
+    this._mergeBuckets(this.positive, previous, previous.positive, minScale);
+    this._mergeBuckets(this.negative, previous, previous.negative, minScale);
+  }
+  diff(other) {
+    this._min = Infinity;
+    this._max = -Infinity;
+    this._sum -= other.sum;
+    this._count -= other.count;
+    this._zeroCount -= other.zeroCount;
+    const minScale = this._minScale(other);
+    this._downscale(this.scale - minScale);
+    this._diffBuckets(this.positive, other, other.positive, minScale);
+    this._diffBuckets(this.negative, other, other.negative, minScale);
+  }
+  clone() {
+    return new ExponentialHistogramAccumulation(this.startTime, this._maxSize, this._recordMinMax, this._sum, this._count, this._zeroCount, this._min, this._max, this.positive.clone(), this.negative.clone(), this._mapping);
+  }
+  _updateBuckets(buckets, value, increment) {
+    let index = this._mapping.mapToIndex(value);
+    let rescalingNeeded = false;
+    let high = 0;
+    let low = 0;
+    if (buckets.length === 0) {
+      buckets.indexStart = index;
+      buckets.indexEnd = buckets.indexStart;
+      buckets.indexBase = buckets.indexStart;
+    } else if (index < buckets.indexStart && buckets.indexEnd - index >= this._maxSize) {
+      rescalingNeeded = true;
+      low = index;
+      high = buckets.indexEnd;
+    } else if (index > buckets.indexEnd && index - buckets.indexStart >= this._maxSize) {
+      rescalingNeeded = true;
+      low = buckets.indexStart;
+      high = index;
+    }
+    if (rescalingNeeded) {
+      const change = this._changeScale(high, low);
+      this._downscale(change);
+      index = this._mapping.mapToIndex(value);
+    }
+    this._incrementIndexBy(buckets, index, increment);
+  }
+  _incrementIndexBy(buckets, index, increment) {
+    if (increment === 0) {
+      return;
+    }
+    if (buckets.length === 0) {
+      buckets.indexStart = buckets.indexEnd = buckets.indexBase = index;
+    }
+    if (index < buckets.indexStart) {
+      const span = buckets.indexEnd - index;
+      if (span >= buckets.backing.length) {
+        this._grow(buckets, span + 1);
+      }
+      buckets.indexStart = index;
+    } else if (index > buckets.indexEnd) {
+      const span = index - buckets.indexStart;
+      if (span >= buckets.backing.length) {
+        this._grow(buckets, span + 1);
+      }
+      buckets.indexEnd = index;
+    }
+    let bucketIndex = index - buckets.indexBase;
+    if (bucketIndex < 0) {
+      bucketIndex += buckets.backing.length;
+    }
+    buckets.incrementBucket(bucketIndex, increment);
+  }
+  _grow(buckets, needed) {
+    const size = buckets.backing.length;
+    const bias = buckets.indexBase - buckets.indexStart;
+    const oldPositiveLimit = size - bias;
+    let newSize = nextGreaterSquare(needed);
+    if (newSize > this._maxSize) {
+      newSize = this._maxSize;
+    }
+    const newPositiveLimit = newSize - bias;
+    buckets.backing.growTo(newSize, oldPositiveLimit, newPositiveLimit);
+  }
+  _changeScale(high, low) {
+    let change = 0;
+    while (high - low >= this._maxSize) {
+      high >>= 1;
+      low >>= 1;
+      change++;
+    }
+    return change;
+  }
+  _downscale(change) {
+    if (change === 0) {
+      return;
+    }
+    if (change < 0) {
+      throw new Error(`impossible change of scale: ${this.scale}`);
+    }
+    const newScale = this._mapping.scale - change;
+    this._positive.downscale(change);
+    this._negative.downscale(change);
+    this._mapping = getMapping(newScale);
+  }
+  _minScale(other) {
+    const minScale = Math.min(this.scale, other.scale);
+    const highLowPos = HighLow.combine(this._highLowAtScale(this.positive, this.scale, minScale), this._highLowAtScale(other.positive, other.scale, minScale));
+    const highLowNeg = HighLow.combine(this._highLowAtScale(this.negative, this.scale, minScale), this._highLowAtScale(other.negative, other.scale, minScale));
+    return Math.min(minScale - this._changeScale(highLowPos.high, highLowPos.low), minScale - this._changeScale(highLowNeg.high, highLowNeg.low));
+  }
+  _highLowAtScale(buckets, currentScale, newScale) {
+    if (buckets.length === 0) {
+      return new HighLow(0, -1);
+    }
+    const shift = currentScale - newScale;
+    return new HighLow(buckets.indexStart >> shift, buckets.indexEnd >> shift);
+  }
+  _mergeBuckets(ours, other, theirs, scale) {
+    const theirOffset = theirs.offset;
+    const theirChange = other.scale - scale;
+    for (let i = 0;i < theirs.length; i++) {
+      this._incrementIndexBy(ours, theirOffset + i >> theirChange, theirs.at(i));
+    }
+  }
+  _diffBuckets(ours, other, theirs, scale) {
+    const theirOffset = theirs.offset;
+    const theirChange = other.scale - scale;
+    for (let i = 0;i < theirs.length; i++) {
+      const ourIndex = theirOffset + i >> theirChange;
+      let bucketIndex = ourIndex - ours.indexBase;
+      if (bucketIndex < 0) {
+        bucketIndex += ours.backing.length;
+      }
+      ours.decrementBucket(bucketIndex, theirs.at(i));
+    }
+    ours.trim();
+  }
+}
+
+class ExponentialHistogramAggregator {
+  kind = AggregatorKind.EXPONENTIAL_HISTOGRAM;
+  _maxSize;
+  _recordMinMax;
+  constructor(maxSize, recordMinMax) {
+    this._maxSize = maxSize;
+    this._recordMinMax = recordMinMax;
+  }
+  createAccumulation(startTime) {
+    return new ExponentialHistogramAccumulation(startTime, this._maxSize, this._recordMinMax);
+  }
+  merge(previous, delta) {
+    const result = delta.clone();
+    result.merge(previous);
+    return result;
+  }
+  diff(previous, current) {
+    const result = current.clone();
+    result.diff(previous);
+    return result;
+  }
+  toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+    return {
+      descriptor,
+      aggregationTemporality,
+      dataPointType: DataPointType.EXPONENTIAL_HISTOGRAM,
+      dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+        const pointValue = accumulation.toPointValue();
+        const allowsNegativeValues = descriptor.type === InstrumentType.GAUGE || descriptor.type === InstrumentType.UP_DOWN_COUNTER || descriptor.type === InstrumentType.OBSERVABLE_GAUGE || descriptor.type === InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;
+        return {
+          attributes,
+          startTime: accumulation.startTime,
+          endTime,
+          value: {
+            min: pointValue.hasMinMax ? pointValue.min : undefined,
+            max: pointValue.hasMinMax ? pointValue.max : undefined,
+            sum: !allowsNegativeValues ? pointValue.sum : undefined,
+            positive: {
+              offset: pointValue.positive.offset,
+              bucketCounts: pointValue.positive.bucketCounts
+            },
+            negative: {
+              offset: pointValue.negative.offset,
+              bucketCounts: pointValue.negative.bucketCounts
+            },
+            count: pointValue.count,
+            scale: pointValue.scale,
+            zeroCount: pointValue.zeroCount
+          }
+        };
+      })
+    };
+  }
+}
+var import_api, MAX_SCALE2 = 20, DEFAULT_MAX_SIZE = 160, MIN_MAX_SIZE = 2;
+var init_ExponentialHistogram = __esm(() => {
+  init_types();
+  init_MetricData();
+  init_Buckets();
+  init_getMapping();
+  init_util();
+  import_api = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/LastValue.js
+class LastValueAccumulation {
+  startTime;
+  _current;
+  sampleTime;
+  constructor(startTime, current = 0, sampleTime = [0, 0]) {
+    this.startTime = startTime;
+    this._current = current;
+    this.sampleTime = sampleTime;
+  }
+  record(value) {
+    this._current = value;
+    this.sampleTime = millisToHrTime(Date.now());
+  }
+  setStartTime(startTime) {
+    this.startTime = startTime;
+  }
+  toPointValue() {
+    return this._current;
+  }
+}
+
+class LastValueAggregator {
+  kind = AggregatorKind.LAST_VALUE;
+  createAccumulation(startTime) {
+    return new LastValueAccumulation(startTime);
+  }
+  merge(previous, delta) {
+    const latestAccumulation = hrTimeToMicroseconds(delta.sampleTime) >= hrTimeToMicroseconds(previous.sampleTime) ? delta : previous;
+    return new LastValueAccumulation(previous.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);
+  }
+  diff(previous, current) {
+    const latestAccumulation = hrTimeToMicroseconds(current.sampleTime) >= hrTimeToMicroseconds(previous.sampleTime) ? current : previous;
+    return new LastValueAccumulation(current.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);
+  }
+  toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+    return {
+      descriptor,
+      aggregationTemporality,
+      dataPointType: DataPointType.GAUGE,
+      dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+        return {
+          attributes,
+          startTime: accumulation.startTime,
+          endTime,
+          value: accumulation.toPointValue()
+        };
+      })
+    };
+  }
+}
+var init_LastValue = __esm(() => {
+  init_types();
+  init_esm();
+  init_MetricData();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/Sum.js
+class SumAccumulation {
+  startTime;
+  monotonic;
+  _current;
+  reset;
+  constructor(startTime, monotonic, current = 0, reset = false) {
+    this.startTime = startTime;
+    this.monotonic = monotonic;
+    this._current = current;
+    this.reset = reset;
+  }
+  record(value) {
+    if (this.monotonic && value < 0) {
+      return;
+    }
+    this._current += value;
+  }
+  setStartTime(startTime) {
+    this.startTime = startTime;
+  }
+  toPointValue() {
+    return this._current;
+  }
+}
+
+class SumAggregator {
+  kind = AggregatorKind.SUM;
+  monotonic;
+  constructor(monotonic) {
+    this.monotonic = monotonic;
+  }
+  createAccumulation(startTime) {
+    return new SumAccumulation(startTime, this.monotonic);
+  }
+  merge(previous, delta) {
+    const prevPv = previous.toPointValue();
+    const deltaPv = delta.toPointValue();
+    if (delta.reset) {
+      return new SumAccumulation(delta.startTime, this.monotonic, deltaPv, delta.reset);
+    }
+    return new SumAccumulation(previous.startTime, this.monotonic, prevPv + deltaPv);
+  }
+  diff(previous, current) {
+    const prevPv = previous.toPointValue();
+    const currPv = current.toPointValue();
+    if (this.monotonic && prevPv > currPv) {
+      return new SumAccumulation(current.startTime, this.monotonic, currPv, true);
+    }
+    return new SumAccumulation(current.startTime, this.monotonic, currPv - prevPv);
+  }
+  toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+    return {
+      descriptor,
+      aggregationTemporality,
+      dataPointType: DataPointType.SUM,
+      dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+        return {
+          attributes,
+          startTime: accumulation.startTime,
+          endTime,
+          value: accumulation.toPointValue()
+        };
+      }),
+      isMonotonic: this.monotonic
+    };
+  }
+}
+var init_Sum = __esm(() => {
+  init_types();
+  init_MetricData();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/aggregator/index.js
+var init_aggregator = __esm(() => {
+  init_Drop();
+  init_Histogram();
+  init_ExponentialHistogram();
+  init_LastValue();
+  init_Sum();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/Aggregation.js
+class ExplicitBucketHistogramAggregation {
+  _boundaries;
+  _recordMinMax;
+  constructor(boundaries, recordMinMax = true) {
+    if (boundaries == null) {
+      throw new Error("ExplicitBucketHistogramAggregation should be created with explicit boundaries, if a single bucket histogram is required, please pass an empty array");
+    }
+    boundaries = boundaries.concat();
+    boundaries = boundaries.sort((a, b) => a - b);
+    const minusInfinityIndex = boundaries.lastIndexOf(-Infinity);
+    let infinityIndex = boundaries.indexOf(Infinity);
+    if (infinityIndex === -1) {
+      infinityIndex = undefined;
+    }
+    this._boundaries = boundaries.slice(minusInfinityIndex + 1, infinityIndex);
+    this._recordMinMax = recordMinMax;
+  }
+  createAggregator(_instrument) {
+    return new HistogramAggregator(this._boundaries, this._recordMinMax);
+  }
+}
+
+class ExponentialHistogramAggregation {
+  _maxSize;
+  _recordMinMax;
+  constructor(maxSize = 160, recordMinMax = true) {
+    this._maxSize = maxSize;
+    this._recordMinMax = recordMinMax;
+  }
+  createAggregator(_instrument) {
+    return new ExponentialHistogramAggregator(this._maxSize, this._recordMinMax);
+  }
+}
+
+class DefaultAggregation {
+  _resolve(instrument) {
+    switch (instrument.type) {
+      case InstrumentType.COUNTER:
+      case InstrumentType.UP_DOWN_COUNTER:
+      case InstrumentType.OBSERVABLE_COUNTER:
+      case InstrumentType.OBSERVABLE_UP_DOWN_COUNTER: {
+        return SUM_AGGREGATION;
+      }
+      case InstrumentType.GAUGE:
+      case InstrumentType.OBSERVABLE_GAUGE: {
+        return LAST_VALUE_AGGREGATION;
+      }
+      case InstrumentType.HISTOGRAM: {
+        if (instrument.advice.explicitBucketBoundaries) {
+          return new ExplicitBucketHistogramAggregation(instrument.advice.explicitBucketBoundaries);
+        }
+        return HISTOGRAM_AGGREGATION;
+      }
+    }
+    api.diag.warn(`Unable to recognize instrument type: ${instrument.type}`);
+    return DROP_AGGREGATION;
+  }
+  createAggregator(instrument) {
+    return this._resolve(instrument).createAggregator(instrument);
+  }
+}
+var api, DropAggregation, SumAggregation, LastValueAggregation, HistogramAggregation, DROP_AGGREGATION, SUM_AGGREGATION, LAST_VALUE_AGGREGATION, HISTOGRAM_AGGREGATION, EXPONENTIAL_HISTOGRAM_AGGREGATION, DEFAULT_AGGREGATION;
+var init_Aggregation = __esm(() => {
+  init_aggregator();
+  init_MetricData();
+  api = __toESM(require_src(), 1);
+  DropAggregation = class DropAggregation {
+    static DEFAULT_INSTANCE = new DropAggregator;
+    createAggregator(_instrument) {
+      return DropAggregation.DEFAULT_INSTANCE;
+    }
+  };
+  SumAggregation = class SumAggregation {
+    static MONOTONIC_INSTANCE = new SumAggregator(true);
+    static NON_MONOTONIC_INSTANCE = new SumAggregator(false);
+    createAggregator(instrument) {
+      switch (instrument.type) {
+        case InstrumentType.COUNTER:
+        case InstrumentType.OBSERVABLE_COUNTER:
+        case InstrumentType.HISTOGRAM: {
+          return SumAggregation.MONOTONIC_INSTANCE;
+        }
+        default: {
+          return SumAggregation.NON_MONOTONIC_INSTANCE;
+        }
+      }
+    }
+  };
+  LastValueAggregation = class LastValueAggregation {
+    static DEFAULT_INSTANCE = new LastValueAggregator;
+    createAggregator(_instrument) {
+      return LastValueAggregation.DEFAULT_INSTANCE;
+    }
+  };
+  HistogramAggregation = class HistogramAggregation {
+    static DEFAULT_INSTANCE = new HistogramAggregator([0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 1e4], true);
+    createAggregator(_instrument) {
+      return HistogramAggregation.DEFAULT_INSTANCE;
+    }
+  };
+  DROP_AGGREGATION = new DropAggregation;
+  SUM_AGGREGATION = new SumAggregation;
+  LAST_VALUE_AGGREGATION = new LastValueAggregation;
+  HISTOGRAM_AGGREGATION = new HistogramAggregation;
+  EXPONENTIAL_HISTOGRAM_AGGREGATION = new ExponentialHistogramAggregation;
+  DEFAULT_AGGREGATION = new DefaultAggregation;
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/AggregationOption.js
+function toAggregation(option) {
+  switch (option.type) {
+    case AggregationType.DEFAULT:
+      return DEFAULT_AGGREGATION;
+    case AggregationType.DROP:
+      return DROP_AGGREGATION;
+    case AggregationType.SUM:
+      return SUM_AGGREGATION;
+    case AggregationType.LAST_VALUE:
+      return LAST_VALUE_AGGREGATION;
+    case AggregationType.EXPONENTIAL_HISTOGRAM: {
+      const expOption = option;
+      return new ExponentialHistogramAggregation(expOption.options?.maxSize, expOption.options?.recordMinMax);
+    }
+    case AggregationType.EXPLICIT_BUCKET_HISTOGRAM: {
+      const expOption = option;
+      if (expOption.options == null) {
+        return HISTOGRAM_AGGREGATION;
+      } else {
+        return new ExplicitBucketHistogramAggregation(expOption.options?.boundaries, expOption.options?.recordMinMax);
+      }
+    }
+    default:
+      throw new Error("Unsupported Aggregation");
+  }
+}
+var AggregationType;
+var init_AggregationOption = __esm(() => {
+  init_Aggregation();
+  (function(AggregationType2) {
+    AggregationType2[AggregationType2["DEFAULT"] = 0] = "DEFAULT";
+    AggregationType2[AggregationType2["DROP"] = 1] = "DROP";
+    AggregationType2[AggregationType2["SUM"] = 2] = "SUM";
+    AggregationType2[AggregationType2["LAST_VALUE"] = 3] = "LAST_VALUE";
+    AggregationType2[AggregationType2["EXPLICIT_BUCKET_HISTOGRAM"] = 4] = "EXPLICIT_BUCKET_HISTOGRAM";
+    AggregationType2[AggregationType2["EXPONENTIAL_HISTOGRAM"] = 5] = "EXPONENTIAL_HISTOGRAM";
+  })(AggregationType || (AggregationType = {}));
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/export/AggregationSelector.js
+var DEFAULT_AGGREGATION_SELECTOR = (_instrumentType) => {
+  return {
+    type: AggregationType.DEFAULT
+  };
+}, DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR = (_instrumentType) => AggregationTemporality.CUMULATIVE;
+var init_AggregationSelector = __esm(() => {
+  init_AggregationTemporality();
+  init_AggregationOption();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/export/MetricReader.js
+class MetricReader {
+  _shutdown = false;
+  _metricProducers;
+  _sdkMetricProducer;
+  _aggregationTemporalitySelector;
+  _aggregationSelector;
+  _cardinalitySelector;
+  constructor(options) {
+    this._aggregationSelector = options?.aggregationSelector ?? DEFAULT_AGGREGATION_SELECTOR;
+    this._aggregationTemporalitySelector = options?.aggregationTemporalitySelector ?? DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR;
+    this._metricProducers = options?.metricProducers ?? [];
+    this._cardinalitySelector = options?.cardinalitySelector;
+  }
+  setMetricProducer(metricProducer) {
+    if (this._sdkMetricProducer) {
+      throw new Error("MetricReader can not be bound to a MeterProvider again.");
+    }
+    this._sdkMetricProducer = metricProducer;
+    this.onInitialized();
+  }
+  selectAggregation(instrumentType) {
+    return this._aggregationSelector(instrumentType);
+  }
+  selectAggregationTemporality(instrumentType) {
+    return this._aggregationTemporalitySelector(instrumentType);
+  }
+  selectCardinalityLimit(instrumentType) {
+    return this._cardinalitySelector ? this._cardinalitySelector(instrumentType) : 2000;
+  }
+  onInitialized() {}
+  async collect(options) {
+    if (this._sdkMetricProducer === undefined) {
+      throw new Error("MetricReader is not bound to a MetricProducer");
+    }
+    if (this._shutdown) {
+      throw new Error("MetricReader is shutdown");
+    }
+    const [sdkCollectionResults, ...additionalCollectionResults] = await Promise.all([
+      this._sdkMetricProducer.collect({
+        timeoutMillis: options?.timeoutMillis
+      }),
+      ...this._metricProducers.map((producer) => producer.collect({
+        timeoutMillis: options?.timeoutMillis
+      }))
+    ]);
+    const errors = sdkCollectionResults.errors.concat(additionalCollectionResults.flatMap((result) => result.errors));
+    const resource = sdkCollectionResults.resourceMetrics.resource;
+    const scopeMetrics = sdkCollectionResults.resourceMetrics.scopeMetrics.concat(additionalCollectionResults.flatMap((result) => result.resourceMetrics.scopeMetrics));
+    return {
+      resourceMetrics: {
+        resource,
+        scopeMetrics
+      },
+      errors
+    };
+  }
+  async shutdown(options) {
+    if (this._shutdown) {
+      api2.diag.error("Cannot call shutdown twice.");
+      return;
+    }
+    if (options?.timeoutMillis == null) {
+      await this.onShutdown();
+    } else {
+      await callWithTimeout(this.onShutdown(), options.timeoutMillis);
+    }
+    this._shutdown = true;
+  }
+  async forceFlush(options) {
+    if (this._shutdown) {
+      api2.diag.warn("Cannot forceFlush on already shutdown MetricReader.");
+      return;
+    }
+    if (options?.timeoutMillis == null) {
+      await this.onForceFlush();
+      return;
+    }
+    await callWithTimeout(this.onForceFlush(), options.timeoutMillis);
+  }
+}
+var api2;
+var init_MetricReader = __esm(() => {
+  init_utils();
+  init_AggregationSelector();
+  api2 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/export/PeriodicExportingMetricReader.js
+var api3, PeriodicExportingMetricReader;
+var init_PeriodicExportingMetricReader = __esm(() => {
+  init_esm();
+  init_MetricReader();
+  init_utils();
+  init_MetricData();
+  api3 = __toESM(require_src(), 1);
+  PeriodicExportingMetricReader = class PeriodicExportingMetricReader extends MetricReader {
+    _interval;
+    _exporter;
+    _exportInterval;
+    _exportTimeout;
+    constructor(options) {
+      const { exporter, exportIntervalMillis = 60000, metricProducers, cardinalityLimits } = options;
+      let { exportTimeoutMillis = 30000 } = options;
+      super({
+        aggregationSelector: exporter.selectAggregation?.bind(exporter),
+        aggregationTemporalitySelector: exporter.selectAggregationTemporality?.bind(exporter),
+        metricProducers,
+        cardinalitySelector: (instrumentType) => {
+          const limits = {
+            default: 2000,
+            ...cardinalityLimits
+          };
+          switch (instrumentType) {
+            case InstrumentType.COUNTER:
+              return limits.counter ?? limits.default;
+            case InstrumentType.GAUGE:
+              return limits.gauge ?? limits.default;
+            case InstrumentType.HISTOGRAM:
+              return limits.histogram ?? limits.default;
+            case InstrumentType.OBSERVABLE_COUNTER:
+              return limits.observableCounter ?? limits.default;
+            case InstrumentType.OBSERVABLE_UP_DOWN_COUNTER:
+              return limits.observableUpDownCounter ?? limits.default;
+            case InstrumentType.OBSERVABLE_GAUGE:
+              return limits.observableGauge ?? limits.default;
+            case InstrumentType.UP_DOWN_COUNTER:
+              return limits.upDownCounter ?? limits.default;
+            default:
+              return limits.default;
+          }
+        }
+      });
+      if (exportIntervalMillis <= 0) {
+        throw Error("exportIntervalMillis must be greater than 0");
+      }
+      if (exportTimeoutMillis <= 0) {
+        throw Error("exportTimeoutMillis must be greater than 0");
+      }
+      if (exportIntervalMillis < exportTimeoutMillis) {
+        if ("exportIntervalMillis" in options && "exportTimeoutMillis" in options) {
+          throw Error("exportIntervalMillis must be greater than or equal to exportTimeoutMillis");
+        } else {
+          api3.diag.info(`Timeout of ${exportTimeoutMillis} exceeds the interval of ${exportIntervalMillis}. Clamping timeout to interval duration.`);
+          exportTimeoutMillis = exportIntervalMillis;
+        }
+      }
+      this._exportInterval = exportIntervalMillis;
+      this._exportTimeout = exportTimeoutMillis;
+      this._exporter = exporter;
+    }
+    async _runOnce() {
+      try {
+        await callWithTimeout(this._doRun(), this._exportTimeout);
+      } catch (err) {
+        if (err instanceof TimeoutError) {
+          api3.diag.error("Export took longer than %s milliseconds and timed out.", this._exportTimeout);
+          return;
+        }
+        globalErrorHandler(err);
+      }
+    }
+    async _doRun() {
+      const { resourceMetrics, errors } = await this.collect({
+        timeoutMillis: this._exportTimeout
+      });
+      if (errors.length > 0) {
+        api3.diag.error("PeriodicExportingMetricReader: metrics collection errors", ...errors);
+      }
+      if (resourceMetrics.resource.asyncAttributesPending) {
+        try {
+          await resourceMetrics.resource.waitForAsyncAttributes?.();
+        } catch (e) {
+          api3.diag.debug("Error while resolving async portion of resource: ", e);
+          globalErrorHandler(e);
+        }
+      }
+      if (resourceMetrics.scopeMetrics.length === 0) {
+        return;
+      }
+      const result = await internal._export(this._exporter, resourceMetrics);
+      if (result.code !== ExportResultCode.SUCCESS) {
+        throw new Error(`PeriodicExportingMetricReader: metrics export failed (error ${result.error})`);
+      }
+    }
+    onInitialized() {
+      this._interval = setInterval(() => {
+        this._runOnce();
+      }, this._exportInterval);
+      if (typeof this._interval !== "number") {
+        this._interval.unref();
+      }
+    }
+    async onForceFlush() {
+      await this._runOnce();
+      await this._exporter.forceFlush();
+    }
+    async onShutdown() {
+      if (this._interval) {
+        clearInterval(this._interval);
+      }
+      await this.onForceFlush();
+      await this._exporter.shutdown();
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/export/ConsoleMetricExporter.js
+class ConsoleMetricExporter {
+  _shutdown = false;
+  _temporalitySelector;
+  constructor(options) {
+    this._temporalitySelector = options?.temporalitySelector ?? DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR;
+  }
+  export(metrics, resultCallback) {
+    if (this._shutdown) {
+      resultCallback({ code: ExportResultCode.FAILED });
+      return;
+    }
+    return ConsoleMetricExporter._sendMetrics(metrics, resultCallback);
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  selectAggregationTemporality(_instrumentType) {
+    return this._temporalitySelector(_instrumentType);
+  }
+  shutdown() {
+    this._shutdown = true;
+    return Promise.resolve();
+  }
+  static _sendMetrics(metrics, done) {
+    for (const scopeMetrics of metrics.scopeMetrics) {
+      for (const metric of scopeMetrics.metrics) {
+        console.dir({
+          descriptor: metric.descriptor,
+          dataPointType: metric.dataPointType,
+          dataPoints: metric.dataPoints
+        }, { depth: null });
+      }
+    }
+    done({ code: ExportResultCode.SUCCESS });
+  }
+}
+var init_ConsoleMetricExporter = __esm(() => {
+  init_esm();
+  init_AggregationSelector();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/ViewRegistry.js
+class ViewRegistry {
+  _registeredViews = [];
+  addView(view) {
+    this._registeredViews.push(view);
+  }
+  findViews(instrument, meter) {
+    const views = this._registeredViews.filter((registeredView) => {
+      return this._matchInstrument(registeredView.instrumentSelector, instrument) && this._matchMeter(registeredView.meterSelector, meter);
+    });
+    return views;
+  }
+  _matchInstrument(selector, instrument) {
+    return (selector.getType() === undefined || instrument.type === selector.getType()) && selector.getNameFilter().match(instrument.name) && selector.getUnitFilter().match(instrument.unit);
+  }
+  _matchMeter(selector, meter) {
+    return selector.getNameFilter().match(meter.name) && (meter.version === undefined || selector.getVersionFilter().match(meter.version)) && (meter.schemaUrl === undefined || selector.getSchemaUrlFilter().match(meter.schemaUrl));
+  }
+}
+var init_ViewRegistry = () => {};
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/InstrumentDescriptor.js
+function createInstrumentDescriptor(name, type, options) {
+  if (!isValidName(name)) {
+    import_api2.diag.warn(`Invalid metric name: "${name}". The metric name should be a ASCII string with a length no greater than 255 characters.`);
+  }
+  return {
+    name,
+    type,
+    description: options?.description ?? "",
+    unit: options?.unit ?? "",
+    valueType: options?.valueType ?? import_api2.ValueType.DOUBLE,
+    advice: options?.advice ?? {}
+  };
+}
+function createInstrumentDescriptorWithView(view, instrument) {
+  return {
+    name: view.name ?? instrument.name,
+    description: view.description ?? instrument.description,
+    type: instrument.type,
+    unit: instrument.unit,
+    valueType: instrument.valueType,
+    advice: instrument.advice
+  };
+}
+function isDescriptorCompatibleWith(descriptor, otherDescriptor) {
+  return equalsCaseInsensitive(descriptor.name, otherDescriptor.name) && descriptor.unit === otherDescriptor.unit && descriptor.type === otherDescriptor.type && descriptor.valueType === otherDescriptor.valueType;
+}
+function isValidName(name) {
+  return NAME_REGEXP.test(name);
+}
+var import_api2, NAME_REGEXP;
+var init_InstrumentDescriptor = __esm(() => {
+  init_utils();
+  import_api2 = __toESM(require_src(), 1);
+  NAME_REGEXP = /^[a-z][a-z0-9_.\-/]{0,254}$/i;
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/Instruments.js
+class SyncInstrument {
+  _writableMetricStorage;
+  _descriptor;
+  constructor(writableMetricStorage, descriptor) {
+    this._writableMetricStorage = writableMetricStorage;
+    this._descriptor = descriptor;
+  }
+  _record(value, attributes = {}, context = import_api3.context.active()) {
+    if (typeof value !== "number") {
+      import_api3.diag.warn(`non-number value provided to metric ${this._descriptor.name}: ${value}`);
+      return;
+    }
+    if (this._descriptor.valueType === import_api3.ValueType.INT && !Number.isInteger(value)) {
+      import_api3.diag.warn(`INT value type cannot accept a floating-point value for ${this._descriptor.name}, ignoring the fractional digits.`);
+      value = Math.trunc(value);
+      if (!Number.isInteger(value)) {
+        return;
+      }
+    }
+    this._writableMetricStorage.record(value, attributes, context, millisToHrTime(Date.now()));
+  }
+}
+
+class ObservableInstrument {
+  _metricStorages;
+  _descriptor;
+  _observableRegistry;
+  constructor(descriptor, metricStorages, observableRegistry) {
+    this._descriptor = descriptor;
+    this._metricStorages = metricStorages;
+    this._observableRegistry = observableRegistry;
+  }
+  addCallback(callback) {
+    this._observableRegistry.addCallback(callback, this);
+  }
+  removeCallback(callback) {
+    this._observableRegistry.removeCallback(callback, this);
+  }
+}
+function isObservableInstrument(it) {
+  return it instanceof ObservableInstrument;
+}
+var import_api3, UpDownCounterInstrument, CounterInstrument, GaugeInstrument, HistogramInstrument, ObservableCounterInstrument, ObservableGaugeInstrument, ObservableUpDownCounterInstrument;
+var init_Instruments = __esm(() => {
+  init_esm();
+  import_api3 = __toESM(require_src(), 1);
+  UpDownCounterInstrument = class UpDownCounterInstrument extends SyncInstrument {
+    add(value, attributes, ctx) {
+      this._record(value, attributes, ctx);
+    }
+  };
+  CounterInstrument = class CounterInstrument extends SyncInstrument {
+    add(value, attributes, ctx) {
+      if (value < 0) {
+        import_api3.diag.warn(`negative value provided to counter ${this._descriptor.name}: ${value}`);
+        return;
+      }
+      this._record(value, attributes, ctx);
+    }
+  };
+  GaugeInstrument = class GaugeInstrument extends SyncInstrument {
+    record(value, attributes, ctx) {
+      this._record(value, attributes, ctx);
+    }
+  };
+  HistogramInstrument = class HistogramInstrument extends SyncInstrument {
+    record(value, attributes, ctx) {
+      if (value < 0) {
+        import_api3.diag.warn(`negative value provided to histogram ${this._descriptor.name}: ${value}`);
+        return;
+      }
+      this._record(value, attributes, ctx);
+    }
+  };
+  ObservableCounterInstrument = class ObservableCounterInstrument extends ObservableInstrument {
+  };
+  ObservableGaugeInstrument = class ObservableGaugeInstrument extends ObservableInstrument {
+  };
+  ObservableUpDownCounterInstrument = class ObservableUpDownCounterInstrument extends ObservableInstrument {
+  };
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/Meter.js
+class Meter {
+  _meterSharedState;
+  constructor(meterSharedState) {
+    this._meterSharedState = meterSharedState;
+  }
+  createGauge(name, options) {
+    const descriptor = createInstrumentDescriptor(name, InstrumentType.GAUGE, options);
+    const storage = this._meterSharedState.registerMetricStorage(descriptor);
+    return new GaugeInstrument(storage, descriptor);
+  }
+  createHistogram(name, options) {
+    const descriptor = createInstrumentDescriptor(name, InstrumentType.HISTOGRAM, options);
+    const storage = this._meterSharedState.registerMetricStorage(descriptor);
+    return new HistogramInstrument(storage, descriptor);
+  }
+  createCounter(name, options) {
+    const descriptor = createInstrumentDescriptor(name, InstrumentType.COUNTER, options);
+    const storage = this._meterSharedState.registerMetricStorage(descriptor);
+    return new CounterInstrument(storage, descriptor);
+  }
+  createUpDownCounter(name, options) {
+    const descriptor = createInstrumentDescriptor(name, InstrumentType.UP_DOWN_COUNTER, options);
+    const storage = this._meterSharedState.registerMetricStorage(descriptor);
+    return new UpDownCounterInstrument(storage, descriptor);
+  }
+  createObservableGauge(name, options) {
+    const descriptor = createInstrumentDescriptor(name, InstrumentType.OBSERVABLE_GAUGE, options);
+    const storages = this._meterSharedState.registerAsyncMetricStorage(descriptor);
+    return new ObservableGaugeInstrument(descriptor, storages, this._meterSharedState.observableRegistry);
+  }
+  createObservableCounter(name, options) {
+    const descriptor = createInstrumentDescriptor(name, InstrumentType.OBSERVABLE_COUNTER, options);
+    const storages = this._meterSharedState.registerAsyncMetricStorage(descriptor);
+    return new ObservableCounterInstrument(descriptor, storages, this._meterSharedState.observableRegistry);
+  }
+  createObservableUpDownCounter(name, options) {
+    const descriptor = createInstrumentDescriptor(name, InstrumentType.OBSERVABLE_UP_DOWN_COUNTER, options);
+    const storages = this._meterSharedState.registerAsyncMetricStorage(descriptor);
+    return new ObservableUpDownCounterInstrument(descriptor, storages, this._meterSharedState.observableRegistry);
+  }
+  addBatchObservableCallback(callback, observables) {
+    this._meterSharedState.observableRegistry.addBatchCallback(callback, observables);
+  }
+  removeBatchObservableCallback(callback, observables) {
+    this._meterSharedState.observableRegistry.removeBatchCallback(callback, observables);
+  }
+}
+var init_Meter = __esm(() => {
+  init_InstrumentDescriptor();
+  init_Instruments();
+  init_MetricData();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MetricStorage.js
+class MetricStorage {
+  _instrumentDescriptor;
+  constructor(instrumentDescriptor) {
+    this._instrumentDescriptor = instrumentDescriptor;
+  }
+  getInstrumentDescriptor() {
+    return this._instrumentDescriptor;
+  }
+  updateDescription(description) {
+    this._instrumentDescriptor = createInstrumentDescriptor(this._instrumentDescriptor.name, this._instrumentDescriptor.type, {
+      description,
+      valueType: this._instrumentDescriptor.valueType,
+      unit: this._instrumentDescriptor.unit,
+      advice: this._instrumentDescriptor.advice
+    });
+  }
+}
+var init_MetricStorage = __esm(() => {
+  init_InstrumentDescriptor();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/HashMap.js
+class HashMap {
+  _valueMap = new Map;
+  _keyMap = new Map;
+  _hash;
+  constructor(hash) {
+    this._hash = hash;
+  }
+  get(key, hashCode) {
+    hashCode ??= this._hash(key);
+    return this._valueMap.get(hashCode);
+  }
+  getOrDefault(key, defaultFactory) {
+    const hash = this._hash(key);
+    if (this._valueMap.has(hash)) {
+      return this._valueMap.get(hash);
+    }
+    const val = defaultFactory();
+    if (!this._keyMap.has(hash)) {
+      this._keyMap.set(hash, key);
+    }
+    this._valueMap.set(hash, val);
+    return val;
+  }
+  set(key, value, hashCode) {
+    hashCode ??= this._hash(key);
+    if (!this._keyMap.has(hashCode)) {
+      this._keyMap.set(hashCode, key);
+    }
+    this._valueMap.set(hashCode, value);
+  }
+  has(key, hashCode) {
+    hashCode ??= this._hash(key);
+    return this._valueMap.has(hashCode);
+  }
+  *keys() {
+    const keyIterator = this._keyMap.entries();
+    let next = keyIterator.next();
+    while (next.done !== true) {
+      yield [next.value[1], next.value[0]];
+      next = keyIterator.next();
+    }
+  }
+  *entries() {
+    const valueIterator = this._valueMap.entries();
+    let next = valueIterator.next();
+    while (next.done !== true) {
+      yield [this._keyMap.get(next.value[0]), next.value[1], next.value[0]];
+      next = valueIterator.next();
+    }
+  }
+  get size() {
+    return this._valueMap.size;
+  }
+}
+var AttributeHashMap;
+var init_HashMap = __esm(() => {
+  init_utils();
+  AttributeHashMap = class AttributeHashMap extends HashMap {
+    constructor() {
+      super(hashAttributes);
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/DeltaMetricProcessor.js
+class DeltaMetricProcessor {
+  _activeCollectionStorage = new AttributeHashMap;
+  _cumulativeMemoStorage = new AttributeHashMap;
+  _cardinalityLimit;
+  _overflowAttributes = { "otel.metric.overflow": true };
+  _overflowHashCode;
+  _aggregator;
+  constructor(aggregator, aggregationCardinalityLimit) {
+    this._aggregator = aggregator;
+    this._cardinalityLimit = (aggregationCardinalityLimit ?? 2000) - 1;
+    this._overflowHashCode = hashAttributes(this._overflowAttributes);
+  }
+  record(value, attributes, _context, collectionTime) {
+    let accumulation = this._activeCollectionStorage.get(attributes);
+    if (!accumulation) {
+      if (this._activeCollectionStorage.size >= this._cardinalityLimit) {
+        const overflowAccumulation = this._activeCollectionStorage.getOrDefault(this._overflowAttributes, () => this._aggregator.createAccumulation(collectionTime));
+        overflowAccumulation?.record(value);
+        return;
+      }
+      accumulation = this._aggregator.createAccumulation(collectionTime);
+      this._activeCollectionStorage.set(attributes, accumulation);
+    }
+    accumulation?.record(value);
+  }
+  batchCumulate(measurements, collectionTime) {
+    Array.from(measurements.entries()).forEach(([attributes, value, hashCode]) => {
+      const accumulation = this._aggregator.createAccumulation(collectionTime);
+      accumulation?.record(value);
+      let delta = accumulation;
+      if (this._cumulativeMemoStorage.has(attributes, hashCode)) {
+        const previous = this._cumulativeMemoStorage.get(attributes, hashCode);
+        delta = this._aggregator.diff(previous, accumulation);
+      } else {
+        if (this._cumulativeMemoStorage.size >= this._cardinalityLimit) {
+          attributes = this._overflowAttributes;
+          hashCode = this._overflowHashCode;
+          if (this._cumulativeMemoStorage.has(attributes, hashCode)) {
+            const previous = this._cumulativeMemoStorage.get(attributes, hashCode);
+            delta = this._aggregator.diff(previous, accumulation);
+          }
+        }
+      }
+      if (this._activeCollectionStorage.has(attributes, hashCode)) {
+        const active = this._activeCollectionStorage.get(attributes, hashCode);
+        delta = this._aggregator.merge(active, delta);
+      }
+      this._cumulativeMemoStorage.set(attributes, accumulation, hashCode);
+      this._activeCollectionStorage.set(attributes, delta, hashCode);
+    });
+  }
+  collect() {
+    const unreportedDelta = this._activeCollectionStorage;
+    this._activeCollectionStorage = new AttributeHashMap;
+    return unreportedDelta;
+  }
+}
+var init_DeltaMetricProcessor = __esm(() => {
+  init_utils();
+  init_HashMap();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/TemporalMetricProcessor.js
+class TemporalMetricProcessor {
+  _aggregator;
+  _unreportedAccumulations = new Map;
+  _reportHistory = new Map;
+  constructor(aggregator, collectorHandles) {
+    this._aggregator = aggregator;
+    collectorHandles.forEach((handle) => {
+      this._unreportedAccumulations.set(handle, []);
+    });
+  }
+  buildMetrics(collector, instrumentDescriptor, currentAccumulations, collectionTime) {
+    this._stashAccumulations(currentAccumulations);
+    const unreportedAccumulations = this._getMergedUnreportedAccumulations(collector);
+    let result = unreportedAccumulations;
+    let aggregationTemporality;
+    if (this._reportHistory.has(collector)) {
+      const last = this._reportHistory.get(collector);
+      const lastCollectionTime = last.collectionTime;
+      aggregationTemporality = last.aggregationTemporality;
+      if (aggregationTemporality === AggregationTemporality.CUMULATIVE) {
+        result = TemporalMetricProcessor.merge(last.accumulations, unreportedAccumulations, this._aggregator);
+      } else {
+        result = TemporalMetricProcessor.calibrateStartTime(last.accumulations, unreportedAccumulations, lastCollectionTime);
+      }
+    } else {
+      aggregationTemporality = collector.selectAggregationTemporality(instrumentDescriptor.type);
+    }
+    this._reportHistory.set(collector, {
+      accumulations: result,
+      collectionTime,
+      aggregationTemporality
+    });
+    const accumulationRecords = AttributesMapToAccumulationRecords(result);
+    if (accumulationRecords.length === 0) {
+      return;
+    }
+    return this._aggregator.toMetricData(instrumentDescriptor, aggregationTemporality, accumulationRecords, collectionTime);
+  }
+  _stashAccumulations(currentAccumulation) {
+    const registeredCollectors = this._unreportedAccumulations.keys();
+    for (const collector of registeredCollectors) {
+      let stash = this._unreportedAccumulations.get(collector);
+      if (stash === undefined) {
+        stash = [];
+        this._unreportedAccumulations.set(collector, stash);
+      }
+      stash.push(currentAccumulation);
+    }
+  }
+  _getMergedUnreportedAccumulations(collector) {
+    let result = new AttributeHashMap;
+    const unreportedList = this._unreportedAccumulations.get(collector);
+    this._unreportedAccumulations.set(collector, []);
+    if (unreportedList === undefined) {
+      return result;
+    }
+    for (const it of unreportedList) {
+      result = TemporalMetricProcessor.merge(result, it, this._aggregator);
+    }
+    return result;
+  }
+  static merge(last, current, aggregator) {
+    const result = last;
+    const iterator = current.entries();
+    let next = iterator.next();
+    while (next.done !== true) {
+      const [key, record, hash] = next.value;
+      if (last.has(key, hash)) {
+        const lastAccumulation = last.get(key, hash);
+        const accumulation = aggregator.merge(lastAccumulation, record);
+        result.set(key, accumulation, hash);
+      } else {
+        result.set(key, record, hash);
+      }
+      next = iterator.next();
+    }
+    return result;
+  }
+  static calibrateStartTime(last, current, lastCollectionTime) {
+    for (const [key, hash] of last.keys()) {
+      const currentAccumulation = current.get(key, hash);
+      currentAccumulation?.setStartTime(lastCollectionTime);
+    }
+    return current;
+  }
+}
+function AttributesMapToAccumulationRecords(map) {
+  return Array.from(map.entries());
+}
+var init_TemporalMetricProcessor = __esm(() => {
+  init_AggregationTemporality();
+  init_HashMap();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/AsyncMetricStorage.js
+var AsyncMetricStorage;
+var init_AsyncMetricStorage = __esm(() => {
+  init_MetricStorage();
+  init_DeltaMetricProcessor();
+  init_TemporalMetricProcessor();
+  init_HashMap();
+  AsyncMetricStorage = class AsyncMetricStorage extends MetricStorage {
+    _aggregationCardinalityLimit;
+    _deltaMetricStorage;
+    _temporalMetricStorage;
+    _attributesProcessor;
+    constructor(_instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) {
+      super(_instrumentDescriptor);
+      this._aggregationCardinalityLimit = aggregationCardinalityLimit;
+      this._deltaMetricStorage = new DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit);
+      this._temporalMetricStorage = new TemporalMetricProcessor(aggregator, collectorHandles);
+      this._attributesProcessor = attributesProcessor;
+    }
+    record(measurements, observationTime) {
+      const processed = new AttributeHashMap;
+      Array.from(measurements.entries()).forEach(([attributes, value]) => {
+        processed.set(this._attributesProcessor.process(attributes), value);
+      });
+      this._deltaMetricStorage.batchCumulate(processed, observationTime);
+    }
+    collect(collector, collectionTime) {
+      const accumulations = this._deltaMetricStorage.collect();
+      return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/RegistrationConflicts.js
+function getIncompatibilityDetails(existing, otherDescriptor) {
+  let incompatibility = "";
+  if (existing.unit !== otherDescriptor.unit) {
+    incompatibility += `	- Unit '${existing.unit}' does not match '${otherDescriptor.unit}'
+`;
+  }
+  if (existing.type !== otherDescriptor.type) {
+    incompatibility += `	- Type '${existing.type}' does not match '${otherDescriptor.type}'
+`;
+  }
+  if (existing.valueType !== otherDescriptor.valueType) {
+    incompatibility += `	- Value Type '${existing.valueType}' does not match '${otherDescriptor.valueType}'
+`;
+  }
+  if (existing.description !== otherDescriptor.description) {
+    incompatibility += `	- Description '${existing.description}' does not match '${otherDescriptor.description}'
+`;
+  }
+  return incompatibility;
+}
+function getValueTypeConflictResolutionRecipe(existing, otherDescriptor) {
+  return `	- use valueType '${existing.valueType}' on instrument creation or use an instrument name other than '${otherDescriptor.name}'`;
+}
+function getUnitConflictResolutionRecipe(existing, otherDescriptor) {
+  return `	- use unit '${existing.unit}' on instrument creation or use an instrument name other than '${otherDescriptor.name}'`;
+}
+function getTypeConflictResolutionRecipe(existing, otherDescriptor) {
+  const selector = {
+    name: otherDescriptor.name,
+    type: otherDescriptor.type,
+    unit: otherDescriptor.unit
+  };
+  const selectorString = JSON.stringify(selector);
+  return `	- create a new view with a name other than '${existing.name}' and InstrumentSelector '${selectorString}'`;
+}
+function getDescriptionResolutionRecipe(existing, otherDescriptor) {
+  const selector = {
+    name: otherDescriptor.name,
+    type: otherDescriptor.type,
+    unit: otherDescriptor.unit
+  };
+  const selectorString = JSON.stringify(selector);
+  return `	- create a new view with a name other than '${existing.name}' and InstrumentSelector '${selectorString}'
+    	- OR - create a new view with the name ${existing.name} and description '${existing.description}' and InstrumentSelector ${selectorString}
+    	- OR - create a new view with the name ${otherDescriptor.name} and description '${existing.description}' and InstrumentSelector ${selectorString}`;
+}
+function getConflictResolutionRecipe(existing, otherDescriptor) {
+  if (existing.valueType !== otherDescriptor.valueType) {
+    return getValueTypeConflictResolutionRecipe(existing, otherDescriptor);
+  }
+  if (existing.unit !== otherDescriptor.unit) {
+    return getUnitConflictResolutionRecipe(existing, otherDescriptor);
+  }
+  if (existing.type !== otherDescriptor.type) {
+    return getTypeConflictResolutionRecipe(existing, otherDescriptor);
+  }
+  if (existing.description !== otherDescriptor.description) {
+    return getDescriptionResolutionRecipe(existing, otherDescriptor);
+  }
+  return "";
+}
+var init_RegistrationConflicts = () => {};
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MetricStorageRegistry.js
+class MetricStorageRegistry {
+  _sharedRegistry = new Map;
+  _perCollectorRegistry = new Map;
+  static create() {
+    return new MetricStorageRegistry;
+  }
+  getStorages(collector) {
+    let storages = [];
+    for (const metricStorages of this._sharedRegistry.values()) {
+      storages = storages.concat(metricStorages);
+    }
+    const perCollectorStorages = this._perCollectorRegistry.get(collector);
+    if (perCollectorStorages != null) {
+      for (const metricStorages of perCollectorStorages.values()) {
+        storages = storages.concat(metricStorages);
+      }
+    }
+    return storages;
+  }
+  register(storage) {
+    this._registerStorage(storage, this._sharedRegistry);
+  }
+  registerForCollector(collector, storage) {
+    let storageMap = this._perCollectorRegistry.get(collector);
+    if (storageMap == null) {
+      storageMap = new Map;
+      this._perCollectorRegistry.set(collector, storageMap);
+    }
+    this._registerStorage(storage, storageMap);
+  }
+  findOrUpdateCompatibleStorage(expectedDescriptor) {
+    const storages = this._sharedRegistry.get(expectedDescriptor.name);
+    if (storages === undefined) {
+      return null;
+    }
+    return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages);
+  }
+  findOrUpdateCompatibleCollectorStorage(collector, expectedDescriptor) {
+    const storageMap = this._perCollectorRegistry.get(collector);
+    if (storageMap === undefined) {
+      return null;
+    }
+    const storages = storageMap.get(expectedDescriptor.name);
+    if (storages === undefined) {
+      return null;
+    }
+    return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages);
+  }
+  _registerStorage(storage, storageMap) {
+    const descriptor = storage.getInstrumentDescriptor();
+    const storages = storageMap.get(descriptor.name);
+    if (storages === undefined) {
+      storageMap.set(descriptor.name, [storage]);
+      return;
+    }
+    storages.push(storage);
+  }
+  _findOrUpdateCompatibleStorage(expectedDescriptor, existingStorages) {
+    let compatibleStorage = null;
+    for (const existingStorage of existingStorages) {
+      const existingDescriptor = existingStorage.getInstrumentDescriptor();
+      if (isDescriptorCompatibleWith(existingDescriptor, expectedDescriptor)) {
+        if (existingDescriptor.description !== expectedDescriptor.description) {
+          if (expectedDescriptor.description.length > existingDescriptor.description.length) {
+            existingStorage.updateDescription(expectedDescriptor.description);
+          }
+          api4.diag.warn("A view or instrument with the name ", expectedDescriptor.name, ` has already been registered, but has a different description and is incompatible with another registered view.
+`, `Details:
+`, getIncompatibilityDetails(existingDescriptor, expectedDescriptor), `The longer description will be used.
+To resolve the conflict:`, getConflictResolutionRecipe(existingDescriptor, expectedDescriptor));
+        }
+        compatibleStorage = existingStorage;
+      } else {
+        api4.diag.warn("A view or instrument with the name ", expectedDescriptor.name, ` has already been registered and is incompatible with another registered view.
+`, `Details:
+`, getIncompatibilityDetails(existingDescriptor, expectedDescriptor), `To resolve the conflict:
+`, getConflictResolutionRecipe(existingDescriptor, expectedDescriptor));
+      }
+    }
+    return compatibleStorage;
+  }
+}
+var api4;
+var init_MetricStorageRegistry = __esm(() => {
+  init_InstrumentDescriptor();
+  init_RegistrationConflicts();
+  api4 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MultiWritableMetricStorage.js
+class MultiMetricStorage {
+  _backingStorages;
+  constructor(backingStorages) {
+    this._backingStorages = backingStorages;
+  }
+  record(value, attributes, context, recordTime) {
+    this._backingStorages.forEach((it) => {
+      it.record(value, attributes, context, recordTime);
+    });
+  }
+}
+var init_MultiWritableMetricStorage = () => {};
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/ObservableResult.js
+class ObservableResultImpl {
+  _buffer = new AttributeHashMap;
+  _instrumentName;
+  _valueType;
+  constructor(instrumentName, valueType) {
+    this._instrumentName = instrumentName;
+    this._valueType = valueType;
+  }
+  observe(value, attributes = {}) {
+    if (typeof value !== "number") {
+      import_api4.diag.warn(`non-number value provided to metric ${this._instrumentName}: ${value}`);
+      return;
+    }
+    if (this._valueType === import_api4.ValueType.INT && !Number.isInteger(value)) {
+      import_api4.diag.warn(`INT value type cannot accept a floating-point value for ${this._instrumentName}, ignoring the fractional digits.`);
+      value = Math.trunc(value);
+      if (!Number.isInteger(value)) {
+        return;
+      }
+    }
+    this._buffer.set(attributes, value);
+  }
+}
+
+class BatchObservableResultImpl {
+  _buffer = new Map;
+  observe(metric, value, attributes = {}) {
+    if (!isObservableInstrument(metric)) {
+      return;
+    }
+    let map = this._buffer.get(metric);
+    if (map == null) {
+      map = new AttributeHashMap;
+      this._buffer.set(metric, map);
+    }
+    if (typeof value !== "number") {
+      import_api4.diag.warn(`non-number value provided to metric ${metric._descriptor.name}: ${value}`);
+      return;
+    }
+    if (metric._descriptor.valueType === import_api4.ValueType.INT && !Number.isInteger(value)) {
+      import_api4.diag.warn(`INT value type cannot accept a floating-point value for ${metric._descriptor.name}, ignoring the fractional digits.`);
+      value = Math.trunc(value);
+      if (!Number.isInteger(value)) {
+        return;
+      }
+    }
+    map.set(attributes, value);
+  }
+}
+var import_api4;
+var init_ObservableResult = __esm(() => {
+  init_HashMap();
+  init_Instruments();
+  import_api4 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/ObservableRegistry.js
+class ObservableRegistry {
+  _callbacks = [];
+  _batchCallbacks = [];
+  addCallback(callback, instrument) {
+    const idx = this._findCallback(callback, instrument);
+    if (idx >= 0) {
+      return;
+    }
+    this._callbacks.push({ callback, instrument });
+  }
+  removeCallback(callback, instrument) {
+    const idx = this._findCallback(callback, instrument);
+    if (idx < 0) {
+      return;
+    }
+    this._callbacks.splice(idx, 1);
+  }
+  addBatchCallback(callback, instruments) {
+    const observableInstruments = new Set(instruments.filter(isObservableInstrument));
+    if (observableInstruments.size === 0) {
+      import_api5.diag.error("BatchObservableCallback is not associated with valid instruments", instruments);
+      return;
+    }
+    const idx = this._findBatchCallback(callback, observableInstruments);
+    if (idx >= 0) {
+      return;
+    }
+    this._batchCallbacks.push({ callback, instruments: observableInstruments });
+  }
+  removeBatchCallback(callback, instruments) {
+    const observableInstruments = new Set(instruments.filter(isObservableInstrument));
+    const idx = this._findBatchCallback(callback, observableInstruments);
+    if (idx < 0) {
+      return;
+    }
+    this._batchCallbacks.splice(idx, 1);
+  }
+  async observe(collectionTime, timeoutMillis) {
+    const callbackFutures = this._observeCallbacks(collectionTime, timeoutMillis);
+    const batchCallbackFutures = this._observeBatchCallbacks(collectionTime, timeoutMillis);
+    const results = await Promise.allSettled([
+      ...callbackFutures,
+      ...batchCallbackFutures
+    ]);
+    const rejections = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    return rejections;
+  }
+  _observeCallbacks(observationTime, timeoutMillis) {
+    return this._callbacks.map(async ({ callback, instrument }) => {
+      const observableResult = new ObservableResultImpl(instrument._descriptor.name, instrument._descriptor.valueType);
+      let callPromise = Promise.resolve(callback(observableResult));
+      if (timeoutMillis != null) {
+        callPromise = callWithTimeout(callPromise, timeoutMillis);
+      }
+      await callPromise;
+      instrument._metricStorages.forEach((metricStorage) => {
+        metricStorage.record(observableResult._buffer, observationTime);
+      });
+    });
+  }
+  _observeBatchCallbacks(observationTime, timeoutMillis) {
+    return this._batchCallbacks.map(async ({ callback, instruments }) => {
+      const observableResult = new BatchObservableResultImpl;
+      let callPromise = Promise.resolve(callback(observableResult));
+      if (timeoutMillis != null) {
+        callPromise = callWithTimeout(callPromise, timeoutMillis);
+      }
+      await callPromise;
+      instruments.forEach((instrument) => {
+        const buffer = observableResult._buffer.get(instrument);
+        if (buffer == null) {
+          return;
+        }
+        instrument._metricStorages.forEach((metricStorage) => {
+          metricStorage.record(buffer, observationTime);
+        });
+      });
+    });
+  }
+  _findCallback(callback, instrument) {
+    return this._callbacks.findIndex((record) => {
+      return record.callback === callback && record.instrument === instrument;
+    });
+  }
+  _findBatchCallback(callback, instruments) {
+    return this._batchCallbacks.findIndex((record) => {
+      return record.callback === callback && setEquals(record.instruments, instruments);
+    });
+  }
+}
+var import_api5;
+var init_ObservableRegistry = __esm(() => {
+  init_Instruments();
+  init_ObservableResult();
+  init_utils();
+  import_api5 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/SyncMetricStorage.js
+var SyncMetricStorage;
+var init_SyncMetricStorage = __esm(() => {
+  init_MetricStorage();
+  init_DeltaMetricProcessor();
+  init_TemporalMetricProcessor();
+  SyncMetricStorage = class SyncMetricStorage extends MetricStorage {
+    _aggregationCardinalityLimit;
+    _deltaMetricStorage;
+    _temporalMetricStorage;
+    _attributesProcessor;
+    constructor(instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) {
+      super(instrumentDescriptor);
+      this._aggregationCardinalityLimit = aggregationCardinalityLimit;
+      this._deltaMetricStorage = new DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit);
+      this._temporalMetricStorage = new TemporalMetricProcessor(aggregator, collectorHandles);
+      this._attributesProcessor = attributesProcessor;
+    }
+    record(value, attributes, context, recordTime) {
+      attributes = this._attributesProcessor.process(attributes, context);
+      this._deltaMetricStorage.record(value, attributes, context, recordTime);
+    }
+    collect(collector, collectionTime) {
+      const accumulations = this._deltaMetricStorage.collect();
+      return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/AttributesProcessor.js
+class NoopAttributesProcessor {
+  process(incoming, _context) {
+    return incoming;
+  }
+}
+
+class MultiAttributesProcessor {
+  _processors;
+  constructor(processors) {
+    this._processors = processors;
+  }
+  process(incoming, context) {
+    let filteredAttributes = incoming;
+    for (const processor of this._processors) {
+      filteredAttributes = processor.process(filteredAttributes, context);
+    }
+    return filteredAttributes;
+  }
+}
+function createNoopAttributesProcessor() {
+  return NOOP;
+}
+function createMultiAttributesProcessor(processors) {
+  return new MultiAttributesProcessor(processors);
+}
+var NOOP;
+var init_AttributesProcessor = __esm(() => {
+  NOOP = new NoopAttributesProcessor;
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MeterSharedState.js
+class MeterSharedState {
+  metricStorageRegistry = new MetricStorageRegistry;
+  observableRegistry = new ObservableRegistry;
+  meter;
+  _meterProviderSharedState;
+  _instrumentationScope;
+  constructor(meterProviderSharedState, instrumentationScope) {
+    this.meter = new Meter(this);
+    this._meterProviderSharedState = meterProviderSharedState;
+    this._instrumentationScope = instrumentationScope;
+  }
+  registerMetricStorage(descriptor) {
+    const storages = this._registerMetricStorage(descriptor, SyncMetricStorage);
+    if (storages.length === 1) {
+      return storages[0];
+    }
+    return new MultiMetricStorage(storages);
+  }
+  registerAsyncMetricStorage(descriptor) {
+    const storages = this._registerMetricStorage(descriptor, AsyncMetricStorage);
+    return storages;
+  }
+  async collect(collector, collectionTime, options) {
+    const errors = await this.observableRegistry.observe(collectionTime, options?.timeoutMillis);
+    const storages = this.metricStorageRegistry.getStorages(collector);
+    if (storages.length === 0) {
+      return null;
+    }
+    const metricDataList = [];
+    storages.forEach((metricStorage) => {
+      const metricData = metricStorage.collect(collector, collectionTime);
+      if (metricData != null) {
+        metricDataList.push(metricData);
+      }
+    });
+    if (metricDataList.length === 0) {
+      return { errors };
+    }
+    return {
+      scopeMetrics: {
+        scope: this._instrumentationScope,
+        metrics: metricDataList
+      },
+      errors
+    };
+  }
+  _registerMetricStorage(descriptor, MetricStorageType) {
+    const views = this._meterProviderSharedState.viewRegistry.findViews(descriptor, this._instrumentationScope);
+    let storages = views.map((view) => {
+      const viewDescriptor = createInstrumentDescriptorWithView(view, descriptor);
+      const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleStorage(viewDescriptor);
+      if (compatibleStorage != null) {
+        return compatibleStorage;
+      }
+      const aggregator = view.aggregation.createAggregator(viewDescriptor);
+      const viewStorage = new MetricStorageType(viewDescriptor, aggregator, view.attributesProcessor, this._meterProviderSharedState.metricCollectors, view.aggregationCardinalityLimit);
+      this.metricStorageRegistry.register(viewStorage);
+      return viewStorage;
+    });
+    if (storages.length === 0) {
+      const perCollectorAggregations = this._meterProviderSharedState.selectAggregations(descriptor.type);
+      const collectorStorages = perCollectorAggregations.map(([collector, aggregation]) => {
+        const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleCollectorStorage(collector, descriptor);
+        if (compatibleStorage != null) {
+          return compatibleStorage;
+        }
+        const aggregator = aggregation.createAggregator(descriptor);
+        const cardinalityLimit = collector.selectCardinalityLimit(descriptor.type);
+        const storage = new MetricStorageType(descriptor, aggregator, createNoopAttributesProcessor(), [collector], cardinalityLimit);
+        this.metricStorageRegistry.registerForCollector(collector, storage);
+        return storage;
+      });
+      storages = storages.concat(collectorStorages);
+    }
+    return storages;
+  }
+}
+var init_MeterSharedState = __esm(() => {
+  init_InstrumentDescriptor();
+  init_Meter();
+  init_AsyncMetricStorage();
+  init_MetricStorageRegistry();
+  init_MultiWritableMetricStorage();
+  init_ObservableRegistry();
+  init_SyncMetricStorage();
+  init_AttributesProcessor();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MeterProviderSharedState.js
+class MeterProviderSharedState {
+  viewRegistry = new ViewRegistry;
+  metricCollectors = [];
+  meterSharedStates = new Map;
+  resource;
+  constructor(resource) {
+    this.resource = resource;
+  }
+  getMeterSharedState(instrumentationScope) {
+    const id = instrumentationScopeId(instrumentationScope);
+    let meterSharedState = this.meterSharedStates.get(id);
+    if (meterSharedState == null) {
+      meterSharedState = new MeterSharedState(this, instrumentationScope);
+      this.meterSharedStates.set(id, meterSharedState);
+    }
+    return meterSharedState;
+  }
+  selectAggregations(instrumentType) {
+    const result = [];
+    for (const collector of this.metricCollectors) {
+      result.push([
+        collector,
+        toAggregation(collector.selectAggregation(instrumentType))
+      ]);
+    }
+    return result;
+  }
+}
+var init_MeterProviderSharedState = __esm(() => {
+  init_utils();
+  init_ViewRegistry();
+  init_MeterSharedState();
+  init_AggregationOption();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MetricCollector.js
+class MetricCollector {
+  _sharedState;
+  _metricReader;
+  constructor(sharedState, metricReader) {
+    this._sharedState = sharedState;
+    this._metricReader = metricReader;
+  }
+  async collect(options) {
+    const collectionTime = millisToHrTime(Date.now());
+    const scopeMetrics = [];
+    const errors = [];
+    const meterCollectionPromises = Array.from(this._sharedState.meterSharedStates.values()).map(async (meterSharedState) => {
+      const current = await meterSharedState.collect(this, collectionTime, options);
+      if (current?.scopeMetrics != null) {
+        scopeMetrics.push(current.scopeMetrics);
+      }
+      if (current?.errors != null) {
+        errors.push(...current.errors);
+      }
+    });
+    await Promise.all(meterCollectionPromises);
+    return {
+      resourceMetrics: {
+        resource: this._sharedState.resource,
+        scopeMetrics
+      },
+      errors
+    };
+  }
+  async forceFlush(options) {
+    await this._metricReader.forceFlush(options);
+  }
+  async shutdown(options) {
+    await this._metricReader.shutdown(options);
+  }
+  selectAggregationTemporality(instrumentType) {
+    return this._metricReader.selectAggregationTemporality(instrumentType);
+  }
+  selectAggregation(instrumentType) {
+    return this._metricReader.selectAggregation(instrumentType);
+  }
+  selectCardinalityLimit(instrumentType) {
+    return this._metricReader.selectCardinalityLimit?.(instrumentType) ?? 2000;
+  }
+}
+var init_MetricCollector = __esm(() => {
+  init_esm();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/Predicate.js
+class PatternPredicate {
+  _matchAll;
+  _regexp;
+  constructor(pattern) {
+    if (pattern === "*") {
+      this._matchAll = true;
+      this._regexp = /.*/;
+    } else {
+      this._matchAll = false;
+      this._regexp = new RegExp(PatternPredicate.escapePattern(pattern));
+    }
+  }
+  match(str) {
+    if (this._matchAll) {
+      return true;
+    }
+    return this._regexp.test(str);
+  }
+  static escapePattern(pattern) {
+    return `^${pattern.replace(ESCAPE, "\\$&").replace("*", ".*")}$`;
+  }
+  static hasWildcard(pattern) {
+    return pattern.includes("*");
+  }
+}
+
+class ExactPredicate {
+  _matchAll;
+  _pattern;
+  constructor(pattern) {
+    this._matchAll = pattern === undefined;
+    this._pattern = pattern;
+  }
+  match(str) {
+    if (this._matchAll) {
+      return true;
+    }
+    if (str === this._pattern) {
+      return true;
+    }
+    return false;
+  }
+}
+var ESCAPE;
+var init_Predicate = __esm(() => {
+  ESCAPE = /[\^$\\.+?()[\]{}|]/g;
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/InstrumentSelector.js
+class InstrumentSelector {
+  _nameFilter;
+  _type;
+  _unitFilter;
+  constructor(criteria) {
+    this._nameFilter = new PatternPredicate(criteria?.name ?? "*");
+    this._type = criteria?.type;
+    this._unitFilter = new ExactPredicate(criteria?.unit);
+  }
+  getType() {
+    return this._type;
+  }
+  getNameFilter() {
+    return this._nameFilter;
+  }
+  getUnitFilter() {
+    return this._unitFilter;
+  }
+}
+var init_InstrumentSelector = __esm(() => {
+  init_Predicate();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/MeterSelector.js
+class MeterSelector {
+  _nameFilter;
+  _versionFilter;
+  _schemaUrlFilter;
+  constructor(criteria) {
+    this._nameFilter = new ExactPredicate(criteria?.name);
+    this._versionFilter = new ExactPredicate(criteria?.version);
+    this._schemaUrlFilter = new ExactPredicate(criteria?.schemaUrl);
+  }
+  getNameFilter() {
+    return this._nameFilter;
+  }
+  getVersionFilter() {
+    return this._versionFilter;
+  }
+  getSchemaUrlFilter() {
+    return this._schemaUrlFilter;
+  }
+}
+var init_MeterSelector = __esm(() => {
+  init_Predicate();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/view/View.js
+function isSelectorNotProvided(options) {
+  return options.instrumentName == null && options.instrumentType == null && options.instrumentUnit == null && options.meterName == null && options.meterVersion == null && options.meterSchemaUrl == null;
+}
+function validateViewOptions(viewOptions) {
+  if (isSelectorNotProvided(viewOptions)) {
+    throw new Error("Cannot create view with no selector arguments supplied");
+  }
+  if (viewOptions.name != null && (viewOptions?.instrumentName == null || PatternPredicate.hasWildcard(viewOptions.instrumentName))) {
+    throw new Error("Views with a specified name must be declared with an instrument selector that selects at most one instrument per meter.");
+  }
+}
+
+class View {
+  name;
+  description;
+  aggregation;
+  attributesProcessor;
+  instrumentSelector;
+  meterSelector;
+  aggregationCardinalityLimit;
+  constructor(viewOptions) {
+    validateViewOptions(viewOptions);
+    if (viewOptions.attributesProcessors != null) {
+      this.attributesProcessor = createMultiAttributesProcessor(viewOptions.attributesProcessors);
+    } else {
+      this.attributesProcessor = createNoopAttributesProcessor();
+    }
+    this.name = viewOptions.name;
+    this.description = viewOptions.description;
+    this.aggregation = toAggregation(viewOptions.aggregation ?? { type: AggregationType.DEFAULT });
+    this.instrumentSelector = new InstrumentSelector({
+      name: viewOptions.instrumentName,
+      type: viewOptions.instrumentType,
+      unit: viewOptions.instrumentUnit
+    });
+    this.meterSelector = new MeterSelector({
+      name: viewOptions.meterName,
+      version: viewOptions.meterVersion,
+      schemaUrl: viewOptions.meterSchemaUrl
+    });
+    this.aggregationCardinalityLimit = viewOptions.aggregationCardinalityLimit;
+  }
+}
+var init_View = __esm(() => {
+  init_Predicate();
+  init_AttributesProcessor();
+  init_InstrumentSelector();
+  init_MeterSelector();
+  init_AggregationOption();
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/MeterProvider.js
+class MeterProvider {
+  _sharedState;
+  _shutdown = false;
+  constructor(options) {
+    this._sharedState = new MeterProviderSharedState(options?.resource ?? defaultResource());
+    if (options?.views != null && options.views.length > 0) {
+      for (const viewOption of options.views) {
+        this._sharedState.viewRegistry.addView(new View(viewOption));
+      }
+    }
+    if (options?.readers != null && options.readers.length > 0) {
+      for (const metricReader of options.readers) {
+        const collector = new MetricCollector(this._sharedState, metricReader);
+        metricReader.setMetricProducer(collector);
+        this._sharedState.metricCollectors.push(collector);
+      }
+    }
+  }
+  getMeter(name, version = "", options = {}) {
+    if (this._shutdown) {
+      import_api6.diag.warn("A shutdown MeterProvider cannot provide a Meter");
+      return import_api6.createNoopMeter();
+    }
+    return this._sharedState.getMeterSharedState({
+      name,
+      version,
+      schemaUrl: options.schemaUrl
+    }).meter;
+  }
+  async shutdown(options) {
+    if (this._shutdown) {
+      import_api6.diag.warn("shutdown may only be called once per MeterProvider");
+      return;
+    }
+    this._shutdown = true;
+    await Promise.all(this._sharedState.metricCollectors.map((collector) => {
+      return collector.shutdown(options);
+    }));
+  }
+  async forceFlush(options) {
+    if (this._shutdown) {
+      import_api6.diag.warn("invalid attempt to force flush after MeterProvider shutdown");
+      return;
+    }
+    await Promise.all(this._sharedState.metricCollectors.map((collector) => {
+      return collector.forceFlush(options);
+    }));
+  }
+}
+var import_api6;
+var init_MeterProvider = __esm(() => {
+  init_esm2();
+  init_MeterProviderSharedState();
+  init_MetricCollector();
+  init_View();
+  import_api6 = __toESM(require_src(), 1);
+});
+
+// node_modules/.bun/@opentelemetry+sdk-metrics@2.7.0+e40b0dfdd726a224/node_modules/@opentelemetry/sdk-metrics/build/esm/index.js
+var init_esm5 = __esm(() => {
+  init_AggregationTemporality();
+  init_PeriodicExportingMetricReader();
+  init_ConsoleMetricExporter();
+  init_MeterProvider();
+});
+
+// src/services/api/metricsOptOut.ts
+async function _fetchMetricsEnabled() {
+  const authResult = getAuthHeaders();
+  if (authResult.error) {
+    throw new Error(`Auth error: ${authResult.error}`);
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": getClaudeCodeUserAgent(),
+    ...authResult.headers
+  };
+  const endpoint = `https://api.anthropic.com/api/claude_code/organizations/metrics_enabled`;
+  const response = await axios_default.get(endpoint, {
+    headers,
+    timeout: 5000
+  });
+  return response.data;
+}
+async function _checkMetricsEnabledAPI() {
+  if (isEssentialTrafficOnly()) {
+    return { enabled: false, hasError: false };
+  }
+  try {
+    const data = await withOAuth401Retry(_fetchMetricsEnabled, {
+      also403Revoked: true
+    });
+    logForDebugging(`Metrics opt-out API response: enabled=${data.metrics_logging_enabled}`);
+    return {
+      enabled: data.metrics_logging_enabled,
+      hasError: false
+    };
+  } catch (error) {
+    logForDebugging(`Failed to check metrics opt-out status: ${errorMessage(error)}`);
+    logError(error);
+    return { enabled: false, hasError: true };
+  }
+}
+async function refreshMetricsStatus() {
+  const result = await memoizedCheckMetrics();
+  if (result.hasError) {
+    return result;
+  }
+  const cached = getGlobalConfig().metricsStatusCache;
+  const unchanged = cached !== undefined && cached.enabled === result.enabled;
+  if (unchanged && Date.now() - cached.timestamp < DISK_CACHE_TTL_MS) {
+    return result;
+  }
+  saveGlobalConfig((current) => ({
+    ...current,
+    metricsStatusCache: {
+      enabled: result.enabled,
+      timestamp: Date.now()
+    }
+  }));
+  return result;
+}
+async function checkMetricsEnabled() {
+  if (isClaudeAISubscriber() && !hasProfileScope()) {
+    return { enabled: false, hasError: false };
+  }
+  const cached = getGlobalConfig().metricsStatusCache;
+  if (cached) {
+    if (Date.now() - cached.timestamp > DISK_CACHE_TTL_MS) {
+      refreshMetricsStatus().catch(logError);
+    }
+    return {
+      enabled: cached.enabled,
+      hasError: false
+    };
+  }
+  return refreshMetricsStatus();
+}
+var CACHE_TTL_MS, DISK_CACHE_TTL_MS, memoizedCheckMetrics;
+var init_metricsOptOut = __esm(() => {
+  init_axios();
+  init_auth();
+  init_config();
+  init_debug();
+  init_errors();
+  init_http();
+  init_log();
+  init_memoize();
+  init_privacyLevel();
+  init_userAgent();
+  CACHE_TTL_MS = 60 * 60 * 1000;
+  DISK_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+  memoizedCheckMetrics = memoizeWithTTLAsync(_checkMetricsEnabledAPI, CACHE_TTL_MS);
+});
+
+// src/utils/telemetry/bigqueryExporter.ts
+class BigQueryMetricsExporter {
+  endpoint;
+  timeout;
+  pendingExports = [];
+  isShutdown = false;
+  constructor(options = {}) {
+    const defaultEndpoint = "https://api.anthropic.com/api/claude_code/metrics";
+    if (process.env.USER_TYPE === "ant" && process.env.ANT_CLAUDE_CODE_METRICS_ENDPOINT) {
+      this.endpoint = process.env.ANT_CLAUDE_CODE_METRICS_ENDPOINT + "/api/claude_code/metrics";
+    } else {
+      this.endpoint = defaultEndpoint;
+    }
+    this.timeout = options.timeout || 5000;
+  }
+  async export(metrics, resultCallback) {
+    if (this.isShutdown) {
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: new Error("Exporter has been shutdown")
+      });
+      return;
+    }
+    const exportPromise = this.doExport(metrics, resultCallback);
+    this.pendingExports.push(exportPromise);
+    exportPromise.finally(() => {
+      const index = this.pendingExports.indexOf(exportPromise);
+      if (index > -1) {
+        this.pendingExports.splice(index, 1);
+      }
+    });
+  }
+  async doExport(metrics, resultCallback) {
+    try {
+      const hasTrust = checkHasTrustDialogAccepted() || getIsNonInteractiveSession();
+      if (!hasTrust) {
+        logForDebugging("BigQuery metrics export: trust not established, skipping");
+        resultCallback({ code: ExportResultCode.SUCCESS });
+        return;
+      }
+      const metricsStatus = await checkMetricsEnabled();
+      if (!metricsStatus.enabled) {
+        logForDebugging("Metrics export disabled by organization setting");
+        resultCallback({ code: ExportResultCode.SUCCESS });
+        return;
+      }
+      const payload = this.transformMetricsForInternal(metrics);
+      const authResult = getAuthHeaders();
+      if (authResult.error) {
+        logForDebugging(`Metrics export failed: ${authResult.error}`);
+        resultCallback({
+          code: ExportResultCode.FAILED,
+          error: new Error(authResult.error)
+        });
+        return;
+      }
+      const headers = {
+        "Content-Type": "application/json",
+        "User-Agent": getClaudeCodeUserAgent(),
+        ...authResult.headers
+      };
+      const response = await axios_default.post(this.endpoint, payload, {
+        timeout: this.timeout,
+        headers
+      });
+      logForDebugging("BigQuery metrics exported successfully");
+      logForDebugging(`BigQuery API Response: ${jsonStringify(response.data, null, 2)}`);
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    } catch (error) {
+      logForDebugging(`BigQuery metrics export failed: ${errorMessage(error)}`);
+      logError(error);
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: toError(error)
+      });
+    }
+  }
+  transformMetricsForInternal(metrics) {
+    const attrs = metrics.resource.attributes;
+    const resourceAttributes = {
+      "service.name": attrs["service.name"] || "claude-code",
+      "service.version": attrs["service.version"] || "unknown",
+      "os.type": attrs["os.type"] || "unknown",
+      "os.version": attrs["os.version"] || "unknown",
+      "host.arch": attrs["host.arch"] || "unknown",
+      "aggregation.temporality": this.selectAggregationTemporality() === AggregationTemporality.DELTA ? "delta" : "cumulative"
+    };
+    if (attrs["wsl.version"]) {
+      resourceAttributes["wsl.version"] = attrs["wsl.version"];
+    }
+    if (isClaudeAISubscriber()) {
+      resourceAttributes["user.customer_type"] = "claude_ai";
+      const subscriptionType = getSubscriptionType();
+      if (subscriptionType) {
+        resourceAttributes["user.subscription_type"] = subscriptionType;
+      }
+    } else {
+      resourceAttributes["user.customer_type"] = "api";
+    }
+    const transformed = {
+      resource_attributes: resourceAttributes,
+      metrics: metrics.scopeMetrics.flatMap((scopeMetric) => scopeMetric.metrics.map((metric) => ({
+        name: metric.descriptor.name,
+        description: metric.descriptor.description,
+        unit: metric.descriptor.unit,
+        data_points: this.extractDataPoints(metric)
+      })))
+    };
+    return transformed;
+  }
+  extractDataPoints(metric) {
+    const dataPoints = metric.dataPoints || [];
+    return dataPoints.filter((point) => typeof point.value === "number").map((point) => ({
+      attributes: this.convertAttributes(point.attributes),
+      value: point.value,
+      timestamp: this.hrTimeToISOString(point.endTime || point.startTime || [Date.now() / 1000, 0])
+    }));
+  }
+  async shutdown() {
+    this.isShutdown = true;
+    await this.forceFlush();
+    logForDebugging("BigQuery metrics exporter shutdown complete");
+  }
+  async forceFlush() {
+    await Promise.all(this.pendingExports);
+    logForDebugging("BigQuery metrics exporter flush complete");
+  }
+  convertAttributes(attributes) {
+    const result = {};
+    if (attributes) {
+      for (const [key, value] of Object.entries(attributes)) {
+        if (value !== undefined && value !== null) {
+          result[key] = String(value);
+        }
+      }
+    }
+    return result;
+  }
+  hrTimeToISOString(hrTime) {
+    const [seconds, nanoseconds] = hrTime;
+    const date = new Date(seconds * 1000 + nanoseconds / 1e6);
+    return date.toISOString();
+  }
+  selectAggregationTemporality() {
+    return AggregationTemporality.DELTA;
+  }
+}
+var init_bigqueryExporter = __esm(() => {
+  init_esm();
+  init_esm5();
+  init_axios();
+  init_metricsOptOut();
+  init_state();
+  init_auth();
+  init_config();
+  init_debug();
+  init_errors();
+  init_http();
+  init_log();
+  init_slowOperations();
+  init_userAgent();
+});
+
+// src/utils/telemetry/logger.ts
+class ClaudeCodeDiagLogger {
+  error(message, ..._) {
+    logError(new Error(message));
+    logForDebugging(`[3P telemetry] OTEL diag error: ${message}`, {
+      level: "error"
+    });
+  }
+  warn(message, ..._) {
+    logError(new Error(message));
+    logForDebugging(`[3P telemetry] OTEL diag warn: ${message}`, {
+      level: "warn"
+    });
+  }
+  info(_message, ..._args) {
+    return;
+  }
+  debug(_message, ..._args) {
+    return;
+  }
+  verbose(_message, ..._args) {
+    return;
+  }
+}
+var init_logger = __esm(() => {
+  init_debug();
+  init_log();
+});
+
+// src/utils/telemetry/instrumentation.ts
+function telemetryTimeout(ms, message) {
+  return new Promise((_, reject) => {
+    setTimeout((rej, msg) => rej(new TelemetryTimeoutError(msg)), ms, reject, message).unref();
+  });
+}
+function bootstrapTelemetry() {
+  if (process.env.USER_TYPE === "ant") {
+    if (process.env.ANT_OTEL_METRICS_EXPORTER) {
+      process.env.OTEL_METRICS_EXPORTER = process.env.ANT_OTEL_METRICS_EXPORTER;
+    }
+    if (process.env.ANT_OTEL_LOGS_EXPORTER) {
+      process.env.OTEL_LOGS_EXPORTER = process.env.ANT_OTEL_LOGS_EXPORTER;
+    }
+    if (process.env.ANT_OTEL_TRACES_EXPORTER) {
+      process.env.OTEL_TRACES_EXPORTER = process.env.ANT_OTEL_TRACES_EXPORTER;
+    }
+    if (process.env.ANT_OTEL_EXPORTER_OTLP_PROTOCOL) {
+      process.env.OTEL_EXPORTER_OTLP_PROTOCOL = process.env.ANT_OTEL_EXPORTER_OTLP_PROTOCOL;
+    }
+    if (process.env.ANT_OTEL_EXPORTER_OTLP_ENDPOINT) {
+      process.env.OTEL_EXPORTER_OTLP_ENDPOINT = process.env.ANT_OTEL_EXPORTER_OTLP_ENDPOINT;
+    }
+    if (process.env.ANT_OTEL_EXPORTER_OTLP_HEADERS) {
+      process.env.OTEL_EXPORTER_OTLP_HEADERS = process.env.ANT_OTEL_EXPORTER_OTLP_HEADERS;
+    }
+  }
+  if (!process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE) {
+    process.env.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE = "delta";
+  }
+}
+function parseExporterTypes(value) {
+  return (value || "").trim().split(",").filter(Boolean).map((t) => t.trim()).filter((t) => t !== "none");
+}
+async function getOtlpReaders() {
+  const exporterTypes = parseExporterTypes(process.env.OTEL_METRICS_EXPORTER);
+  const exportInterval = parseInt(process.env.OTEL_METRIC_EXPORT_INTERVAL || DEFAULT_METRICS_EXPORT_INTERVAL_MS.toString());
+  const exporters = [];
+  for (const exporterType of exporterTypes) {
+    if (exporterType === "console") {
+      const consoleExporter = new ConsoleMetricExporter;
+      const originalExport = consoleExporter.export.bind(consoleExporter);
+      consoleExporter.export = (metrics, callback) => {
+        if (metrics.resource && metrics.resource.attributes) {
+          logForDebugging(`
+=== Resource Attributes ===`);
+          logForDebugging(jsonStringify(metrics.resource.attributes));
+          logForDebugging(`===========================
+`);
+        }
+        return originalExport(metrics, callback);
+      };
+      exporters.push(consoleExporter);
+    } else if (exporterType === "otlp") {
+      const protocol = process.env.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL?.trim() || process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim();
+      const httpConfig = getOTLPExporterConfig();
+      switch (protocol) {
+        case "grpc": {
+          const { OTLPMetricExporter } = await import("./chunk-4b5peb6p.js").then((m)=>__toESM(m.default,1));
+          exporters.push(new OTLPMetricExporter);
+          break;
+        }
+        case "http/json": {
+          const { OTLPMetricExporter } = await import("./chunk-zv0txvbs.js").then((m)=>__toESM(m.default,1));
+          exporters.push(new OTLPMetricExporter(httpConfig));
+          break;
+        }
+        case "http/protobuf": {
+          const { OTLPMetricExporter } = await import("./chunk-qrz3b0e1.js");
+          exporters.push(new OTLPMetricExporter(httpConfig));
+          break;
+        }
+        default:
+          throw new Error(`Unknown protocol set in OTEL_EXPORTER_OTLP_METRICS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`);
+      }
+    } else if (exporterType === "prometheus") {
+      const { PrometheusExporter } = await import("./chunk-wpqynh28.js").then((m)=>__toESM(m.default,1));
+      exporters.push(new PrometheusExporter);
+    } else {
+      throw new Error(`Unknown exporter type set in OTEL_EXPORTER_OTLP_METRICS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${exporterType}`);
+    }
+  }
+  return exporters.map((exporter) => {
+    if ("export" in exporter) {
+      return new PeriodicExportingMetricReader({
+        exporter,
+        exportIntervalMillis: exportInterval
+      });
+    }
+    return exporter;
+  });
+}
+async function getOtlpLogExporters() {
+  const exporterTypes = parseExporterTypes(process.env.OTEL_LOGS_EXPORTER);
+  const protocol = process.env.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL?.trim() || process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim();
+  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  logForDebugging(`[3P telemetry] getOtlpLogExporters: types=${jsonStringify(exporterTypes)}, protocol=${protocol}, endpoint=${endpoint}`);
+  const exporters = [];
+  for (const exporterType of exporterTypes) {
+    if (exporterType === "console") {
+      exporters.push(new ConsoleLogRecordExporter);
+    } else if (exporterType === "otlp") {
+      const httpConfig = getOTLPExporterConfig();
+      switch (protocol) {
+        case "grpc": {
+          const { OTLPLogExporter } = await import("./chunk-temv6q01.js").then((m)=>__toESM(m.default,1));
+          exporters.push(new OTLPLogExporter);
+          break;
+        }
+        case "http/json": {
+          const { OTLPLogExporter } = await import("./chunk-0zkw14gq.js");
+          exporters.push(new OTLPLogExporter(httpConfig));
+          break;
+        }
+        case "http/protobuf": {
+          const { OTLPLogExporter } = await import("./chunk-7q7h7msb.js");
+          exporters.push(new OTLPLogExporter(httpConfig));
+          break;
+        }
+        default:
+          throw new Error(`Unknown protocol set in OTEL_EXPORTER_OTLP_LOGS_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`);
+      }
+    } else {
+      throw new Error(`Unknown exporter type set in OTEL_LOGS_EXPORTER env var: ${exporterType}`);
+    }
+  }
+  return exporters;
+}
+async function getOtlpTraceExporters() {
+  const exporterTypes = parseExporterTypes(process.env.OTEL_TRACES_EXPORTER);
+  const exporters = [];
+  for (const exporterType of exporterTypes) {
+    if (exporterType === "console") {
+      exporters.push(new ConsoleSpanExporter);
+    } else if (exporterType === "otlp") {
+      const protocol = process.env.OTEL_EXPORTER_OTLP_TRACES_PROTOCOL?.trim() || process.env.OTEL_EXPORTER_OTLP_PROTOCOL?.trim();
+      const httpConfig = getOTLPExporterConfig();
+      switch (protocol) {
+        case "grpc": {
+          const { OTLPTraceExporter } = await import("./chunk-t260g32y.js").then((m)=>__toESM(m.default,1));
+          exporters.push(new OTLPTraceExporter);
+          break;
+        }
+        case "http/json": {
+          const { OTLPTraceExporter } = await import("./chunk-fx0xd0ex.js");
+          exporters.push(new OTLPTraceExporter(httpConfig));
+          break;
+        }
+        case "http/protobuf": {
+          const { OTLPTraceExporter } = await import("./chunk-hxc5rbra.js");
+          exporters.push(new OTLPTraceExporter(httpConfig));
+          break;
+        }
+        default:
+          throw new Error(`Unknown protocol set in OTEL_EXPORTER_OTLP_TRACES_PROTOCOL or OTEL_EXPORTER_OTLP_PROTOCOL env var: ${protocol}`);
+      }
+    } else {
+      throw new Error(`Unknown exporter type set in OTEL_TRACES_EXPORTER env var: ${exporterType}`);
+    }
+  }
+  return exporters;
+}
+function isTelemetryEnabled() {
+  return isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_TELEMETRY);
+}
+function getBigQueryExportingReader() {
+  const bigqueryExporter = new BigQueryMetricsExporter;
+  return new PeriodicExportingMetricReader({
+    exporter: bigqueryExporter,
+    exportIntervalMillis: 300000
+  });
+}
+function isBigQueryMetricsEnabled() {
+  const subscriptionType = getSubscriptionType();
+  const isC4EOrTeamUser = isClaudeAISubscriber() && (subscriptionType === "enterprise" || subscriptionType === "team");
+  return is1PApiCustomer() || isC4EOrTeamUser;
+}
+async function initializeBetaTracing(resource) {
+  const endpoint = process.env.BETA_TRACING_ENDPOINT;
+  if (!endpoint) {
+    return;
+  }
+  const [{ OTLPTraceExporter }, { OTLPLogExporter }] = await Promise.all([
+    import("./chunk-fx0xd0ex.js"),
+    import("./chunk-0zkw14gq.js")
+  ]);
+  const httpConfig = {
+    url: `${endpoint}/v1/traces`
+  };
+  const logHttpConfig = {
+    url: `${endpoint}/v1/logs`
+  };
+  const traceExporter = new OTLPTraceExporter(httpConfig);
+  const spanProcessor = new BatchSpanProcessor(traceExporter, {
+    scheduledDelayMillis: DEFAULT_TRACES_EXPORT_INTERVAL_MS
+  });
+  const tracerProvider = new BasicTracerProvider({
+    resource,
+    spanProcessors: [spanProcessor]
+  });
+  import_api7.trace.setGlobalTracerProvider(tracerProvider);
+  setTracerProvider(tracerProvider);
+  const logExporter = new OTLPLogExporter(logHttpConfig);
+  const loggerProvider = new LoggerProvider({
+    resource,
+    processors: [
+      new BatchLogRecordProcessor(logExporter, {
+        scheduledDelayMillis: DEFAULT_LOGS_EXPORT_INTERVAL_MS
+      })
+    ]
+  });
+  import_api_logs.logs.setGlobalLoggerProvider(loggerProvider);
+  setLoggerProvider(loggerProvider);
+  const eventLogger = import_api_logs.logs.getLogger("com.anthropic.claude_code.events", "2.1.888");
+  setEventLogger(eventLogger);
+  process.on("beforeExit", async () => {
+    await loggerProvider?.forceFlush();
+    await tracerProvider?.forceFlush();
+  });
+  process.on("exit", () => {
+    loggerProvider?.forceFlush();
+    tracerProvider?.forceFlush();
+  });
+}
+async function initializeTelemetry() {
+  profileCheckpoint("telemetry_init_start");
+  bootstrapTelemetry();
+  if (getHasFormattedOutput()) {
+    for (const key of [
+      "OTEL_METRICS_EXPORTER",
+      "OTEL_LOGS_EXPORTER",
+      "OTEL_TRACES_EXPORTER"
+    ]) {
+      const v = process.env[key];
+      if (v?.includes("console")) {
+        process.env[key] = v.split(",").map((s) => s.trim()).filter((s) => s !== "console").join(",");
+      }
+    }
+  }
+  import_api7.diag.setLogger(new ClaudeCodeDiagLogger, import_api7.DiagLogLevel.ERROR);
+  initializePerfettoTracing();
+  const readers = [];
+  const telemetryEnabled = isTelemetryEnabled();
+  logForDebugging(`[3P telemetry] isTelemetryEnabled=${telemetryEnabled} (CLAUDE_CODE_ENABLE_TELEMETRY=${process.env.CLAUDE_CODE_ENABLE_TELEMETRY})`);
+  if (telemetryEnabled) {
+    readers.push(...await getOtlpReaders());
+  }
+  if (isBigQueryMetricsEnabled()) {
+    readers.push(getBigQueryExportingReader());
+  }
+  const platform = getPlatform();
+  const baseAttributes = {
+    [import_semantic_conventions.ATTR_SERVICE_NAME]: "claude-code",
+    [import_semantic_conventions.ATTR_SERVICE_VERSION]: "2.1.888"
+  };
+  if (platform === "wsl") {
+    const wslVersion = getWslVersion();
+    if (wslVersion) {
+      baseAttributes["wsl.version"] = wslVersion;
+    }
+  }
+  const baseResource = resourceFromAttributes(baseAttributes);
+  const osResource = resourceFromAttributes(osDetector.detect().attributes || {});
+  const hostDetected = hostDetector.detect();
+  const hostArchAttributes = hostDetected.attributes?.[import_semantic_conventions.SEMRESATTRS_HOST_ARCH] ? {
+    [import_semantic_conventions.SEMRESATTRS_HOST_ARCH]: hostDetected.attributes[import_semantic_conventions.SEMRESATTRS_HOST_ARCH]
+  } : {};
+  const hostArchResource = resourceFromAttributes(hostArchAttributes);
+  const envResource = resourceFromAttributes(envDetector.detect().attributes || {});
+  const resource = baseResource.merge(osResource).merge(hostArchResource).merge(envResource);
+  if (isBetaTracingEnabled()) {
+    initializeBetaTracing(resource).catch((e) => logForDebugging(`Beta tracing init failed: ${e}`, { level: "error" }));
+    const meterProvider2 = new MeterProvider({
+      resource,
+      views: [],
+      readers
+    });
+    setMeterProvider(meterProvider2);
+    const shutdownTelemetry2 = async () => {
+      const timeoutMs = parseInt(process.env.CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS || "2000");
+      try {
+        endInteractionSpan();
+        const loggerProvider = getLoggerProvider();
+        const tracerProvider = getTracerProvider();
+        const chains = [meterProvider2.shutdown()];
+        if (loggerProvider) {
+          chains.push(loggerProvider.forceFlush().then(() => loggerProvider.shutdown()));
+        }
+        if (tracerProvider) {
+          chains.push(tracerProvider.forceFlush().then(() => tracerProvider.shutdown()));
+        }
+        await Promise.race([
+          Promise.all(chains),
+          telemetryTimeout(timeoutMs, "OpenTelemetry shutdown timeout")
+        ]);
+      } catch {}
+    };
+    registerCleanup(shutdownTelemetry2);
+    return meterProvider2.getMeter("com.anthropic.claude_code", "2.1.888");
+  }
+  const meterProvider = new MeterProvider({
+    resource,
+    views: [],
+    readers
+  });
+  setMeterProvider(meterProvider);
+  if (telemetryEnabled) {
+    const logExporters = await getOtlpLogExporters();
+    logForDebugging(`[3P telemetry] Created ${logExporters.length} log exporter(s)`);
+    if (logExporters.length > 0) {
+      const loggerProvider = new LoggerProvider({
+        resource,
+        processors: logExporters.map((exporter) => new BatchLogRecordProcessor(exporter, {
+          scheduledDelayMillis: parseInt(process.env.OTEL_LOGS_EXPORT_INTERVAL || DEFAULT_LOGS_EXPORT_INTERVAL_MS.toString())
+        }))
+      });
+      import_api_logs.logs.setGlobalLoggerProvider(loggerProvider);
+      setLoggerProvider(loggerProvider);
+      const eventLogger = import_api_logs.logs.getLogger("com.anthropic.claude_code.events", "2.1.888");
+      setEventLogger(eventLogger);
+      logForDebugging("[3P telemetry] Event logger set successfully");
+      process.on("beforeExit", async () => {
+        await loggerProvider?.forceFlush();
+        const tracerProvider = getTracerProvider();
+        await tracerProvider?.forceFlush();
+      });
+      process.on("exit", () => {
+        loggerProvider?.forceFlush();
+        getTracerProvider()?.forceFlush();
+      });
+    }
+  }
+  if (telemetryEnabled && isEnhancedTelemetryEnabled()) {
+    const traceExporters = await getOtlpTraceExporters();
+    if (traceExporters.length > 0) {
+      const spanProcessors = traceExporters.map((exporter) => new BatchSpanProcessor(exporter, {
+        scheduledDelayMillis: parseInt(process.env.OTEL_TRACES_EXPORT_INTERVAL || DEFAULT_TRACES_EXPORT_INTERVAL_MS.toString())
+      }));
+      const tracerProvider = new BasicTracerProvider({
+        resource,
+        spanProcessors
+      });
+      import_api7.trace.setGlobalTracerProvider(tracerProvider);
+      setTracerProvider(tracerProvider);
+    }
+  }
+  const shutdownTelemetry = async () => {
+    const timeoutMs = parseInt(process.env.CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS || "2000");
+    try {
+      endInteractionSpan();
+      const shutdownPromises = [meterProvider.shutdown()];
+      const loggerProvider = getLoggerProvider();
+      if (loggerProvider) {
+        shutdownPromises.push(loggerProvider.shutdown());
+      }
+      const tracerProvider = getTracerProvider();
+      if (tracerProvider) {
+        shutdownPromises.push(tracerProvider.shutdown());
+      }
+      await Promise.race([
+        Promise.all(shutdownPromises),
+        telemetryTimeout(timeoutMs, "OpenTelemetry shutdown timeout")
+      ]);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timeout")) {
+        logForDebugging(`
+OpenTelemetry telemetry flush timed out after ${timeoutMs}ms
+
+To resolve this issue, you can:
+1. Increase the timeout by setting CLAUDE_CODE_OTEL_SHUTDOWN_TIMEOUT_MS env var (e.g., 5000 for 5 seconds)
+2. Check if your OpenTelemetry backend is experiencing scalability issues
+3. Disable OpenTelemetry by unsetting CLAUDE_CODE_ENABLE_TELEMETRY env var
+
+Current timeout: ${timeoutMs}ms
+`, { level: "error" });
+      }
+      throw error;
+    }
+  };
+  registerCleanup(shutdownTelemetry);
+  return meterProvider.getMeter("com.anthropic.claude_code", "2.1.888");
+}
+async function flushTelemetry() {
+  const meterProvider = getMeterProvider();
+  if (!meterProvider) {
+    return;
+  }
+  const timeoutMs = parseInt(process.env.CLAUDE_CODE_OTEL_FLUSH_TIMEOUT_MS || "5000");
+  try {
+    const flushPromises = [meterProvider.forceFlush()];
+    const loggerProvider = getLoggerProvider();
+    if (loggerProvider) {
+      flushPromises.push(loggerProvider.forceFlush());
+    }
+    const tracerProvider = getTracerProvider();
+    if (tracerProvider) {
+      flushPromises.push(tracerProvider.forceFlush());
+    }
+    await Promise.race([
+      Promise.all(flushPromises),
+      telemetryTimeout(timeoutMs, "OpenTelemetry flush timeout")
+    ]);
+    logForDebugging("Telemetry flushed successfully");
+  } catch (error) {
+    if (error instanceof TelemetryTimeoutError) {
+      logForDebugging(`Telemetry flush timed out after ${timeoutMs}ms. Some metrics may not be exported.`, { level: "warn" });
+    } else {
+      logForDebugging(`Telemetry flush failed: ${errorMessage(error)}`, {
+        level: "error"
+      });
+    }
+  }
+}
+function parseOtelHeadersEnvVar() {
+  const headers = {};
+  const envHeaders = process.env.OTEL_EXPORTER_OTLP_HEADERS;
+  if (envHeaders) {
+    for (const pair of envHeaders.split(",")) {
+      const [key, ...valueParts] = pair.split("=");
+      if (key && valueParts.length > 0) {
+        headers[key.trim()] = valueParts.join("=").trim();
+      }
+    }
+  }
+  return headers;
+}
+function getOTLPExporterConfig() {
+  const proxyUrl = getProxyUrl();
+  const mtlsConfig = getMTLSConfig();
+  const settings = getSettings_DEPRECATED();
+  const config = {};
+  const staticHeaders = parseOtelHeadersEnvVar();
+  if (settings?.otelHeadersHelper) {
+    config.headers = async () => {
+      const dynamicHeaders = getOtelHeadersFromHelper();
+      return { ...staticHeaders, ...dynamicHeaders };
+    };
+  } else if (Object.keys(staticHeaders).length > 0) {
+    config.headers = async () => staticHeaders;
+  }
+  const otelEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  if (!proxyUrl || otelEndpoint && shouldBypassProxy(otelEndpoint)) {
+    const caCerts2 = getCACertificates();
+    if (mtlsConfig || caCerts2) {
+      config.httpAgentOptions = {
+        ...mtlsConfig,
+        ...caCerts2 && { ca: caCerts2 }
+      };
+    }
+    return config;
+  }
+  const caCerts = getCACertificates();
+  const agentFactory = (_protocol) => {
+    const proxyAgent = mtlsConfig || caCerts ? new HttpsProxyAgent(proxyUrl, {
+      ...mtlsConfig && {
+        cert: mtlsConfig.cert,
+        key: mtlsConfig.key,
+        passphrase: mtlsConfig.passphrase
+      },
+      ...caCerts && { ca: caCerts }
+    }) : new HttpsProxyAgent(proxyUrl);
+    return proxyAgent;
+  };
+  config.httpAgentOptions = agentFactory;
+  return config;
+}
+var import_api7, import_api_logs, import_semantic_conventions, DEFAULT_METRICS_EXPORT_INTERVAL_MS = 60000, DEFAULT_LOGS_EXPORT_INTERVAL_MS = 5000, DEFAULT_TRACES_EXPORT_INTERVAL_MS = 5000, TelemetryTimeoutError;
+var init_instrumentation = __esm(() => {
+  init_esm2();
+  init_esm3();
+  init_esm5();
+  init_esm4();
+  init_dist();
+  init_state();
+  init_auth();
+  init_platform();
+  init_caCerts();
+  init_cleanupRegistry();
+  init_debug();
+  init_envUtils();
+  init_errors();
+  init_mtls();
+  init_proxy();
+  init_settings();
+  init_slowOperations();
+  init_startupProfiler();
+  init_betaSessionTracing();
+  init_bigqueryExporter();
+  init_logger();
+  init_perfettoTracing();
+  init_sessionTracing();
+  import_api7 = __toESM(require_src(), 1);
+  import_api_logs = __toESM(require_src3(), 1);
+  import_semantic_conventions = __toESM(require_src2(), 1);
+  TelemetryTimeoutError = class TelemetryTimeoutError extends Error {
+  };
+});
+init_instrumentation();
+
+export {
+  parseExporterTypes,
+  isTelemetryEnabled,
+  initializeTelemetry,
+  flushTelemetry,
+  bootstrapTelemetry
+};